/** * Cesium - https://github.com/CesiumGS/cesium * * Copyright 2011-2020 Cesium Contributors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * Columbus View (Pat. Pend.) * * Portions licensed separately. * See https://github.com/CesiumGS/cesium/blob/master/LICENSE.md for full licensing details. */ define(['exports', './when-8d13db60', './Check-70bec281', './WebGLConstants-4c11ee5f'], function (exports, when, Check, WebGLConstants) { 'use strict'; /** * WebGL component datatypes. Components are intrinsics, * which form attributes, which form vertices. * * @exports ComponentDatatype */ var ComponentDatatype = { /** * 8-bit signed byte corresponding to <code>gl.BYTE</code> and the type * of an element in <code>Int8Array</code>. * * @type {Number} * @constant */ BYTE : WebGLConstants.WebGLConstants.BYTE, /** * 8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type * of an element in <code>Uint8Array</code>. * * @type {Number} * @constant */ UNSIGNED_BYTE : WebGLConstants.WebGLConstants.UNSIGNED_BYTE, /** * 16-bit signed short corresponding to <code>SHORT</code> and the type * of an element in <code>Int16Array</code>. * * @type {Number} * @constant */ SHORT : WebGLConstants.WebGLConstants.SHORT, /** * 16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type * of an element in <code>Uint16Array</code>. * * @type {Number} * @constant */ UNSIGNED_SHORT : WebGLConstants.WebGLConstants.UNSIGNED_SHORT, /** * 32-bit signed int corresponding to <code>INT</code> and the type * of an element in <code>Int32Array</code>. * * @memberOf ComponentDatatype * * @type {Number} * @constant */ INT : WebGLConstants.WebGLConstants.INT, /** * 32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type * of an element in <code>Uint32Array</code>. * * @memberOf ComponentDatatype * * @type {Number} * @constant */ UNSIGNED_INT : WebGLConstants.WebGLConstants.UNSIGNED_INT, /** * 32-bit floating-point corresponding to <code>FLOAT</code> and the type * of an element in <code>Float32Array</code>. * * @type {Number} * @constant */ FLOAT : WebGLConstants.WebGLConstants.FLOAT, /** * 64-bit floating-point corresponding to <code>gl.DOUBLE</code> (in Desktop OpenGL; * this is not supported in WebGL, and is emulated in Cesium via {@link GeometryPipeline.encodeAttribute}) * and the type of an element in <code>Float64Array</code>. * * @memberOf ComponentDatatype * * @type {Number} * @constant * @default 0x140A */ DOUBLE : WebGLConstants.WebGLConstants.DOUBLE }; /** * Returns the size, in bytes, of the corresponding datatype. * * @param {ComponentDatatype} componentDatatype The component datatype to get the size of. * @returns {Number} The size in bytes. * * @exception {DeveloperError} componentDatatype is not a valid value. * * @example * // Returns Int8Array.BYTES_PER_ELEMENT * var size = Cesium.ComponentDatatype.getSizeInBytes(Cesium.ComponentDatatype.BYTE); */ ComponentDatatype.getSizeInBytes = function(componentDatatype){ //>>includeStart('debug', pragmas.debug); if (!when.defined(componentDatatype)) { throw new Check.DeveloperError('value is required.'); } //>>includeEnd('debug'); switch (componentDatatype) { case ComponentDatatype.BYTE: return Int8Array.BYTES_PER_ELEMENT; case ComponentDatatype.UNSIGNED_BYTE: return Uint8Array.BYTES_PER_ELEMENT; case ComponentDatatype.SHORT: return Int16Array.BYTES_PER_ELEMENT; case ComponentDatatype.UNSIGNED_SHORT: return Uint16Array.BYTES_PER_ELEMENT; case ComponentDatatype.INT: return Int32Array.BYTES_PER_ELEMENT; case ComponentDatatype.UNSIGNED_INT: return Uint32Array.BYTES_PER_ELEMENT; case ComponentDatatype.FLOAT: return Float32Array.BYTES_PER_ELEMENT; case ComponentDatatype.DOUBLE: return Float64Array.BYTES_PER_ELEMENT; //>>includeStart('debug', pragmas.debug); default: throw new Check.DeveloperError('componentDatatype is not a valid value.'); //>>includeEnd('debug'); } }; /** * Gets the {@link ComponentDatatype} for the provided TypedArray instance. * * @param {TypedArray} array The typed array. * @returns {ComponentDatatype} The ComponentDatatype for the provided array, or undefined if the array is not a TypedArray. */ ComponentDatatype.fromTypedArray = function(array) { if (array instanceof Int8Array) { return ComponentDatatype.BYTE; } if (array instanceof Uint8Array) { return ComponentDatatype.UNSIGNED_BYTE; } if (array instanceof Int16Array) { return ComponentDatatype.SHORT; } if (array instanceof Uint16Array) { return ComponentDatatype.UNSIGNED_SHORT; } if (array instanceof Int32Array) { return ComponentDatatype.INT; } if (array instanceof Uint32Array) { return ComponentDatatype.UNSIGNED_INT; } if (array instanceof Float32Array) { return ComponentDatatype.FLOAT; } if (array instanceof Float64Array) { return ComponentDatatype.DOUBLE; } }; /** * Validates that the provided component datatype is a valid {@link ComponentDatatype} * * @param {ComponentDatatype} componentDatatype The component datatype to validate. * @returns {Boolean} <code>true</code> if the provided component datatype is a valid value; otherwise, <code>false</code>. * * @example * if (!Cesium.ComponentDatatype.validate(componentDatatype)) { * throw new Cesium.DeveloperError('componentDatatype must be a valid value.'); * } */ ComponentDatatype.validate = function(componentDatatype) { return when.defined(componentDatatype) && (componentDatatype === ComponentDatatype.BYTE || componentDatatype === ComponentDatatype.UNSIGNED_BYTE || componentDatatype === ComponentDatatype.SHORT || componentDatatype === ComponentDatatype.UNSIGNED_SHORT || componentDatatype === ComponentDatatype.INT || componentDatatype === ComponentDatatype.UNSIGNED_INT || componentDatatype === ComponentDatatype.FLOAT || componentDatatype === ComponentDatatype.DOUBLE); }; /** * Creates a typed array corresponding to component data type. * * @param {ComponentDatatype} componentDatatype The component data type. * @param {Number|Array} valuesOrLength The length of the array to create or an array. * @returns {Int8Array|Uint8Array|Int16Array|Uint16Array|Int32Array|Uint32Array|Float32Array|Float64Array} A typed array. * * @exception {DeveloperError} componentDatatype is not a valid value. * * @example * // creates a Float32Array with length of 100 * var typedArray = Cesium.ComponentDatatype.createTypedArray(Cesium.ComponentDatatype.FLOAT, 100); */ ComponentDatatype.createTypedArray = function(componentDatatype, valuesOrLength) { //>>includeStart('debug', pragmas.debug); if (!when.defined(componentDatatype)) { throw new Check.DeveloperError('componentDatatype is required.'); } if (!when.defined(valuesOrLength)) { throw new Check.DeveloperError('valuesOrLength is required.'); } //>>includeEnd('debug'); switch (componentDatatype) { case ComponentDatatype.BYTE: return new Int8Array(valuesOrLength); case ComponentDatatype.UNSIGNED_BYTE: return new Uint8Array(valuesOrLength); case ComponentDatatype.SHORT: return new Int16Array(valuesOrLength); case ComponentDatatype.UNSIGNED_SHORT: return new Uint16Array(valuesOrLength); case ComponentDatatype.INT: return new Int32Array(valuesOrLength); case ComponentDatatype.UNSIGNED_INT: return new Uint32Array(valuesOrLength); case ComponentDatatype.FLOAT: return new Float32Array(valuesOrLength); case ComponentDatatype.DOUBLE: return new Float64Array(valuesOrLength); //>>includeStart('debug', pragmas.debug); default: throw new Check.DeveloperError('componentDatatype is not a valid value.'); //>>includeEnd('debug'); } }; /** * Creates a typed view of an array of bytes. * * @param {ComponentDatatype} componentDatatype The type of the view to create. * @param {ArrayBuffer} buffer The buffer storage to use for the view. * @param {Number} [byteOffset] The offset, in bytes, to the first element in the view. * @param {Number} [length] The number of elements in the view. * @returns {Int8Array|Uint8Array|Int16Array|Uint16Array|Int32Array|Uint32Array|Float32Array|Float64Array} A typed array view of the buffer. * * @exception {DeveloperError} componentDatatype is not a valid value. */ ComponentDatatype.createArrayBufferView = function(componentDatatype, buffer, byteOffset, length) { //>>includeStart('debug', pragmas.debug); if (!when.defined(componentDatatype)) { throw new Check.DeveloperError('componentDatatype is required.'); } if (!when.defined(buffer)) { throw new Check.DeveloperError('buffer is required.'); } //>>includeEnd('debug'); byteOffset = when.defaultValue(byteOffset, 0); length = when.defaultValue(length, (buffer.byteLength - byteOffset) / ComponentDatatype.getSizeInBytes(componentDatatype)); switch (componentDatatype) { case ComponentDatatype.BYTE: return new Int8Array(buffer, byteOffset, length); case ComponentDatatype.UNSIGNED_BYTE: return new Uint8Array(buffer, byteOffset, length); case ComponentDatatype.SHORT: return new Int16Array(buffer, byteOffset, length); case ComponentDatatype.UNSIGNED_SHORT: return new Uint16Array(buffer, byteOffset, length); case ComponentDatatype.INT: return new Int32Array(buffer, byteOffset, length); case ComponentDatatype.UNSIGNED_INT: return new Uint32Array(buffer, byteOffset, length); case ComponentDatatype.FLOAT: return new Float32Array(buffer, byteOffset, length); case ComponentDatatype.DOUBLE: return new Float64Array(buffer, byteOffset, length); //>>includeStart('debug', pragmas.debug); default: throw new Check.DeveloperError('componentDatatype is not a valid value.'); //>>includeEnd('debug'); } }; /** * Get the ComponentDatatype from its name. * * @param {String} name The name of the ComponentDatatype. * @returns {ComponentDatatype} The ComponentDatatype. * * @exception {DeveloperError} name is not a valid value. */ ComponentDatatype.fromName = function(name) { switch (name) { case 'BYTE': return ComponentDatatype.BYTE; case 'UNSIGNED_BYTE': return ComponentDatatype.UNSIGNED_BYTE; case 'SHORT': return ComponentDatatype.SHORT; case 'UNSIGNED_SHORT': return ComponentDatatype.UNSIGNED_SHORT; case 'INT': return ComponentDatatype.INT; case 'UNSIGNED_INT': return ComponentDatatype.UNSIGNED_INT; case 'FLOAT': return ComponentDatatype.FLOAT; case 'DOUBLE': return ComponentDatatype.DOUBLE; //>>includeStart('debug', pragmas.debug); default: throw new Check.DeveloperError('name is not a valid value.'); //>>includeEnd('debug'); } }; var ComponentDatatype$1 = Object.freeze(ComponentDatatype); exports.ComponentDatatype = ComponentDatatype$1; });