import Check from "../Core/Check.js";
|
import ComponentDatatype from "../Core/ComponentDatatype.js";
|
import defaultValue from "../Core/defaultValue.js";
|
import defined from "../Core/defined.js";
|
import destroyObject from "../Core/destroyObject.js";
|
import DeveloperError from "../Core/DeveloperError.js";
|
import CesiumMath from "../Core/Math.js";
|
import Buffer from "./Buffer.js";
|
import BufferUsage from "./BufferUsage.js";
|
import VertexArray from "./VertexArray.js";
|
|
/**
|
* @private
|
*/
|
function VertexArrayFacade(context, attributes, sizeInVertices, instanced) {
|
//>>includeStart('debug', pragmas.debug);
|
Check.defined("context", context);
|
if (!attributes || attributes.length === 0) {
|
throw new DeveloperError("At least one attribute is required.");
|
}
|
//>>includeEnd('debug');
|
|
var attrs = VertexArrayFacade._verifyAttributes(attributes);
|
sizeInVertices = defaultValue(sizeInVertices, 0);
|
var precreatedAttributes = [];
|
var attributesByUsage = {};
|
var attributesForUsage;
|
var usage;
|
|
// Bucket the attributes by usage.
|
var length = attrs.length;
|
for (var i = 0; i < length; ++i) {
|
var attribute = attrs[i];
|
|
// If the attribute already has a vertex buffer, we do not need
|
// to manage a vertex buffer or typed array for it.
|
if (attribute.vertexBuffer) {
|
precreatedAttributes.push(attribute);
|
continue;
|
}
|
|
usage = attribute.usage;
|
attributesForUsage = attributesByUsage[usage];
|
if (!defined(attributesForUsage)) {
|
attributesForUsage = attributesByUsage[usage] = [];
|
}
|
|
attributesForUsage.push(attribute);
|
}
|
|
// A function to sort attributes by the size of their components. From left to right, a vertex
|
// stores floats, shorts, and then bytes.
|
function compare(left, right) {
|
return (
|
ComponentDatatype.getSizeInBytes(right.componentDatatype) -
|
ComponentDatatype.getSizeInBytes(left.componentDatatype)
|
);
|
}
|
|
this._allBuffers = [];
|
|
for (usage in attributesByUsage) {
|
if (attributesByUsage.hasOwnProperty(usage)) {
|
attributesForUsage = attributesByUsage[usage];
|
|
attributesForUsage.sort(compare);
|
var vertexSizeInBytes = VertexArrayFacade._vertexSizeInBytes(
|
attributesForUsage
|
);
|
|
var bufferUsage = attributesForUsage[0].usage;
|
|
var buffer = {
|
vertexSizeInBytes: vertexSizeInBytes,
|
vertexBuffer: undefined,
|
usage: bufferUsage,
|
needsCommit: false,
|
arrayBuffer: undefined,
|
arrayViews: VertexArrayFacade._createArrayViews(
|
attributesForUsage,
|
vertexSizeInBytes
|
),
|
};
|
|
this._allBuffers.push(buffer);
|
}
|
}
|
|
this._size = 0;
|
this._instanced = defaultValue(instanced, false);
|
|
this._precreated = precreatedAttributes;
|
this._context = context;
|
|
this.writers = undefined;
|
this.va = undefined;
|
|
this.resize(sizeInVertices);
|
}
|
VertexArrayFacade._verifyAttributes = function (attributes) {
|
var attrs = [];
|
|
for (var i = 0; i < attributes.length; ++i) {
|
var attribute = attributes[i];
|
|
var attr = {
|
index: defaultValue(attribute.index, i),
|
enabled: defaultValue(attribute.enabled, true),
|
componentsPerAttribute: attribute.componentsPerAttribute,
|
componentDatatype: defaultValue(
|
attribute.componentDatatype,
|
ComponentDatatype.FLOAT
|
),
|
normalize: defaultValue(attribute.normalize, false),
|
|
// There will be either a vertexBuffer or an [optional] usage.
|
vertexBuffer: attribute.vertexBuffer,
|
usage: defaultValue(attribute.usage, BufferUsage.STATIC_DRAW),
|
};
|
attrs.push(attr);
|
|
//>>includeStart('debug', pragmas.debug);
|
if (
|
attr.componentsPerAttribute !== 1 &&
|
attr.componentsPerAttribute !== 2 &&
|
attr.componentsPerAttribute !== 3 &&
|
attr.componentsPerAttribute !== 4
|
) {
|
throw new DeveloperError(
|
"attribute.componentsPerAttribute must be in the range [1, 4]."
|
);
|
}
|
|
var datatype = attr.componentDatatype;
|
if (!ComponentDatatype.validate(datatype)) {
|
throw new DeveloperError(
|
"Attribute must have a valid componentDatatype or not specify it."
|
);
|
}
|
|
if (!BufferUsage.validate(attr.usage)) {
|
throw new DeveloperError(
|
"Attribute must have a valid usage or not specify it."
|
);
|
}
|
//>>includeEnd('debug');
|
}
|
|
// Verify all attribute names are unique.
|
var uniqueIndices = new Array(attrs.length);
|
for (var j = 0; j < attrs.length; ++j) {
|
var currentAttr = attrs[j];
|
var index = currentAttr.index;
|
//>>includeStart('debug', pragmas.debug);
|
if (uniqueIndices[index]) {
|
throw new DeveloperError(
|
"Index " + index + " is used by more than one attribute."
|
);
|
}
|
//>>includeEnd('debug');
|
uniqueIndices[index] = true;
|
}
|
|
return attrs;
|
};
|
|
VertexArrayFacade._vertexSizeInBytes = function (attributes) {
|
var sizeInBytes = 0;
|
|
var length = attributes.length;
|
for (var i = 0; i < length; ++i) {
|
var attribute = attributes[i];
|
sizeInBytes +=
|
attribute.componentsPerAttribute *
|
ComponentDatatype.getSizeInBytes(attribute.componentDatatype);
|
}
|
|
var maxComponentSizeInBytes =
|
length > 0
|
? ComponentDatatype.getSizeInBytes(attributes[0].componentDatatype)
|
: 0; // Sorted by size
|
var remainder =
|
maxComponentSizeInBytes > 0 ? sizeInBytes % maxComponentSizeInBytes : 0;
|
var padding = remainder === 0 ? 0 : maxComponentSizeInBytes - remainder;
|
sizeInBytes += padding;
|
|
return sizeInBytes;
|
};
|
|
VertexArrayFacade._createArrayViews = function (attributes, vertexSizeInBytes) {
|
var views = [];
|
var offsetInBytes = 0;
|
|
var length = attributes.length;
|
for (var i = 0; i < length; ++i) {
|
var attribute = attributes[i];
|
var componentDatatype = attribute.componentDatatype;
|
|
views.push({
|
index: attribute.index,
|
enabled: attribute.enabled,
|
componentsPerAttribute: attribute.componentsPerAttribute,
|
componentDatatype: componentDatatype,
|
normalize: attribute.normalize,
|
|
offsetInBytes: offsetInBytes,
|
vertexSizeInComponentType:
|
vertexSizeInBytes / ComponentDatatype.getSizeInBytes(componentDatatype),
|
|
view: undefined,
|
});
|
|
offsetInBytes +=
|
attribute.componentsPerAttribute *
|
ComponentDatatype.getSizeInBytes(componentDatatype);
|
}
|
|
return views;
|
};
|
|
/**
|
* Invalidates writers. Can't render again until commit is called.
|
*/
|
VertexArrayFacade.prototype.resize = function (sizeInVertices) {
|
this._size = sizeInVertices;
|
|
var allBuffers = this._allBuffers;
|
this.writers = [];
|
|
for (var i = 0, len = allBuffers.length; i < len; ++i) {
|
var buffer = allBuffers[i];
|
|
VertexArrayFacade._resize(buffer, this._size);
|
|
// Reserving invalidates the writers, so if client's cache them, they need to invalidate their cache.
|
VertexArrayFacade._appendWriters(this.writers, buffer);
|
}
|
|
// VAs are recreated next time commit is called.
|
destroyVA(this);
|
};
|
|
VertexArrayFacade._resize = function (buffer, size) {
|
if (buffer.vertexSizeInBytes > 0) {
|
// Create larger array buffer
|
var arrayBuffer = new ArrayBuffer(size * buffer.vertexSizeInBytes);
|
|
// Copy contents from previous array buffer
|
if (defined(buffer.arrayBuffer)) {
|
var destView = new Uint8Array(arrayBuffer);
|
var sourceView = new Uint8Array(buffer.arrayBuffer);
|
var sourceLength = sourceView.length;
|
for (var j = 0; j < sourceLength; ++j) {
|
destView[j] = sourceView[j];
|
}
|
}
|
|
// Create typed views into the new array buffer
|
var views = buffer.arrayViews;
|
var length = views.length;
|
for (var i = 0; i < length; ++i) {
|
var view = views[i];
|
view.view = ComponentDatatype.createArrayBufferView(
|
view.componentDatatype,
|
arrayBuffer,
|
view.offsetInBytes
|
);
|
}
|
|
buffer.arrayBuffer = arrayBuffer;
|
}
|
};
|
|
var createWriters = [
|
// 1 component per attribute
|
function (buffer, view, vertexSizeInComponentType) {
|
return function (index, attribute) {
|
view[index * vertexSizeInComponentType] = attribute;
|
buffer.needsCommit = true;
|
};
|
},
|
|
// 2 component per attribute
|
function (buffer, view, vertexSizeInComponentType) {
|
return function (index, component0, component1) {
|
var i = index * vertexSizeInComponentType;
|
view[i] = component0;
|
view[i + 1] = component1;
|
buffer.needsCommit = true;
|
};
|
},
|
|
// 3 component per attribute
|
function (buffer, view, vertexSizeInComponentType) {
|
return function (index, component0, component1, component2) {
|
var i = index * vertexSizeInComponentType;
|
view[i] = component0;
|
view[i + 1] = component1;
|
view[i + 2] = component2;
|
buffer.needsCommit = true;
|
};
|
},
|
|
// 4 component per attribute
|
function (buffer, view, vertexSizeInComponentType) {
|
return function (index, component0, component1, component2, component3) {
|
var i = index * vertexSizeInComponentType;
|
view[i] = component0;
|
view[i + 1] = component1;
|
view[i + 2] = component2;
|
view[i + 3] = component3;
|
buffer.needsCommit = true;
|
};
|
},
|
];
|
|
VertexArrayFacade._appendWriters = function (writers, buffer) {
|
var arrayViews = buffer.arrayViews;
|
var length = arrayViews.length;
|
for (var i = 0; i < length; ++i) {
|
var arrayView = arrayViews[i];
|
writers[arrayView.index] = createWriters[
|
arrayView.componentsPerAttribute - 1
|
](buffer, arrayView.view, arrayView.vertexSizeInComponentType);
|
}
|
};
|
|
VertexArrayFacade.prototype.commit = function (indexBuffer) {
|
var recreateVA = false;
|
|
var allBuffers = this._allBuffers;
|
var buffer;
|
var i;
|
var length;
|
|
for (i = 0, length = allBuffers.length; i < length; ++i) {
|
buffer = allBuffers[i];
|
recreateVA = commit(this, buffer) || recreateVA;
|
}
|
|
///////////////////////////////////////////////////////////////////////
|
|
if (recreateVA || !defined(this.va)) {
|
destroyVA(this);
|
var va = (this.va = []);
|
|
var chunkSize = CesiumMath.SIXTY_FOUR_KILOBYTES - 4; // The 65535 index is reserved for primitive restart. Reserve the last 4 indices so that billboard quads are not broken up.
|
var numberOfVertexArrays =
|
defined(indexBuffer) && !this._instanced
|
? Math.ceil(this._size / chunkSize)
|
: 1;
|
for (var k = 0; k < numberOfVertexArrays; ++k) {
|
var attributes = [];
|
for (i = 0, length = allBuffers.length; i < length; ++i) {
|
buffer = allBuffers[i];
|
var offset = k * (buffer.vertexSizeInBytes * chunkSize);
|
VertexArrayFacade._appendAttributes(
|
attributes,
|
buffer,
|
offset,
|
this._instanced
|
);
|
}
|
|
attributes = attributes.concat(this._precreated);
|
|
va.push({
|
va: new VertexArray({
|
context: this._context,
|
attributes: attributes,
|
indexBuffer: indexBuffer,
|
}),
|
indicesCount:
|
1.5 *
|
(k !== numberOfVertexArrays - 1 ? chunkSize : this._size % chunkSize),
|
// TODO: not hardcode 1.5, this assumes 6 indices per 4 vertices (as for Billboard quads).
|
});
|
}
|
}
|
};
|
|
function commit(vertexArrayFacade, buffer) {
|
if (buffer.needsCommit && buffer.vertexSizeInBytes > 0) {
|
buffer.needsCommit = false;
|
|
var vertexBuffer = buffer.vertexBuffer;
|
var vertexBufferSizeInBytes =
|
vertexArrayFacade._size * buffer.vertexSizeInBytes;
|
var vertexBufferDefined = defined(vertexBuffer);
|
if (
|
!vertexBufferDefined ||
|
vertexBuffer.sizeInBytes < vertexBufferSizeInBytes
|
) {
|
if (vertexBufferDefined) {
|
vertexBuffer.destroy();
|
}
|
buffer.vertexBuffer = Buffer.createVertexBuffer({
|
context: vertexArrayFacade._context,
|
typedArray: buffer.arrayBuffer,
|
usage: buffer.usage,
|
});
|
buffer.vertexBuffer.vertexArrayDestroyable = false;
|
|
return true; // Created new vertex buffer
|
}
|
|
buffer.vertexBuffer.copyFromArrayView(buffer.arrayBuffer);
|
}
|
|
return false; // Did not create new vertex buffer
|
}
|
|
VertexArrayFacade._appendAttributes = function (
|
attributes,
|
buffer,
|
vertexBufferOffset,
|
instanced
|
) {
|
var arrayViews = buffer.arrayViews;
|
var length = arrayViews.length;
|
for (var i = 0; i < length; ++i) {
|
var view = arrayViews[i];
|
|
attributes.push({
|
index: view.index,
|
enabled: view.enabled,
|
componentsPerAttribute: view.componentsPerAttribute,
|
componentDatatype: view.componentDatatype,
|
normalize: view.normalize,
|
vertexBuffer: buffer.vertexBuffer,
|
offsetInBytes: vertexBufferOffset + view.offsetInBytes,
|
strideInBytes: buffer.vertexSizeInBytes,
|
instanceDivisor: instanced ? 1 : 0,
|
});
|
}
|
};
|
|
VertexArrayFacade.prototype.subCommit = function (
|
offsetInVertices,
|
lengthInVertices
|
) {
|
//>>includeStart('debug', pragmas.debug);
|
if (offsetInVertices < 0 || offsetInVertices >= this._size) {
|
throw new DeveloperError(
|
"offsetInVertices must be greater than or equal to zero and less than the vertex array size."
|
);
|
}
|
if (offsetInVertices + lengthInVertices > this._size) {
|
throw new DeveloperError(
|
"offsetInVertices + lengthInVertices cannot exceed the vertex array size."
|
);
|
}
|
//>>includeEnd('debug');
|
|
var allBuffers = this._allBuffers;
|
for (var i = 0, len = allBuffers.length; i < len; ++i) {
|
subCommit(allBuffers[i], offsetInVertices, lengthInVertices);
|
}
|
};
|
|
function subCommit(buffer, offsetInVertices, lengthInVertices) {
|
if (buffer.needsCommit && buffer.vertexSizeInBytes > 0) {
|
var byteOffset = buffer.vertexSizeInBytes * offsetInVertices;
|
var byteLength = buffer.vertexSizeInBytes * lengthInVertices;
|
|
// PERFORMANCE_IDEA: If we want to get really crazy, we could consider updating
|
// individual attributes instead of the entire (sub-)vertex.
|
//
|
// PERFORMANCE_IDEA: Does creating the typed view add too much GC overhead?
|
buffer.vertexBuffer.copyFromArrayView(
|
new Uint8Array(buffer.arrayBuffer, byteOffset, byteLength),
|
byteOffset
|
);
|
}
|
}
|
|
VertexArrayFacade.prototype.endSubCommits = function () {
|
var allBuffers = this._allBuffers;
|
|
for (var i = 0, len = allBuffers.length; i < len; ++i) {
|
allBuffers[i].needsCommit = false;
|
}
|
};
|
|
function destroyVA(vertexArrayFacade) {
|
var va = vertexArrayFacade.va;
|
if (!defined(va)) {
|
return;
|
}
|
|
var length = va.length;
|
for (var i = 0; i < length; ++i) {
|
va[i].va.destroy();
|
}
|
|
vertexArrayFacade.va = undefined;
|
}
|
|
VertexArrayFacade.prototype.isDestroyed = function () {
|
return false;
|
};
|
|
VertexArrayFacade.prototype.destroy = function () {
|
var allBuffers = this._allBuffers;
|
for (var i = 0, len = allBuffers.length; i < len; ++i) {
|
var buffer = allBuffers[i];
|
buffer.vertexBuffer = buffer.vertexBuffer && buffer.vertexBuffer.destroy();
|
}
|
|
destroyVA(this);
|
|
return destroyObject(this);
|
};
|
export default VertexArrayFacade;
|
