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 Geometry from '../Core/Geometry.js';
|
import IndexDatatype from '../Core/IndexDatatype.js';
|
import CesiumMath from '../Core/Math.js';
|
import RuntimeError from '../Core/RuntimeError.js';
|
import Buffer from './Buffer.js';
|
import BufferUsage from './BufferUsage.js';
|
import ContextLimits from './ContextLimits.js';
|
|
function addAttribute(attributes, attribute, index, context) {
|
var hasVertexBuffer = defined(attribute.vertexBuffer);
|
var hasValue = defined(attribute.value);
|
var componentsPerAttribute = attribute.value ? attribute.value.length : attribute.componentsPerAttribute;
|
|
//>>includeStart('debug', pragmas.debug);
|
if (!hasVertexBuffer && !hasValue) {
|
throw new DeveloperError('attribute must have a vertexBuffer or a value.');
|
}
|
if (hasVertexBuffer && hasValue) {
|
throw new DeveloperError('attribute cannot have both a vertexBuffer and a value. It must have either a vertexBuffer property defining per-vertex data or a value property defining data for all vertices.');
|
}
|
if ((componentsPerAttribute !== 1) &&
|
(componentsPerAttribute !== 2) &&
|
(componentsPerAttribute !== 3) &&
|
(componentsPerAttribute !== 4)) {
|
if (hasValue) {
|
throw new DeveloperError('attribute.value.length must be in the range [1, 4].');
|
}
|
|
throw new DeveloperError('attribute.componentsPerAttribute must be in the range [1, 4].');
|
}
|
if (defined(attribute.componentDatatype) && !ComponentDatatype.validate(attribute.componentDatatype)) {
|
throw new DeveloperError('attribute must have a valid componentDatatype or not specify it.');
|
}
|
if (defined(attribute.strideInBytes) && (attribute.strideInBytes > 255)) {
|
// WebGL limit. Not in GL ES.
|
throw new DeveloperError('attribute must have a strideInBytes less than or equal to 255 or not specify it.');
|
}
|
if (defined(attribute.instanceDivisor) && (attribute.instanceDivisor > 0) && !context.instancedArrays) {
|
throw new DeveloperError('instanced arrays is not supported');
|
}
|
if (defined(attribute.instanceDivisor) && (attribute.instanceDivisor < 0)) {
|
throw new DeveloperError('attribute must have an instanceDivisor greater than or equal to zero');
|
}
|
if (defined(attribute.instanceDivisor) && hasValue) {
|
throw new DeveloperError('attribute cannot have have an instanceDivisor if it is not backed by a buffer');
|
}
|
if (defined(attribute.instanceDivisor) && (attribute.instanceDivisor > 0) && (attribute.index === 0)) {
|
throw new DeveloperError('attribute zero cannot have an instanceDivisor greater than 0');
|
}
|
//>>includeEnd('debug');
|
|
// Shallow copy the attribute; we do not want to copy the vertex buffer.
|
var attr = {
|
index : defaultValue(attribute.index, index),
|
enabled : defaultValue(attribute.enabled, true),
|
vertexBuffer : attribute.vertexBuffer,
|
value : hasValue ? attribute.value.slice(0) : undefined,
|
componentsPerAttribute : componentsPerAttribute,
|
componentDatatype : defaultValue(attribute.componentDatatype, ComponentDatatype.FLOAT),
|
normalize : defaultValue(attribute.normalize, false),
|
offsetInBytes : defaultValue(attribute.offsetInBytes, 0),
|
strideInBytes : defaultValue(attribute.strideInBytes, 0),
|
instanceDivisor : defaultValue(attribute.instanceDivisor, 0)
|
};
|
|
if (hasVertexBuffer) {
|
// Common case: vertex buffer for per-vertex data
|
attr.vertexAttrib = function(gl) {
|
var index = this.index;
|
gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer._getBuffer());
|
gl.vertexAttribPointer(index, this.componentsPerAttribute, this.componentDatatype, this.normalize, this.strideInBytes, this.offsetInBytes);
|
gl.enableVertexAttribArray(index);
|
if (this.instanceDivisor > 0) {
|
context.glVertexAttribDivisor(index, this.instanceDivisor);
|
context._vertexAttribDivisors[index] = this.instanceDivisor;
|
context._previousDrawInstanced = true;
|
}
|
};
|
|
attr.disableVertexAttribArray = function(gl) {
|
gl.disableVertexAttribArray(this.index);
|
if (this.instanceDivisor > 0) {
|
context.glVertexAttribDivisor(index, 0);
|
}
|
};
|
} else {
|
// Less common case: value array for the same data for each vertex
|
switch (attr.componentsPerAttribute) {
|
case 1:
|
attr.vertexAttrib = function(gl) {
|
gl.vertexAttrib1fv(this.index, this.value);
|
};
|
break;
|
case 2:
|
attr.vertexAttrib = function(gl) {
|
gl.vertexAttrib2fv(this.index, this.value);
|
};
|
break;
|
case 3:
|
attr.vertexAttrib = function(gl) {
|
gl.vertexAttrib3fv(this.index, this.value);
|
};
|
break;
|
case 4:
|
attr.vertexAttrib = function(gl) {
|
gl.vertexAttrib4fv(this.index, this.value);
|
};
|
break;
|
}
|
|
attr.disableVertexAttribArray = function(gl) {
|
};
|
}
|
|
attributes.push(attr);
|
}
|
|
function bind(gl, attributes, indexBuffer) {
|
for ( var i = 0; i < attributes.length; ++i) {
|
var attribute = attributes[i];
|
if (attribute.enabled) {
|
attribute.vertexAttrib(gl);
|
}
|
}
|
|
if (defined(indexBuffer)) {
|
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer._getBuffer());
|
}
|
}
|
|
/**
|
* Creates a vertex array, which defines the attributes making up a vertex, and contains an optional index buffer
|
* to select vertices for rendering. Attributes are defined using object literals as shown in Example 1 below.
|
*
|
* @param {Object} options Object with the following properties:
|
* @param {Context} options.context The context in which the VertexArray gets created.
|
* @param {Object[]} options.attributes An array of attributes.
|
* @param {IndexBuffer} [options.indexBuffer] An optional index buffer.
|
*
|
* @returns {VertexArray} The vertex array, ready for use with drawing.
|
*
|
* @exception {DeveloperError} Attribute must have a <code>vertexBuffer</code>.
|
* @exception {DeveloperError} Attribute must have a <code>componentsPerAttribute</code>.
|
* @exception {DeveloperError} Attribute must have a valid <code>componentDatatype</code> or not specify it.
|
* @exception {DeveloperError} Attribute must have a <code>strideInBytes</code> less than or equal to 255 or not specify it.
|
* @exception {DeveloperError} Index n is used by more than one attribute.
|
*
|
*
|
* @example
|
* // Example 1. Create a vertex array with vertices made up of three floating point
|
* // values, e.g., a position, from a single vertex buffer. No index buffer is used.
|
* var positionBuffer = Buffer.createVertexBuffer({
|
* context : context,
|
* sizeInBytes : 12,
|
* usage : BufferUsage.STATIC_DRAW
|
* });
|
* var attributes = [
|
* {
|
* index : 0,
|
* enabled : true,
|
* vertexBuffer : positionBuffer,
|
* componentsPerAttribute : 3,
|
* componentDatatype : ComponentDatatype.FLOAT,
|
* normalize : false,
|
* offsetInBytes : 0,
|
* strideInBytes : 0 // tightly packed
|
* instanceDivisor : 0 // not instanced
|
* }
|
* ];
|
* var va = new VertexArray({
|
* context : context,
|
* attributes : attributes
|
* });
|
*
|
* @example
|
* // Example 2. Create a vertex array with vertices from two different vertex buffers.
|
* // Each vertex has a three-component position and three-component normal.
|
* var positionBuffer = Buffer.createVertexBuffer({
|
* context : context,
|
* sizeInBytes : 12,
|
* usage : BufferUsage.STATIC_DRAW
|
* });
|
* var normalBuffer = Buffer.createVertexBuffer({
|
* context : context,
|
* sizeInBytes : 12,
|
* usage : BufferUsage.STATIC_DRAW
|
* });
|
* var attributes = [
|
* {
|
* index : 0,
|
* vertexBuffer : positionBuffer,
|
* componentsPerAttribute : 3,
|
* componentDatatype : ComponentDatatype.FLOAT
|
* },
|
* {
|
* index : 1,
|
* vertexBuffer : normalBuffer,
|
* componentsPerAttribute : 3,
|
* componentDatatype : ComponentDatatype.FLOAT
|
* }
|
* ];
|
* var va = new VertexArray({
|
* context : context,
|
* attributes : attributes
|
* });
|
*
|
* @example
|
* // Example 3. Creates the same vertex layout as Example 2 using a single
|
* // vertex buffer, instead of two.
|
* var buffer = Buffer.createVertexBuffer({
|
* context : context,
|
* sizeInBytes : 24,
|
* usage : BufferUsage.STATIC_DRAW
|
* });
|
* var attributes = [
|
* {
|
* vertexBuffer : buffer,
|
* componentsPerAttribute : 3,
|
* componentDatatype : ComponentDatatype.FLOAT,
|
* offsetInBytes : 0,
|
* strideInBytes : 24
|
* },
|
* {
|
* vertexBuffer : buffer,
|
* componentsPerAttribute : 3,
|
* componentDatatype : ComponentDatatype.FLOAT,
|
* normalize : true,
|
* offsetInBytes : 12,
|
* strideInBytes : 24
|
* }
|
* ];
|
* var va = new VertexArray({
|
* context : context,
|
* attributes : attributes
|
* });
|
*
|
* @see Buffer#createVertexBuffer
|
* @see Buffer#createIndexBuffer
|
* @see Context#draw
|
*
|
* @private
|
*/
|
function VertexArray(options) {
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
|
//>>includeStart('debug', pragmas.debug);
|
Check.defined('options.context', options.context);
|
Check.defined('options.attributes', options.attributes);
|
//>>includeEnd('debug');
|
|
var context = options.context;
|
var gl = context._gl;
|
var attributes = options.attributes;
|
var indexBuffer = options.indexBuffer;
|
|
var i;
|
var vaAttributes = [];
|
var numberOfVertices = 1; // if every attribute is backed by a single value
|
var hasInstancedAttributes = false;
|
var hasConstantAttributes = false;
|
|
var length = attributes.length;
|
for (i = 0; i < length; ++i) {
|
addAttribute(vaAttributes, attributes[i], i, context);
|
}
|
|
length = vaAttributes.length;
|
for (i = 0; i < length; ++i) {
|
var attribute = vaAttributes[i];
|
|
if (defined(attribute.vertexBuffer) && (attribute.instanceDivisor === 0)) {
|
// This assumes that each vertex buffer in the vertex array has the same number of vertices.
|
var bytes = attribute.strideInBytes || (attribute.componentsPerAttribute * ComponentDatatype.getSizeInBytes(attribute.componentDatatype));
|
numberOfVertices = attribute.vertexBuffer.sizeInBytes / bytes;
|
break;
|
}
|
}
|
|
for (i = 0; i < length; ++i) {
|
if (vaAttributes[i].instanceDivisor > 0) {
|
hasInstancedAttributes = true;
|
}
|
if (defined(vaAttributes[i].value)) {
|
hasConstantAttributes = true;
|
}
|
}
|
|
//>>includeStart('debug', pragmas.debug);
|
// Verify all attribute names are unique
|
var uniqueIndices = {};
|
for (i = 0; i < length; ++i) {
|
var index = vaAttributes[i].index;
|
if (uniqueIndices[index]) {
|
throw new DeveloperError('Index ' + index + ' is used by more than one attribute.');
|
}
|
uniqueIndices[index] = true;
|
}
|
//>>includeEnd('debug');
|
|
var vao;
|
|
// Setup VAO if supported
|
if (context.vertexArrayObject) {
|
vao = context.glCreateVertexArray();
|
context.glBindVertexArray(vao);
|
bind(gl, vaAttributes, indexBuffer);
|
context.glBindVertexArray(null);
|
}
|
|
this._numberOfVertices = numberOfVertices;
|
this._hasInstancedAttributes = hasInstancedAttributes;
|
this._hasConstantAttributes = hasConstantAttributes;
|
this._context = context;
|
this._gl = gl;
|
this._vao = vao;
|
this._attributes = vaAttributes;
|
this._indexBuffer = indexBuffer;
|
}
|
|
function computeNumberOfVertices(attribute) {
|
return attribute.values.length / attribute.componentsPerAttribute;
|
}
|
|
function computeAttributeSizeInBytes(attribute) {
|
return ComponentDatatype.getSizeInBytes(attribute.componentDatatype) * attribute.componentsPerAttribute;
|
}
|
|
function interleaveAttributes(attributes) {
|
var j;
|
var name;
|
var attribute;
|
|
// Extract attribute names.
|
var names = [];
|
for (name in attributes) {
|
// Attribute needs to have per-vertex values; not a constant value for all vertices.
|
if (attributes.hasOwnProperty(name) &&
|
defined(attributes[name]) &&
|
defined(attributes[name].values)) {
|
names.push(name);
|
|
if (attributes[name].componentDatatype === ComponentDatatype.DOUBLE) {
|
attributes[name].componentDatatype = ComponentDatatype.FLOAT;
|
attributes[name].values = ComponentDatatype.createTypedArray(ComponentDatatype.FLOAT, attributes[name].values);
|
}
|
}
|
}
|
|
// Validation. Compute number of vertices.
|
var numberOfVertices;
|
var namesLength = names.length;
|
|
if (namesLength > 0) {
|
numberOfVertices = computeNumberOfVertices(attributes[names[0]]);
|
|
for (j = 1; j < namesLength; ++j) {
|
var currentNumberOfVertices = computeNumberOfVertices(attributes[names[j]]);
|
|
if (currentNumberOfVertices !== numberOfVertices) {
|
throw new RuntimeError(
|
'Each attribute list must have the same number of vertices. ' +
|
'Attribute ' + names[j] + ' has a different number of vertices ' +
|
'(' + currentNumberOfVertices.toString() + ')' +
|
' than attribute ' + names[0] +
|
' (' + numberOfVertices.toString() + ').');
|
}
|
}
|
}
|
|
// Sort attributes by the size of their components. From left to right, a vertex stores floats, shorts, and then bytes.
|
names.sort(function(left, right) {
|
return ComponentDatatype.getSizeInBytes(attributes[right].componentDatatype) - ComponentDatatype.getSizeInBytes(attributes[left].componentDatatype);
|
});
|
|
// Compute sizes and strides.
|
var vertexSizeInBytes = 0;
|
var offsetsInBytes = {};
|
|
for (j = 0; j < namesLength; ++j) {
|
name = names[j];
|
attribute = attributes[name];
|
|
offsetsInBytes[name] = vertexSizeInBytes;
|
vertexSizeInBytes += computeAttributeSizeInBytes(attribute);
|
}
|
|
if (vertexSizeInBytes > 0) {
|
// Pad each vertex to be a multiple of the largest component datatype so each
|
// attribute can be addressed using typed arrays.
|
var maxComponentSizeInBytes = ComponentDatatype.getSizeInBytes(attributes[names[0]].componentDatatype); // Sorted large to small
|
var remainder = vertexSizeInBytes % maxComponentSizeInBytes;
|
if (remainder !== 0) {
|
vertexSizeInBytes += (maxComponentSizeInBytes - remainder);
|
}
|
|
// Total vertex buffer size in bytes, including per-vertex padding.
|
var vertexBufferSizeInBytes = numberOfVertices * vertexSizeInBytes;
|
|
// Create array for interleaved vertices. Each attribute has a different view (pointer) into the array.
|
var buffer = new ArrayBuffer(vertexBufferSizeInBytes);
|
var views = {};
|
|
for (j = 0; j < namesLength; ++j) {
|
name = names[j];
|
var sizeInBytes = ComponentDatatype.getSizeInBytes(attributes[name].componentDatatype);
|
|
views[name] = {
|
pointer : ComponentDatatype.createTypedArray(attributes[name].componentDatatype, buffer),
|
index : offsetsInBytes[name] / sizeInBytes, // Offset in ComponentType
|
strideInComponentType : vertexSizeInBytes / sizeInBytes
|
};
|
}
|
|
// Copy attributes into one interleaved array.
|
// PERFORMANCE_IDEA: Can we optimize these loops?
|
for (j = 0; j < numberOfVertices; ++j) {
|
for ( var n = 0; n < namesLength; ++n) {
|
name = names[n];
|
attribute = attributes[name];
|
var values = attribute.values;
|
var view = views[name];
|
var pointer = view.pointer;
|
|
var numberOfComponents = attribute.componentsPerAttribute;
|
for ( var k = 0; k < numberOfComponents; ++k) {
|
pointer[view.index + k] = values[(j * numberOfComponents) + k];
|
}
|
|
view.index += view.strideInComponentType;
|
}
|
}
|
|
return {
|
buffer : buffer,
|
offsetsInBytes : offsetsInBytes,
|
vertexSizeInBytes : vertexSizeInBytes
|
};
|
}
|
|
// No attributes to interleave.
|
return undefined;
|
}
|
|
/**
|
* Creates a vertex array from a geometry. A geometry contains vertex attributes and optional index data
|
* in system memory, whereas a vertex array contains vertex buffers and an optional index buffer in WebGL
|
* memory for use with rendering.
|
* <br /><br />
|
* The <code>geometry</code> argument should use the standard layout like the geometry returned by {@link BoxGeometry}.
|
* <br /><br />
|
* <code>options</code> can have four properties:
|
* <ul>
|
* <li><code>geometry</code>: The source geometry containing data used to create the vertex array.</li>
|
* <li><code>attributeLocations</code>: An object that maps geometry attribute names to vertex shader attribute locations.</li>
|
* <li><code>bufferUsage</code>: The expected usage pattern of the vertex array's buffers. On some WebGL implementations, this can significantly affect performance. See {@link BufferUsage}. Default: <code>BufferUsage.DYNAMIC_DRAW</code>.</li>
|
* <li><code>interleave</code>: Determines if all attributes are interleaved in a single vertex buffer or if each attribute is stored in a separate vertex buffer. Default: <code>false</code>.</li>
|
* </ul>
|
* <br />
|
* If <code>options</code> is not specified or the <code>geometry</code> contains no data, the returned vertex array is empty.
|
*
|
* @param {Object} options An object defining the geometry, attribute indices, buffer usage, and vertex layout used to create the vertex array.
|
*
|
* @exception {RuntimeError} Each attribute list must have the same number of vertices.
|
* @exception {DeveloperError} The geometry must have zero or one index lists.
|
* @exception {DeveloperError} Index n is used by more than one attribute.
|
*
|
*
|
* @example
|
* // Example 1. Creates a vertex array for rendering a box. The default dynamic draw
|
* // usage is used for the created vertex and index buffer. The attributes are not
|
* // interleaved by default.
|
* var geometry = new BoxGeometry();
|
* var va = VertexArray.fromGeometry({
|
* context : context,
|
* geometry : geometry,
|
* attributeLocations : GeometryPipeline.createAttributeLocations(geometry),
|
* });
|
*
|
* @example
|
* // Example 2. Creates a vertex array with interleaved attributes in a
|
* // single vertex buffer. The vertex and index buffer have static draw usage.
|
* var va = VertexArray.fromGeometry({
|
* context : context,
|
* geometry : geometry,
|
* attributeLocations : GeometryPipeline.createAttributeLocations(geometry),
|
* bufferUsage : BufferUsage.STATIC_DRAW,
|
* interleave : true
|
* });
|
*
|
* @example
|
* // Example 3. When the caller destroys the vertex array, it also destroys the
|
* // attached vertex buffer(s) and index buffer.
|
* va = va.destroy();
|
*
|
* @see Buffer#createVertexBuffer
|
* @see Buffer#createIndexBuffer
|
* @see GeometryPipeline.createAttributeLocations
|
* @see ShaderProgram
|
*/
|
VertexArray.fromGeometry = function(options) {
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
|
//>>includeStart('debug', pragmas.debug);
|
Check.defined('options.context', options.context);
|
//>>includeEnd('debug');
|
|
var context = options.context;
|
var geometry = defaultValue(options.geometry, defaultValue.EMPTY_OBJECT);
|
|
var bufferUsage = defaultValue(options.bufferUsage, BufferUsage.DYNAMIC_DRAW);
|
|
var attributeLocations = defaultValue(options.attributeLocations, defaultValue.EMPTY_OBJECT);
|
var interleave = defaultValue(options.interleave, false);
|
var createdVAAttributes = options.vertexArrayAttributes;
|
|
var name;
|
var attribute;
|
var vertexBuffer;
|
var vaAttributes = (defined(createdVAAttributes)) ? createdVAAttributes : [];
|
var attributes = geometry.attributes;
|
|
if (interleave) {
|
// Use a single vertex buffer with interleaved vertices.
|
var interleavedAttributes = interleaveAttributes(attributes);
|
if (defined(interleavedAttributes)) {
|
vertexBuffer = Buffer.createVertexBuffer({
|
context : context,
|
typedArray : interleavedAttributes.buffer,
|
usage : bufferUsage
|
});
|
var offsetsInBytes = interleavedAttributes.offsetsInBytes;
|
var strideInBytes = interleavedAttributes.vertexSizeInBytes;
|
|
for (name in attributes) {
|
if (attributes.hasOwnProperty(name) && defined(attributes[name])) {
|
attribute = attributes[name];
|
|
if (defined(attribute.values)) {
|
// Common case: per-vertex attributes
|
vaAttributes.push({
|
index : attributeLocations[name],
|
vertexBuffer : vertexBuffer,
|
componentDatatype : attribute.componentDatatype,
|
componentsPerAttribute : attribute.componentsPerAttribute,
|
normalize : attribute.normalize,
|
offsetInBytes : offsetsInBytes[name],
|
strideInBytes : strideInBytes
|
});
|
} else {
|
// Constant attribute for all vertices
|
vaAttributes.push({
|
index : attributeLocations[name],
|
value : attribute.value,
|
componentDatatype : attribute.componentDatatype,
|
normalize : attribute.normalize
|
});
|
}
|
}
|
}
|
}
|
} else {
|
// One vertex buffer per attribute.
|
for (name in attributes) {
|
if (attributes.hasOwnProperty(name) && defined(attributes[name])) {
|
attribute = attributes[name];
|
|
var componentDatatype = attribute.componentDatatype;
|
if (componentDatatype === ComponentDatatype.DOUBLE) {
|
componentDatatype = ComponentDatatype.FLOAT;
|
}
|
|
vertexBuffer = undefined;
|
if (defined(attribute.values)) {
|
vertexBuffer = Buffer.createVertexBuffer({
|
context : context,
|
typedArray : ComponentDatatype.createTypedArray(componentDatatype, attribute.values),
|
usage : bufferUsage
|
});
|
}
|
|
vaAttributes.push({
|
index : attributeLocations[name],
|
vertexBuffer : vertexBuffer,
|
value : attribute.value,
|
componentDatatype : componentDatatype,
|
componentsPerAttribute : attribute.componentsPerAttribute,
|
normalize : attribute.normalize
|
});
|
}
|
}
|
}
|
|
var indexBuffer;
|
var indices = geometry.indices;
|
if (defined(indices)) {
|
if ((Geometry.computeNumberOfVertices(geometry) >= CesiumMath.SIXTY_FOUR_KILOBYTES) && context.elementIndexUint) {
|
indexBuffer = Buffer.createIndexBuffer({
|
context : context,
|
typedArray : new Uint32Array(indices),
|
usage : bufferUsage,
|
indexDatatype : IndexDatatype.UNSIGNED_INT
|
});
|
} else{
|
indexBuffer = Buffer.createIndexBuffer({
|
context : context,
|
typedArray : new Uint16Array(indices),
|
usage : bufferUsage,
|
indexDatatype : IndexDatatype.UNSIGNED_SHORT
|
});
|
}
|
}
|
|
return new VertexArray({
|
context : context,
|
attributes : vaAttributes,
|
indexBuffer : indexBuffer
|
});
|
};
|
|
Object.defineProperties(VertexArray.prototype, {
|
numberOfAttributes : {
|
get : function() {
|
return this._attributes.length;
|
}
|
},
|
numberOfVertices : {
|
get : function() {
|
return this._numberOfVertices;
|
}
|
},
|
indexBuffer : {
|
get : function() {
|
return this._indexBuffer;
|
}
|
}
|
});
|
|
/**
|
* index is the location in the array of attributes, not the index property of an attribute.
|
*/
|
VertexArray.prototype.getAttribute = function(index) {
|
//>>includeStart('debug', pragmas.debug);
|
Check.defined('index', index);
|
//>>includeEnd('debug');
|
|
return this._attributes[index];
|
};
|
|
// Workaround for ANGLE, where the attribute divisor seems to be part of the global state instead
|
// of the VAO state. This function is called when the vao is bound, and should be removed
|
// once the ANGLE issue is resolved. Setting the divisor should normally happen in vertexAttrib and
|
// disableVertexAttribArray.
|
function setVertexAttribDivisor(vertexArray) {
|
var context = vertexArray._context;
|
var hasInstancedAttributes = vertexArray._hasInstancedAttributes;
|
if (!hasInstancedAttributes && !context._previousDrawInstanced) {
|
return;
|
}
|
context._previousDrawInstanced = hasInstancedAttributes;
|
|
var divisors = context._vertexAttribDivisors;
|
var attributes = vertexArray._attributes;
|
var maxAttributes = ContextLimits.maximumVertexAttributes;
|
var i;
|
|
if (hasInstancedAttributes) {
|
var length = attributes.length;
|
for (i = 0; i < length; ++i) {
|
var attribute = attributes[i];
|
if (attribute.enabled) {
|
var divisor = attribute.instanceDivisor;
|
var index = attribute.index;
|
if (divisor !== divisors[index]) {
|
context.glVertexAttribDivisor(index, divisor);
|
divisors[index] = divisor;
|
}
|
}
|
}
|
} else {
|
for (i = 0; i < maxAttributes; ++i) {
|
if (divisors[i] > 0) {
|
context.glVertexAttribDivisor(i, 0);
|
divisors[i] = 0;
|
}
|
}
|
}
|
}
|
|
// Vertex attributes backed by a constant value go through vertexAttrib[1234]f[v]
|
// which is part of context state rather than VAO state.
|
function setConstantAttributes(vertexArray, gl) {
|
var attributes = vertexArray._attributes;
|
var length = attributes.length;
|
for (var i = 0; i < length; ++i) {
|
var attribute = attributes[i];
|
if (attribute.enabled && defined(attribute.value)) {
|
attribute.vertexAttrib(gl);
|
}
|
}
|
}
|
|
VertexArray.prototype._bind = function() {
|
if (defined(this._vao)) {
|
this._context.glBindVertexArray(this._vao);
|
if (this._context.instancedArrays) {
|
setVertexAttribDivisor(this);
|
}
|
if (this._hasConstantAttributes) {
|
setConstantAttributes(this, this._gl);
|
}
|
} else {
|
bind(this._gl, this._attributes, this._indexBuffer);
|
}
|
};
|
|
VertexArray.prototype._unBind = function() {
|
if (defined(this._vao)) {
|
this._context.glBindVertexArray(null);
|
} else {
|
var attributes = this._attributes;
|
var gl = this._gl;
|
|
for ( var i = 0; i < attributes.length; ++i) {
|
var attribute = attributes[i];
|
if (attribute.enabled) {
|
attribute.disableVertexAttribArray(gl);
|
}
|
}
|
if (this._indexBuffer) {
|
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
|
}
|
}
|
};
|
|
VertexArray.prototype.isDestroyed = function() {
|
return false;
|
};
|
|
VertexArray.prototype.destroy = function() {
|
var attributes = this._attributes;
|
for ( var i = 0; i < attributes.length; ++i) {
|
var vertexBuffer = attributes[i].vertexBuffer;
|
if (defined(vertexBuffer) && !vertexBuffer.isDestroyed() && vertexBuffer.vertexArrayDestroyable) {
|
vertexBuffer.destroy();
|
}
|
}
|
|
var indexBuffer = this._indexBuffer;
|
if (defined(indexBuffer) && !indexBuffer.isDestroyed() && indexBuffer.vertexArrayDestroyable) {
|
indexBuffer.destroy();
|
}
|
|
if (defined(this._vao)) {
|
this._context.glDeleteVertexArray(this._vao);
|
}
|
|
return destroyObject(this);
|
};
|
export default VertexArray;
|
