import Check from '../Core/Check.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 IndexDatatype from '../Core/IndexDatatype.js';
|
import WebGLConstants from '../Core/WebGLConstants.js';
|
import BufferUsage from './BufferUsage.js';
|
|
/**
|
* @private
|
*/
|
function Buffer(options) {
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
|
//>>includeStart('debug', pragmas.debug);
|
Check.defined('options.context', options.context);
|
|
if (!defined(options.typedArray) && !defined(options.sizeInBytes)) {
|
throw new DeveloperError('Either options.sizeInBytes or options.typedArray is required.');
|
}
|
|
if (defined(options.typedArray) && defined(options.sizeInBytes)) {
|
throw new DeveloperError('Cannot pass in both options.sizeInBytes and options.typedArray.');
|
}
|
|
if (defined(options.typedArray)) {
|
Check.typeOf.object('options.typedArray', options.typedArray);
|
Check.typeOf.number('options.typedArray.byteLength', options.typedArray.byteLength);
|
}
|
|
if (!BufferUsage.validate(options.usage)) {
|
throw new DeveloperError('usage is invalid.');
|
}
|
//>>includeEnd('debug');
|
|
var gl = options.context._gl;
|
var bufferTarget = options.bufferTarget;
|
var typedArray = options.typedArray;
|
var sizeInBytes = options.sizeInBytes;
|
var usage = options.usage;
|
var hasArray = defined(typedArray);
|
|
if (hasArray) {
|
sizeInBytes = typedArray.byteLength;
|
}
|
|
//>>includeStart('debug', pragmas.debug);
|
Check.typeOf.number.greaterThan('sizeInBytes', sizeInBytes, 0);
|
//>>includeEnd('debug');
|
|
var buffer = gl.createBuffer();
|
gl.bindBuffer(bufferTarget, buffer);
|
gl.bufferData(bufferTarget, hasArray ? typedArray : sizeInBytes, usage);
|
gl.bindBuffer(bufferTarget, null);
|
|
this._gl = gl;
|
this._webgl2 = options.context._webgl2;
|
this._bufferTarget = bufferTarget;
|
this._sizeInBytes = sizeInBytes;
|
this._usage = usage;
|
this._buffer = buffer;
|
this.vertexArrayDestroyable = true;
|
}
|
|
/**
|
* Creates a vertex buffer, which contains untyped vertex data in GPU-controlled memory.
|
* <br /><br />
|
* A vertex array defines the actual makeup of a vertex, e.g., positions, normals, texture coordinates,
|
* etc., by interpreting the raw data in one or more vertex buffers.
|
*
|
* @param {Object} options An object containing the following properties:
|
* @param {Context} options.context The context in which to create the buffer
|
* @param {ArrayBufferView} [options.typedArray] A typed array containing the data to copy to the buffer.
|
* @param {Number} [options.sizeInBytes] A <code>Number</code> defining the size of the buffer in bytes. Required if options.typedArray is not given.
|
* @param {BufferUsage} options.usage Specifies the expected usage pattern of the buffer. On some GL implementations, this can significantly affect performance. See {@link BufferUsage}.
|
* @returns {VertexBuffer} The vertex buffer, ready to be attached to a vertex array.
|
*
|
* @exception {DeveloperError} Must specify either <options.typedArray> or <options.sizeInBytes>, but not both.
|
* @exception {DeveloperError} The buffer size must be greater than zero.
|
* @exception {DeveloperError} Invalid <code>usage</code>.
|
*
|
*
|
* @example
|
* // Example 1. Create a dynamic vertex buffer 16 bytes in size.
|
* var buffer = Buffer.createVertexBuffer({
|
* context : context,
|
* sizeInBytes : 16,
|
* usage : BufferUsage.DYNAMIC_DRAW
|
* });
|
*
|
* @example
|
* // Example 2. Create a dynamic vertex buffer from three floating-point values.
|
* // The data copied to the vertex buffer is considered raw bytes until it is
|
* // interpreted as vertices using a vertex array.
|
* var positionBuffer = buffer.createVertexBuffer({
|
* context : context,
|
* typedArray : new Float32Array([0, 0, 0]),
|
* usage : BufferUsage.STATIC_DRAW
|
* });
|
*
|
* @see {@link https://www.khronos.org/opengles/sdk/docs/man/xhtml/glGenBuffer.xml|glGenBuffer}
|
* @see {@link https://www.khronos.org/opengles/sdk/docs/man/xhtml/glBindBuffer.xml|glBindBuffer} with <code>ARRAY_BUFFER</code>
|
* @see {@link https://www.khronos.org/opengles/sdk/docs/man/xhtml/glBufferData.xml|glBufferData} with <code>ARRAY_BUFFER</code>
|
*/
|
Buffer.createVertexBuffer = function(options) {
|
//>>includeStart('debug', pragmas.debug);
|
Check.defined('options.context', options.context);
|
//>>includeEnd('debug');
|
|
return new Buffer({
|
context: options.context,
|
bufferTarget: WebGLConstants.ARRAY_BUFFER,
|
typedArray: options.typedArray,
|
sizeInBytes: options.sizeInBytes,
|
usage: options.usage
|
});
|
};
|
|
/**
|
* Creates an index buffer, which contains typed indices in GPU-controlled memory.
|
* <br /><br />
|
* An index buffer can be attached to a vertex array to select vertices for rendering.
|
* <code>Context.draw</code> can render using the entire index buffer or a subset
|
* of the index buffer defined by an offset and count.
|
*
|
* @param {Object} options An object containing the following properties:
|
* @param {Context} options.context The context in which to create the buffer
|
* @param {ArrayBufferView} [options.typedArray] A typed array containing the data to copy to the buffer.
|
* @param {Number} [options.sizeInBytes] A <code>Number</code> defining the size of the buffer in bytes. Required if options.typedArray is not given.
|
* @param {BufferUsage} options.usage Specifies the expected usage pattern of the buffer. On some GL implementations, this can significantly affect performance. See {@link BufferUsage}.
|
* @param {IndexDatatype} options.indexDatatype The datatype of indices in the buffer.
|
* @returns {IndexBuffer} The index buffer, ready to be attached to a vertex array.
|
*
|
* @exception {DeveloperError} Must specify either <options.typedArray> or <options.sizeInBytes>, but not both.
|
* @exception {DeveloperError} IndexDatatype.UNSIGNED_INT requires OES_element_index_uint, which is not supported on this system. Check context.elementIndexUint.
|
* @exception {DeveloperError} The size in bytes must be greater than zero.
|
* @exception {DeveloperError} Invalid <code>usage</code>.
|
* @exception {DeveloperError} Invalid <code>indexDatatype</code>.
|
*
|
*
|
* @example
|
* // Example 1. Create a stream index buffer of unsigned shorts that is
|
* // 16 bytes in size.
|
* var buffer = Buffer.createIndexBuffer({
|
* context : context,
|
* sizeInBytes : 16,
|
* usage : BufferUsage.STREAM_DRAW,
|
* indexDatatype : IndexDatatype.UNSIGNED_SHORT
|
* });
|
*
|
* @example
|
* // Example 2. Create a static index buffer containing three unsigned shorts.
|
* var buffer = Buffer.createIndexBuffer({
|
* context : context,
|
* typedArray : new Uint16Array([0, 1, 2]),
|
* usage : BufferUsage.STATIC_DRAW,
|
* indexDatatype : IndexDatatype.UNSIGNED_SHORT
|
* });
|
*
|
* @see {@link https://www.khronos.org/opengles/sdk/docs/man/xhtml/glGenBuffer.xml|glGenBuffer}
|
* @see {@link https://www.khronos.org/opengles/sdk/docs/man/xhtml/glBindBuffer.xml|glBindBuffer} with <code>ELEMENT_ARRAY_BUFFER</code>
|
* @see {@link https://www.khronos.org/opengles/sdk/docs/man/xhtml/glBufferData.xml|glBufferData} with <code>ELEMENT_ARRAY_BUFFER</code>
|
*/
|
Buffer.createIndexBuffer = function(options) {
|
//>>includeStart('debug', pragmas.debug);
|
Check.defined('options.context', options.context);
|
|
if (!IndexDatatype.validate(options.indexDatatype)) {
|
throw new DeveloperError('Invalid indexDatatype.');
|
}
|
|
if (options.indexDatatype === IndexDatatype.UNSIGNED_INT && !options.context.elementIndexUint) {
|
throw new DeveloperError('IndexDatatype.UNSIGNED_INT requires OES_element_index_uint, which is not supported on this system. Check context.elementIndexUint.');
|
}
|
//>>includeEnd('debug');
|
|
var context = options.context;
|
var indexDatatype = options.indexDatatype;
|
|
var bytesPerIndex = IndexDatatype.getSizeInBytes(indexDatatype);
|
var buffer = new Buffer({
|
context : context,
|
bufferTarget : WebGLConstants.ELEMENT_ARRAY_BUFFER,
|
typedArray : options.typedArray,
|
sizeInBytes : options.sizeInBytes,
|
usage : options.usage
|
});
|
|
var numberOfIndices = buffer.sizeInBytes / bytesPerIndex;
|
|
Object.defineProperties(buffer, {
|
indexDatatype: {
|
get : function() {
|
return indexDatatype;
|
}
|
},
|
bytesPerIndex : {
|
get : function() {
|
return bytesPerIndex;
|
}
|
},
|
numberOfIndices : {
|
get : function() {
|
return numberOfIndices;
|
}
|
}
|
});
|
|
return buffer;
|
};
|
|
Object.defineProperties(Buffer.prototype, {
|
sizeInBytes : {
|
get : function() {
|
return this._sizeInBytes;
|
}
|
},
|
|
usage: {
|
get : function() {
|
return this._usage;
|
}
|
}
|
});
|
|
Buffer.prototype._getBuffer = function() {
|
return this._buffer;
|
};
|
|
Buffer.prototype.copyFromArrayView = function(arrayView, offsetInBytes) {
|
offsetInBytes = defaultValue(offsetInBytes, 0);
|
|
//>>includeStart('debug', pragmas.debug);
|
Check.defined('arrayView', arrayView);
|
Check.typeOf.number.lessThanOrEquals('offsetInBytes + arrayView.byteLength', offsetInBytes + arrayView.byteLength, this._sizeInBytes);
|
//>>includeEnd('debug');
|
|
var gl = this._gl;
|
var target = this._bufferTarget;
|
gl.bindBuffer(target, this._buffer);
|
gl.bufferSubData(target, offsetInBytes, arrayView);
|
gl.bindBuffer(target, null);
|
};
|
|
Buffer.prototype.copyFromBuffer = function(readBuffer, readOffset, writeOffset, sizeInBytes) {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._webgl2) {
|
throw new DeveloperError('A WebGL 2 context is required.');
|
}
|
if (!defined(readBuffer)) {
|
throw new DeveloperError('readBuffer must be defined.');
|
}
|
if (!defined(sizeInBytes) || sizeInBytes <= 0) {
|
throw new DeveloperError('sizeInBytes must be defined and be greater than zero.');
|
}
|
if (!defined(readOffset) || readOffset < 0 || readOffset + sizeInBytes > readBuffer._sizeInBytes) {
|
throw new DeveloperError('readOffset must be greater than or equal to zero and readOffset + sizeInBytes must be less than of equal to readBuffer.sizeInBytes.');
|
}
|
if (!defined(writeOffset) || writeOffset < 0 || writeOffset + sizeInBytes > this._sizeInBytes) {
|
throw new DeveloperError('writeOffset must be greater than or equal to zero and writeOffset + sizeInBytes must be less than of equal to this.sizeInBytes.');
|
}
|
if (this._buffer === readBuffer._buffer && ((writeOffset >= readOffset && writeOffset < readOffset + sizeInBytes) || (readOffset > writeOffset && readOffset < writeOffset + sizeInBytes))) {
|
throw new DeveloperError('When readBuffer is equal to this, the ranges [readOffset + sizeInBytes) and [writeOffset, writeOffset + sizeInBytes) must not overlap.');
|
}
|
if ((this._bufferTarget === WebGLConstants.ELEMENT_ARRAY_BUFFER && readBuffer._bufferTarget !== WebGLConstants.ELEMENT_ARRAY_BUFFER) ||
|
(this._bufferTarget !== WebGLConstants.ELEMENT_ARRAY_BUFFER && readBuffer._bufferTarget === WebGLConstants.ELEMENT_ARRAY_BUFFER)) {
|
throw new DeveloperError('Can not copy an index buffer into another buffer type.');
|
}
|
//>>includeEnd('debug');
|
|
var readTarget = WebGLConstants.COPY_READ_BUFFER;
|
var writeTarget = WebGLConstants.COPY_WRITE_BUFFER;
|
|
var gl = this._gl;
|
gl.bindBuffer(writeTarget, this._buffer);
|
gl.bindBuffer(readTarget, readBuffer._buffer);
|
gl.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, sizeInBytes);
|
gl.bindBuffer(writeTarget, null);
|
gl.bindBuffer(readTarget, null);
|
};
|
|
Buffer.prototype.getBufferData = function(arrayView, sourceOffset, destinationOffset, length) {
|
sourceOffset = defaultValue(sourceOffset, 0);
|
destinationOffset = defaultValue(destinationOffset, 0);
|
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._webgl2) {
|
throw new DeveloperError('A WebGL 2 context is required.');
|
}
|
if (!defined(arrayView)) {
|
throw new DeveloperError('arrayView is required.');
|
}
|
|
var copyLength;
|
var elementSize;
|
var arrayLength = arrayView.byteLength;
|
if (!defined(length)) {
|
if (defined(arrayLength)) {
|
copyLength = arrayLength - destinationOffset;
|
elementSize = 1;
|
} else {
|
arrayLength = arrayView.length;
|
copyLength = arrayLength - destinationOffset;
|
elementSize = arrayView.BYTES_PER_ELEMENT;
|
}
|
} else {
|
copyLength = length;
|
if (defined(arrayLength)) {
|
elementSize = 1;
|
} else {
|
arrayLength = arrayView.length;
|
elementSize = arrayView.BYTES_PER_ELEMENT;
|
}
|
}
|
|
if (destinationOffset < 0 || destinationOffset > arrayLength) {
|
throw new DeveloperError('destinationOffset must be greater than zero and less than the arrayView length.');
|
}
|
if (destinationOffset + copyLength > arrayLength) {
|
throw new DeveloperError('destinationOffset + length must be less than or equal to the arrayViewLength.');
|
}
|
if (sourceOffset < 0 || sourceOffset > this._sizeInBytes) {
|
throw new DeveloperError('sourceOffset must be greater than zero and less than the buffers size.');
|
}
|
if (sourceOffset + copyLength * elementSize > this._sizeInBytes) {
|
throw new DeveloperError('sourceOffset + length must be less than the buffers size.');
|
}
|
//>>includeEnd('debug');
|
|
var gl = this._gl;
|
var target = WebGLConstants.COPY_READ_BUFFER;
|
gl.bindBuffer(target, this._buffer);
|
gl.getBufferSubData(target, sourceOffset, arrayView, destinationOffset, length);
|
gl.bindBuffer(target, null);
|
};
|
|
Buffer.prototype.isDestroyed = function() {
|
return false;
|
};
|
|
Buffer.prototype.destroy = function() {
|
this._gl.deleteBuffer(this._buffer);
|
return destroyObject(this);
|
};
|
export default Buffer;
|
