851 lines
33 KiB
JavaScript
851 lines
33 KiB
JavaScript
/**
|
|
* 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', './Cartesian2-16a61632', './BoundingSphere-d018a565', './ComponentDatatype-5862616f', './GeometryAttribute-1e248a71', './GeometryAttributes-aacecde6', './GeometryPipeline-30473267', './IndexDatatype-9435b55f', './WebMercatorProjection-9a70654e'], function (exports, when, Check, Cartesian2, BoundingSphere, ComponentDatatype, GeometryAttribute, GeometryAttributes, GeometryPipeline, IndexDatatype, WebMercatorProjection) { 'use strict';
|
|
|
|
/**
|
|
* Value and type information for per-instance geometry attribute that determines the geometry instance offset
|
|
*
|
|
* @alias OffsetGeometryInstanceAttribute
|
|
* @constructor
|
|
*
|
|
* @param {Number} [x=0] The x translation
|
|
* @param {Number} [y=0] The y translation
|
|
* @param {Number} [z=0] The z translation
|
|
*
|
|
* @private
|
|
*
|
|
* @see GeometryInstance
|
|
* @see GeometryInstanceAttribute
|
|
*/
|
|
function OffsetGeometryInstanceAttribute(x, y, z) {
|
|
x = when.defaultValue(x, 0);
|
|
y = when.defaultValue(y, 0);
|
|
z = when.defaultValue(z, 0);
|
|
|
|
/**
|
|
* The values for the attributes stored in a typed array.
|
|
*
|
|
* @type Float32Array
|
|
*/
|
|
this.value = new Float32Array([x, y, z]);
|
|
}
|
|
|
|
Object.defineProperties(OffsetGeometryInstanceAttribute.prototype, {
|
|
/**
|
|
* The datatype of each component in the attribute, e.g., individual elements in
|
|
* {@link OffsetGeometryInstanceAttribute#value}.
|
|
*
|
|
* @memberof OffsetGeometryInstanceAttribute.prototype
|
|
*
|
|
* @type {ComponentDatatype}
|
|
* @readonly
|
|
*
|
|
* @default {@link ComponentDatatype.FLOAT}
|
|
*/
|
|
componentDatatype : {
|
|
get : function() {
|
|
return ComponentDatatype.ComponentDatatype.FLOAT;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* The number of components in the attributes, i.e., {@link OffsetGeometryInstanceAttribute#value}.
|
|
*
|
|
* @memberof OffsetGeometryInstanceAttribute.prototype
|
|
*
|
|
* @type {Number}
|
|
* @readonly
|
|
*
|
|
* @default 3
|
|
*/
|
|
componentsPerAttribute : {
|
|
get : function() {
|
|
return 3;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* When <code>true</code> and <code>componentDatatype</code> is an integer format,
|
|
* indicate that the components should be mapped to the range [0, 1] (unsigned)
|
|
* or [-1, 1] (signed) when they are accessed as floating-point for rendering.
|
|
*
|
|
* @memberof OffsetGeometryInstanceAttribute.prototype
|
|
*
|
|
* @type {Boolean}
|
|
* @readonly
|
|
*
|
|
* @default false
|
|
*/
|
|
normalize : {
|
|
get : function() {
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Creates a new {@link OffsetGeometryInstanceAttribute} instance given the provided an enabled flag and {@link DistanceDisplayCondition}.
|
|
*
|
|
* @param {Cartesian3} offset The cartesian offset
|
|
* @returns {OffsetGeometryInstanceAttribute} The new {@link OffsetGeometryInstanceAttribute} instance.
|
|
*/
|
|
OffsetGeometryInstanceAttribute.fromCartesian3 = function(offset) {
|
|
//>>includeStart('debug', pragmas.debug);
|
|
Check.Check.defined('offset', offset);
|
|
//>>includeEnd('debug');
|
|
|
|
return new OffsetGeometryInstanceAttribute(offset.x, offset.y, offset.z);
|
|
};
|
|
|
|
/**
|
|
* Converts a distance display condition to a typed array that can be used to assign a distance display condition attribute.
|
|
*
|
|
* @param {Cartesian3} offset The cartesian offset
|
|
* @param {Float32Array} [result] The array to store the result in, if undefined a new instance will be created.
|
|
* @returns {Float32Array} The modified result parameter or a new instance if result was undefined.
|
|
*
|
|
* @example
|
|
* var attributes = primitive.getGeometryInstanceAttributes('an id');
|
|
* attributes.modelMatrix = Cesium.OffsetGeometryInstanceAttribute.toValue(modelMatrix, attributes.modelMatrix);
|
|
*/
|
|
OffsetGeometryInstanceAttribute.toValue = function(offset, result) {
|
|
//>>includeStart('debug', pragmas.debug);
|
|
Check.Check.defined('offset', offset);
|
|
//>>includeEnd('debug');
|
|
|
|
if (!when.defined(result)) {
|
|
result = new Float32Array([offset.x, offset.y, offset.z]);
|
|
}
|
|
|
|
result[0] = offset.x;
|
|
result[1] = offset.y;
|
|
result[2] = offset.z;
|
|
return result;
|
|
};
|
|
|
|
function transformToWorldCoordinates(instances, primitiveModelMatrix, scene3DOnly) {
|
|
var toWorld = !scene3DOnly;
|
|
var length = instances.length;
|
|
var i;
|
|
|
|
if (!toWorld && (length > 1)) {
|
|
var modelMatrix = instances[0].modelMatrix;
|
|
|
|
for (i = 1; i < length; ++i) {
|
|
if (!BoundingSphere.Matrix4.equals(modelMatrix, instances[i].modelMatrix)) {
|
|
toWorld = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (toWorld) {
|
|
for (i = 0; i < length; ++i) {
|
|
if (when.defined(instances[i].geometry)) {
|
|
GeometryPipeline.GeometryPipeline.transformToWorldCoordinates(instances[i]);
|
|
}
|
|
}
|
|
} else {
|
|
// Leave geometry in local coordinate system; auto update model-matrix.
|
|
BoundingSphere.Matrix4.multiplyTransformation(primitiveModelMatrix, instances[0].modelMatrix, primitiveModelMatrix);
|
|
}
|
|
}
|
|
|
|
function addGeometryBatchId(geometry, batchId) {
|
|
var attributes = geometry.attributes;
|
|
var positionAttr = attributes.position;
|
|
var numberOfComponents = positionAttr.values.length / positionAttr.componentsPerAttribute;
|
|
|
|
attributes.batchId = new GeometryAttribute.GeometryAttribute({
|
|
componentDatatype : ComponentDatatype.ComponentDatatype.FLOAT,
|
|
componentsPerAttribute : 1,
|
|
values : new Float32Array(numberOfComponents)
|
|
});
|
|
|
|
var values = attributes.batchId.values;
|
|
for (var j = 0; j < numberOfComponents; ++j) {
|
|
values[j] = batchId;
|
|
}
|
|
}
|
|
|
|
function addBatchIds(instances) {
|
|
var length = instances.length;
|
|
|
|
for (var i = 0; i < length; ++i) {
|
|
var instance = instances[i];
|
|
if (when.defined(instance.geometry)) {
|
|
addGeometryBatchId(instance.geometry, i);
|
|
} else if (when.defined(instance.westHemisphereGeometry) && when.defined(instance.eastHemisphereGeometry)) {
|
|
addGeometryBatchId(instance.westHemisphereGeometry, i);
|
|
addGeometryBatchId(instance.eastHemisphereGeometry, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
function geometryPipeline(parameters) {
|
|
var instances = parameters.instances;
|
|
var projection = parameters.projection;
|
|
var uintIndexSupport = parameters.elementIndexUintSupported;
|
|
var scene3DOnly = parameters.scene3DOnly;
|
|
var vertexCacheOptimize = parameters.vertexCacheOptimize;
|
|
var compressVertices = parameters.compressVertices;
|
|
var modelMatrix = parameters.modelMatrix;
|
|
|
|
var i;
|
|
var geometry;
|
|
var primitiveType;
|
|
var length = instances.length;
|
|
|
|
for (i = 0; i < length; ++i) {
|
|
if (when.defined(instances[i].geometry)) {
|
|
primitiveType = instances[i].geometry.primitiveType;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//>>includeStart('debug', pragmas.debug);
|
|
for (i = 1; i < length; ++i) {
|
|
if (when.defined(instances[i].geometry) && instances[i].geometry.primitiveType !== primitiveType) {
|
|
throw new Check.DeveloperError('All instance geometries must have the same primitiveType.');
|
|
}
|
|
}
|
|
//>>includeEnd('debug');
|
|
|
|
// Unify to world coordinates before combining.
|
|
transformToWorldCoordinates(instances, modelMatrix, scene3DOnly);
|
|
|
|
// Clip to IDL
|
|
if (!scene3DOnly) {
|
|
for (i = 0; i < length; ++i) {
|
|
if (when.defined(instances[i].geometry)) {
|
|
GeometryPipeline.GeometryPipeline.splitLongitude(instances[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
addBatchIds(instances);
|
|
|
|
// Optimize for vertex shader caches
|
|
if (vertexCacheOptimize) {
|
|
for (i = 0; i < length; ++i) {
|
|
var instance = instances[i];
|
|
if (when.defined(instance.geometry)) {
|
|
GeometryPipeline.GeometryPipeline.reorderForPostVertexCache(instance.geometry);
|
|
GeometryPipeline.GeometryPipeline.reorderForPreVertexCache(instance.geometry);
|
|
} else if (when.defined(instance.westHemisphereGeometry) && when.defined(instance.eastHemisphereGeometry)) {
|
|
GeometryPipeline.GeometryPipeline.reorderForPostVertexCache(instance.westHemisphereGeometry);
|
|
GeometryPipeline.GeometryPipeline.reorderForPreVertexCache(instance.westHemisphereGeometry);
|
|
|
|
GeometryPipeline.GeometryPipeline.reorderForPostVertexCache(instance.eastHemisphereGeometry);
|
|
GeometryPipeline.GeometryPipeline.reorderForPreVertexCache(instance.eastHemisphereGeometry);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Combine into single geometry for better rendering performance.
|
|
var geometries = GeometryPipeline.GeometryPipeline.combineInstances(instances);
|
|
|
|
length = geometries.length;
|
|
for (i = 0; i < length; ++i) {
|
|
geometry = geometries[i];
|
|
|
|
// Split positions for GPU RTE
|
|
var attributes = geometry.attributes;
|
|
var name;
|
|
if (!scene3DOnly) {
|
|
for (name in attributes) {
|
|
if (attributes.hasOwnProperty(name) && attributes[name].componentDatatype === ComponentDatatype.ComponentDatatype.DOUBLE) {
|
|
var name3D = name + '3D';
|
|
var name2D = name + '2D';
|
|
|
|
// Compute 2D positions
|
|
GeometryPipeline.GeometryPipeline.projectTo2D(geometry, name, name3D, name2D, projection);
|
|
if (when.defined(geometry.boundingSphere) && name === 'position') {
|
|
geometry.boundingSphereCV = BoundingSphere.BoundingSphere.fromVertices(geometry.attributes.position2D.values);
|
|
}
|
|
|
|
GeometryPipeline.GeometryPipeline.encodeAttribute(geometry, name3D, name3D + 'High', name3D + 'Low');
|
|
GeometryPipeline.GeometryPipeline.encodeAttribute(geometry, name2D, name2D + 'High', name2D + 'Low');
|
|
}
|
|
}
|
|
} else {
|
|
for (name in attributes) {
|
|
if (attributes.hasOwnProperty(name) && attributes[name].componentDatatype === ComponentDatatype.ComponentDatatype.DOUBLE) {
|
|
GeometryPipeline.GeometryPipeline.encodeAttribute(geometry, name, name + '3DHigh', name + '3DLow');
|
|
}
|
|
}
|
|
}
|
|
|
|
// oct encode and pack normals, compress texture coordinates
|
|
if (compressVertices) {
|
|
GeometryPipeline.GeometryPipeline.compressVertices(geometry);
|
|
}
|
|
}
|
|
|
|
if (!uintIndexSupport) {
|
|
// Break into multiple geometries to fit within unsigned short indices if needed
|
|
var splitGeometries = [];
|
|
length = geometries.length;
|
|
for (i = 0; i < length; ++i) {
|
|
geometry = geometries[i];
|
|
splitGeometries = splitGeometries.concat(GeometryPipeline.GeometryPipeline.fitToUnsignedShortIndices(geometry));
|
|
}
|
|
|
|
geometries = splitGeometries;
|
|
}
|
|
|
|
return geometries;
|
|
}
|
|
|
|
function createPickOffsets(instances, geometryName, geometries, pickOffsets) {
|
|
var offset;
|
|
var indexCount;
|
|
var geometryIndex;
|
|
|
|
var offsetIndex = pickOffsets.length - 1;
|
|
if (offsetIndex >= 0) {
|
|
var pickOffset = pickOffsets[offsetIndex];
|
|
offset = pickOffset.offset + pickOffset.count;
|
|
geometryIndex = pickOffset.index;
|
|
indexCount = geometries[geometryIndex].indices.length;
|
|
} else {
|
|
offset = 0;
|
|
geometryIndex = 0;
|
|
indexCount = geometries[geometryIndex].indices.length;
|
|
}
|
|
|
|
var length = instances.length;
|
|
for (var i = 0; i < length; ++i) {
|
|
var instance = instances[i];
|
|
var geometry = instance[geometryName];
|
|
if (!when.defined(geometry)) {
|
|
continue;
|
|
}
|
|
|
|
var count = geometry.indices.length;
|
|
|
|
if (offset + count > indexCount) {
|
|
offset = 0;
|
|
indexCount = geometries[++geometryIndex].indices.length;
|
|
}
|
|
|
|
pickOffsets.push({
|
|
index : geometryIndex,
|
|
offset : offset,
|
|
count : count
|
|
});
|
|
offset += count;
|
|
}
|
|
}
|
|
|
|
function createInstancePickOffsets(instances, geometries) {
|
|
var pickOffsets = [];
|
|
createPickOffsets(instances, 'geometry', geometries, pickOffsets);
|
|
createPickOffsets(instances, 'westHemisphereGeometry', geometries, pickOffsets);
|
|
createPickOffsets(instances, 'eastHemisphereGeometry', geometries, pickOffsets);
|
|
return pickOffsets;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
var PrimitivePipeline = {};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
PrimitivePipeline.combineGeometry = function(parameters) {
|
|
var geometries;
|
|
var attributeLocations;
|
|
var instances = parameters.instances;
|
|
var length = instances.length;
|
|
var pickOffsets;
|
|
|
|
var offsetInstanceExtend;
|
|
var hasOffset = false;
|
|
if (length > 0) {
|
|
geometries = geometryPipeline(parameters);
|
|
if (geometries.length > 0) {
|
|
attributeLocations = GeometryPipeline.GeometryPipeline.createAttributeLocations(geometries[0]);
|
|
if (parameters.createPickOffsets) {
|
|
pickOffsets = createInstancePickOffsets(instances, geometries);
|
|
}
|
|
}
|
|
if (when.defined(instances[0].attributes) && when.defined(instances[0].attributes.offset)) {
|
|
offsetInstanceExtend = new Array(length);
|
|
hasOffset = true;
|
|
}
|
|
}
|
|
|
|
var boundingSpheres = new Array(length);
|
|
var boundingSpheresCV = new Array(length);
|
|
for (var i = 0; i < length; ++i) {
|
|
var instance = instances[i];
|
|
var geometry = instance.geometry;
|
|
if (when.defined(geometry)) {
|
|
boundingSpheres[i] = geometry.boundingSphere;
|
|
boundingSpheresCV[i] = geometry.boundingSphereCV;
|
|
if (hasOffset) {
|
|
offsetInstanceExtend[i] = instance.geometry.offsetAttribute;
|
|
}
|
|
}
|
|
|
|
var eastHemisphereGeometry = instance.eastHemisphereGeometry;
|
|
var westHemisphereGeometry = instance.westHemisphereGeometry;
|
|
if (when.defined(eastHemisphereGeometry) && when.defined(westHemisphereGeometry)) {
|
|
if (when.defined(eastHemisphereGeometry.boundingSphere) && when.defined(westHemisphereGeometry.boundingSphere)) {
|
|
boundingSpheres[i] = BoundingSphere.BoundingSphere.union(eastHemisphereGeometry.boundingSphere, westHemisphereGeometry.boundingSphere);
|
|
}
|
|
if (when.defined(eastHemisphereGeometry.boundingSphereCV) && when.defined(westHemisphereGeometry.boundingSphereCV)) {
|
|
boundingSpheresCV[i] = BoundingSphere.BoundingSphere.union(eastHemisphereGeometry.boundingSphereCV, westHemisphereGeometry.boundingSphereCV);
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
geometries : geometries,
|
|
modelMatrix : parameters.modelMatrix,
|
|
attributeLocations : attributeLocations,
|
|
pickOffsets : pickOffsets,
|
|
offsetInstanceExtend : offsetInstanceExtend,
|
|
boundingSpheres : boundingSpheres,
|
|
boundingSpheresCV : boundingSpheresCV
|
|
};
|
|
};
|
|
|
|
function transferGeometry(geometry, transferableObjects) {
|
|
var attributes = geometry.attributes;
|
|
for (var name in attributes) {
|
|
if (attributes.hasOwnProperty(name)) {
|
|
var attribute = attributes[name];
|
|
|
|
if (when.defined(attribute) && when.defined(attribute.values)) {
|
|
transferableObjects.push(attribute.values.buffer);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (when.defined(geometry.indices)) {
|
|
transferableObjects.push(geometry.indices.buffer);
|
|
}
|
|
}
|
|
|
|
function transferGeometries(geometries, transferableObjects) {
|
|
var length = geometries.length;
|
|
for (var i = 0; i < length; ++i) {
|
|
transferGeometry(geometries[i], transferableObjects);
|
|
}
|
|
}
|
|
|
|
// This function was created by simplifying packCreateGeometryResults into a count-only operation.
|
|
function countCreateGeometryResults(items) {
|
|
var count = 1;
|
|
var length = items.length;
|
|
for (var i = 0; i < length; i++) {
|
|
var geometry = items[i];
|
|
++count;
|
|
|
|
if (!when.defined(geometry)) {
|
|
continue;
|
|
}
|
|
|
|
var attributes = geometry.attributes;
|
|
|
|
count += 7 + 2 * BoundingSphere.BoundingSphere.packedLength + (when.defined(geometry.indices) ? geometry.indices.length : 0);
|
|
|
|
for (var property in attributes) {
|
|
if (attributes.hasOwnProperty(property) && when.defined(attributes[property])) {
|
|
var attribute = attributes[property];
|
|
count += 5 + attribute.values.length;
|
|
}
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
PrimitivePipeline.packCreateGeometryResults = function(items, transferableObjects) {
|
|
var packedData = new Float64Array(countCreateGeometryResults(items));
|
|
var stringTable = [];
|
|
var stringHash = {};
|
|
|
|
var length = items.length;
|
|
var count = 0;
|
|
packedData[count++] = length;
|
|
for (var i = 0; i < length; i++) {
|
|
var geometry = items[i];
|
|
|
|
var validGeometry = when.defined(geometry);
|
|
packedData[count++] = validGeometry ? 1.0 : 0.0;
|
|
|
|
if (!validGeometry) {
|
|
continue;
|
|
}
|
|
|
|
packedData[count++] = geometry.primitiveType;
|
|
packedData[count++] = geometry.geometryType;
|
|
packedData[count++] = when.defaultValue(geometry.offsetAttribute, -1);
|
|
|
|
var validBoundingSphere = when.defined(geometry.boundingSphere) ? 1.0 : 0.0;
|
|
packedData[count++] = validBoundingSphere;
|
|
if (validBoundingSphere) {
|
|
BoundingSphere.BoundingSphere.pack(geometry.boundingSphere, packedData, count);
|
|
}
|
|
|
|
count += BoundingSphere.BoundingSphere.packedLength;
|
|
|
|
var validBoundingSphereCV = when.defined(geometry.boundingSphereCV) ? 1.0 : 0.0;
|
|
packedData[count++] = validBoundingSphereCV;
|
|
if (validBoundingSphereCV) {
|
|
BoundingSphere.BoundingSphere.pack(geometry.boundingSphereCV, packedData, count);
|
|
}
|
|
|
|
count += BoundingSphere.BoundingSphere.packedLength;
|
|
|
|
var attributes = geometry.attributes;
|
|
var attributesToWrite = [];
|
|
for (var property in attributes) {
|
|
if (attributes.hasOwnProperty(property) && when.defined(attributes[property])) {
|
|
attributesToWrite.push(property);
|
|
if (!when.defined(stringHash[property])) {
|
|
stringHash[property] = stringTable.length;
|
|
stringTable.push(property);
|
|
}
|
|
}
|
|
}
|
|
|
|
packedData[count++] = attributesToWrite.length;
|
|
for (var q = 0; q < attributesToWrite.length; q++) {
|
|
var name = attributesToWrite[q];
|
|
var attribute = attributes[name];
|
|
packedData[count++] = stringHash[name];
|
|
packedData[count++] = attribute.componentDatatype;
|
|
packedData[count++] = attribute.componentsPerAttribute;
|
|
packedData[count++] = attribute.normalize ? 1 : 0;
|
|
packedData[count++] = attribute.values.length;
|
|
packedData.set(attribute.values, count);
|
|
count += attribute.values.length;
|
|
}
|
|
|
|
var indicesLength = when.defined(geometry.indices) ? geometry.indices.length : 0;
|
|
packedData[count++] = indicesLength;
|
|
|
|
if (indicesLength > 0) {
|
|
packedData.set(geometry.indices, count);
|
|
count += indicesLength;
|
|
}
|
|
}
|
|
|
|
transferableObjects.push(packedData.buffer);
|
|
|
|
return {
|
|
stringTable : stringTable,
|
|
packedData : packedData
|
|
};
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
PrimitivePipeline.unpackCreateGeometryResults = function(createGeometryResult) {
|
|
var stringTable = createGeometryResult.stringTable;
|
|
var packedGeometry = createGeometryResult.packedData;
|
|
|
|
var i;
|
|
var result = new Array(packedGeometry[0]);
|
|
var resultIndex = 0;
|
|
|
|
var packedGeometryIndex = 1;
|
|
while (packedGeometryIndex < packedGeometry.length) {
|
|
var valid = packedGeometry[packedGeometryIndex++] === 1.0;
|
|
if (!valid) {
|
|
result[resultIndex++] = undefined;
|
|
continue;
|
|
}
|
|
|
|
var primitiveType = packedGeometry[packedGeometryIndex++];
|
|
var geometryType = packedGeometry[packedGeometryIndex++];
|
|
var offsetAttribute = packedGeometry[packedGeometryIndex++];
|
|
if (offsetAttribute === -1) {
|
|
offsetAttribute = undefined;
|
|
}
|
|
|
|
var boundingSphere;
|
|
var boundingSphereCV;
|
|
|
|
var validBoundingSphere = packedGeometry[packedGeometryIndex++] === 1.0;
|
|
if (validBoundingSphere) {
|
|
boundingSphere = BoundingSphere.BoundingSphere.unpack(packedGeometry, packedGeometryIndex);
|
|
}
|
|
|
|
packedGeometryIndex += BoundingSphere.BoundingSphere.packedLength;
|
|
|
|
var validBoundingSphereCV = packedGeometry[packedGeometryIndex++] === 1.0;
|
|
if (validBoundingSphereCV) {
|
|
boundingSphereCV = BoundingSphere.BoundingSphere.unpack(packedGeometry, packedGeometryIndex);
|
|
}
|
|
|
|
packedGeometryIndex += BoundingSphere.BoundingSphere.packedLength;
|
|
|
|
var length;
|
|
var values;
|
|
var componentsPerAttribute;
|
|
var attributes = new GeometryAttributes.GeometryAttributes();
|
|
var numAttributes = packedGeometry[packedGeometryIndex++];
|
|
for (i = 0; i < numAttributes; i++) {
|
|
var name = stringTable[packedGeometry[packedGeometryIndex++]];
|
|
var componentDatatype = packedGeometry[packedGeometryIndex++];
|
|
componentsPerAttribute = packedGeometry[packedGeometryIndex++];
|
|
var normalize = packedGeometry[packedGeometryIndex++] !== 0;
|
|
|
|
length = packedGeometry[packedGeometryIndex++];
|
|
values = ComponentDatatype.ComponentDatatype.createTypedArray(componentDatatype, length);
|
|
for (var valuesIndex = 0; valuesIndex < length; valuesIndex++) {
|
|
values[valuesIndex] = packedGeometry[packedGeometryIndex++];
|
|
}
|
|
|
|
attributes[name] = new GeometryAttribute.GeometryAttribute({
|
|
componentDatatype : componentDatatype,
|
|
componentsPerAttribute : componentsPerAttribute,
|
|
normalize : normalize,
|
|
values : values
|
|
});
|
|
}
|
|
|
|
var indices;
|
|
length = packedGeometry[packedGeometryIndex++];
|
|
|
|
if (length > 0) {
|
|
var numberOfVertices = values.length / componentsPerAttribute;
|
|
indices = IndexDatatype.IndexDatatype.createTypedArray(numberOfVertices, length);
|
|
for (i = 0; i < length; i++) {
|
|
indices[i] = packedGeometry[packedGeometryIndex++];
|
|
}
|
|
}
|
|
|
|
result[resultIndex++] = new GeometryAttribute.Geometry({
|
|
primitiveType : primitiveType,
|
|
geometryType : geometryType,
|
|
boundingSphere : boundingSphere,
|
|
boundingSphereCV : boundingSphereCV,
|
|
indices : indices,
|
|
attributes : attributes,
|
|
offsetAttribute: offsetAttribute
|
|
});
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
function packInstancesForCombine(instances, transferableObjects) {
|
|
var length = instances.length;
|
|
var packedData = new Float64Array(1 + (length * 19));
|
|
var count = 0;
|
|
packedData[count++] = length;
|
|
for (var i = 0; i < length; i++) {
|
|
var instance = instances[i];
|
|
BoundingSphere.Matrix4.pack(instance.modelMatrix, packedData, count);
|
|
count += BoundingSphere.Matrix4.packedLength;
|
|
if (when.defined(instance.attributes) && when.defined(instance.attributes.offset)) {
|
|
var values = instance.attributes.offset.value;
|
|
packedData[count] = values[0];
|
|
packedData[count + 1] = values[1];
|
|
packedData[count + 2] = values[2];
|
|
}
|
|
count += 3;
|
|
}
|
|
transferableObjects.push(packedData.buffer);
|
|
|
|
return packedData;
|
|
}
|
|
|
|
function unpackInstancesForCombine(data) {
|
|
var packedInstances = data;
|
|
var result = new Array(packedInstances[0]);
|
|
var count = 0;
|
|
|
|
var i = 1;
|
|
while (i < packedInstances.length) {
|
|
var modelMatrix = BoundingSphere.Matrix4.unpack(packedInstances, i);
|
|
var attributes;
|
|
i += BoundingSphere.Matrix4.packedLength;
|
|
if (when.defined(packedInstances[i])) {
|
|
attributes = {
|
|
offset : new OffsetGeometryInstanceAttribute(packedInstances[i], packedInstances[i + 1], packedInstances[i + 2])
|
|
};
|
|
}
|
|
i += 3;
|
|
|
|
result[count++] = {
|
|
modelMatrix : modelMatrix,
|
|
attributes : attributes
|
|
};
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
PrimitivePipeline.packCombineGeometryParameters = function(parameters, transferableObjects) {
|
|
var createGeometryResults = parameters.createGeometryResults;
|
|
var length = createGeometryResults.length;
|
|
|
|
for (var i = 0; i < length; i++) {
|
|
transferableObjects.push(createGeometryResults[i].packedData.buffer);
|
|
}
|
|
|
|
return {
|
|
createGeometryResults : parameters.createGeometryResults,
|
|
packedInstances : packInstancesForCombine(parameters.instances, transferableObjects),
|
|
ellipsoid : parameters.ellipsoid,
|
|
isGeographic : parameters.projection instanceof BoundingSphere.GeographicProjection,
|
|
elementIndexUintSupported : parameters.elementIndexUintSupported,
|
|
scene3DOnly : parameters.scene3DOnly,
|
|
vertexCacheOptimize : parameters.vertexCacheOptimize,
|
|
compressVertices : parameters.compressVertices,
|
|
modelMatrix : parameters.modelMatrix,
|
|
createPickOffsets : parameters.createPickOffsets
|
|
};
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
PrimitivePipeline.unpackCombineGeometryParameters = function(packedParameters) {
|
|
var instances = unpackInstancesForCombine(packedParameters.packedInstances);
|
|
var createGeometryResults = packedParameters.createGeometryResults;
|
|
var length = createGeometryResults.length;
|
|
var instanceIndex = 0;
|
|
|
|
for (var resultIndex = 0; resultIndex < length; resultIndex++) {
|
|
var geometries = PrimitivePipeline.unpackCreateGeometryResults(createGeometryResults[resultIndex]);
|
|
var geometriesLength = geometries.length;
|
|
for (var geometryIndex = 0; geometryIndex < geometriesLength; geometryIndex++) {
|
|
var geometry = geometries[geometryIndex];
|
|
var instance = instances[instanceIndex];
|
|
instance.geometry = geometry;
|
|
++instanceIndex;
|
|
}
|
|
}
|
|
|
|
var ellipsoid = Cartesian2.Ellipsoid.clone(packedParameters.ellipsoid);
|
|
var projection = packedParameters.isGeographic ? new BoundingSphere.GeographicProjection(ellipsoid) : new WebMercatorProjection.WebMercatorProjection(ellipsoid);
|
|
|
|
return {
|
|
instances : instances,
|
|
ellipsoid : ellipsoid,
|
|
projection : projection,
|
|
elementIndexUintSupported : packedParameters.elementIndexUintSupported,
|
|
scene3DOnly : packedParameters.scene3DOnly,
|
|
vertexCacheOptimize : packedParameters.vertexCacheOptimize,
|
|
compressVertices : packedParameters.compressVertices,
|
|
modelMatrix : BoundingSphere.Matrix4.clone(packedParameters.modelMatrix),
|
|
createPickOffsets : packedParameters.createPickOffsets
|
|
};
|
|
};
|
|
|
|
function packBoundingSpheres(boundingSpheres) {
|
|
var length = boundingSpheres.length;
|
|
var bufferLength = 1 + (BoundingSphere.BoundingSphere.packedLength + 1) * length;
|
|
var buffer = new Float32Array(bufferLength);
|
|
|
|
var bufferIndex = 0;
|
|
buffer[bufferIndex++] = length;
|
|
|
|
for (var i = 0; i < length; ++i) {
|
|
var bs = boundingSpheres[i];
|
|
if (!when.defined(bs)) {
|
|
buffer[bufferIndex++] = 0.0;
|
|
} else {
|
|
buffer[bufferIndex++] = 1.0;
|
|
BoundingSphere.BoundingSphere.pack(boundingSpheres[i], buffer, bufferIndex);
|
|
}
|
|
bufferIndex += BoundingSphere.BoundingSphere.packedLength;
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
function unpackBoundingSpheres(buffer) {
|
|
var result = new Array(buffer[0]);
|
|
var count = 0;
|
|
|
|
var i = 1;
|
|
while (i < buffer.length) {
|
|
if (buffer[i++] === 1.0) {
|
|
result[count] = BoundingSphere.BoundingSphere.unpack(buffer, i);
|
|
}
|
|
++count;
|
|
i += BoundingSphere.BoundingSphere.packedLength;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
PrimitivePipeline.packCombineGeometryResults = function(results, transferableObjects) {
|
|
if (when.defined(results.geometries)) {
|
|
transferGeometries(results.geometries, transferableObjects);
|
|
}
|
|
|
|
var packedBoundingSpheres = packBoundingSpheres(results.boundingSpheres);
|
|
var packedBoundingSpheresCV = packBoundingSpheres(results.boundingSpheresCV);
|
|
transferableObjects.push(packedBoundingSpheres.buffer, packedBoundingSpheresCV.buffer);
|
|
|
|
return {
|
|
geometries : results.geometries,
|
|
attributeLocations : results.attributeLocations,
|
|
modelMatrix : results.modelMatrix,
|
|
pickOffsets : results.pickOffsets,
|
|
offsetInstanceExtend: results.offsetInstanceExtend,
|
|
boundingSpheres : packedBoundingSpheres,
|
|
boundingSpheresCV : packedBoundingSpheresCV
|
|
};
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
PrimitivePipeline.unpackCombineGeometryResults = function(packedResult) {
|
|
return {
|
|
geometries : packedResult.geometries,
|
|
attributeLocations : packedResult.attributeLocations,
|
|
modelMatrix : packedResult.modelMatrix,
|
|
pickOffsets : packedResult.pickOffsets,
|
|
offsetInstanceExtend: packedResult.offsetInstanceExtend,
|
|
boundingSpheres : unpackBoundingSpheres(packedResult.boundingSpheres),
|
|
boundingSpheresCV : unpackBoundingSpheres(packedResult.boundingSpheresCV)
|
|
};
|
|
};
|
|
|
|
exports.PrimitivePipeline = PrimitivePipeline;
|
|
|
|
});
|