import arraySlice from '../Core/arraySlice.js';
|
import BoundingSphere from '../Core/BoundingSphere.js';
|
import Cartesian3 from '../Core/Cartesian3.js';
|
import Cartesian4 from '../Core/Cartesian4.js';
|
import Color from '../Core/Color.js';
|
import combine from '../Core/combine.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 FeatureDetection from '../Core/FeatureDetection.js';
|
import IndexDatatype from '../Core/IndexDatatype.js';
|
import Matrix4 from '../Core/Matrix4.js';
|
import PrimitiveType from '../Core/PrimitiveType.js';
|
import RuntimeError from '../Core/RuntimeError.js';
|
import Transforms from '../Core/Transforms.js';
|
import WebGLConstants from '../Core/WebGLConstants.js';
|
import addDefaults from '../ThirdParty/GltfPipeline/addDefaults.js';
|
import ForEach from '../ThirdParty/GltfPipeline/ForEach.js';
|
import getAccessorByteStride from '../ThirdParty/GltfPipeline/getAccessorByteStride.js';
|
import numberOfComponentsForType from '../ThirdParty/GltfPipeline/numberOfComponentsForType.js';
|
import parseGlb from '../ThirdParty/GltfPipeline/parseGlb.js';
|
import updateVersion from '../ThirdParty/GltfPipeline/updateVersion.js';
|
import when from '../ThirdParty/when.js';
|
import Axis from './Axis.js';
|
import ModelLoadResources from './ModelLoadResources.js';
|
import ModelUtility from './ModelUtility.js';
|
import processModelMaterialsCommon from './processModelMaterialsCommon.js';
|
import processPbrMaterials from './processPbrMaterials.js';
|
import SceneMode from './SceneMode.js';
|
import Vector3DTileBatch from './Vector3DTileBatch.js';
|
import Vector3DTilePrimitive from './Vector3DTilePrimitive.js';
|
|
var boundingSphereCartesian3Scratch = new Cartesian3();
|
|
var ModelState = ModelUtility.ModelState;
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/**
|
* A 3D model for classifying other 3D assets based on glTF, the runtime 3D asset format.
|
* This is a special case when a model of a 3D tileset becomes a classifier when setting {@link Cesium3DTileset#classificationType}.
|
*
|
* @alias ClassificationModel
|
* @constructor
|
*
|
* @private
|
*
|
* @param {Object} options Object with the following properties:
|
* @param {ArrayBuffer|Uint8Array} options.gltf A binary glTF buffer.
|
* @param {Boolean} [options.show=true] Determines if the model primitive will be shown.
|
* @param {Matrix4} [options.modelMatrix=Matrix4.IDENTITY] The 4x4 transformation matrix that transforms the model from model to world coordinates.
|
* @param {Boolean} [options.debugShowBoundingVolume=false] For debugging only. Draws the bounding sphere for each draw command in the model.
|
* @param {Boolean} [options.debugWireframe=false] For debugging only. Draws the model in wireframe.
|
* @param {ClassificationType} [options.classificationType] What this model will classify.
|
*
|
* @exception {RuntimeError} Only binary glTF is supported.
|
* @exception {RuntimeError} Buffer data must be embedded in the binary glTF.
|
* @exception {RuntimeError} Only one node is supported for classification and it must have a mesh.
|
* @exception {RuntimeError} Only one mesh is supported when using b3dm for classification.
|
* @exception {RuntimeError} Only one primitive per mesh is supported when using b3dm for classification.
|
* @exception {RuntimeError} The mesh must have a position attribute.
|
* @exception {RuntimeError} The mesh must have a batch id attribute.
|
*/
|
function ClassificationModel(options) {
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
|
var gltf = options.gltf;
|
if (gltf instanceof ArrayBuffer) {
|
gltf = new Uint8Array(gltf);
|
}
|
|
if (gltf instanceof Uint8Array) {
|
// Parse and update binary glTF
|
gltf = parseGlb(gltf);
|
updateVersion(gltf);
|
addDefaults(gltf);
|
processModelMaterialsCommon(gltf);
|
processPbrMaterials(gltf);
|
} else {
|
throw new RuntimeError('Only binary glTF is supported as a classifier.');
|
}
|
|
ForEach.buffer(gltf, function(buffer) {
|
if (!defined(buffer.extras._pipeline.source)) {
|
throw new RuntimeError('Buffer data must be embedded in the binary gltf.');
|
}
|
});
|
|
var gltfNodes = gltf.nodes;
|
var gltfMeshes = gltf.meshes;
|
|
var gltfNode = gltfNodes[0];
|
var meshId = gltfNode.mesh;
|
if (gltfNodes.length !== 1 || !defined(meshId)) {
|
throw new RuntimeError('Only one node is supported for classification and it must have a mesh.');
|
}
|
|
if (gltfMeshes.length !== 1) {
|
throw new RuntimeError('Only one mesh is supported when using b3dm for classification.');
|
}
|
|
var gltfPrimitives = gltfMeshes[0].primitives;
|
if (gltfPrimitives.length !== 1) {
|
throw new RuntimeError('Only one primitive per mesh is supported when using b3dm for classification.');
|
}
|
|
var gltfPositionAttribute = gltfPrimitives[0].attributes.POSITION;
|
if (!defined(gltfPositionAttribute)) {
|
throw new RuntimeError('The mesh must have a position attribute.');
|
}
|
|
var gltfBatchIdAttribute = gltfPrimitives[0].attributes._BATCHID;
|
if (!defined(gltfBatchIdAttribute)) {
|
throw new RuntimeError('The mesh must have a batch id attribute.');
|
}
|
|
this._gltf = gltf;
|
|
/**
|
* Determines if the model primitive will be shown.
|
*
|
* @type {Boolean}
|
*
|
* @default true
|
*/
|
this.show = defaultValue(options.show, true);
|
|
/**
|
* The 4x4 transformation matrix that transforms the model from model to world coordinates.
|
* When this is the identity matrix, the model is drawn in world coordinates, i.e., Earth's WGS84 coordinates.
|
* Local reference frames can be used by providing a different transformation matrix, like that returned
|
* by {@link Transforms.eastNorthUpToFixedFrame}.
|
*
|
* @type {Matrix4}
|
*
|
* @default {@link Matrix4.IDENTITY}
|
*
|
* @example
|
* var origin = Cesium.Cartesian3.fromDegrees(-95.0, 40.0, 200000.0);
|
* m.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(origin);
|
*/
|
this.modelMatrix = Matrix4.clone(defaultValue(options.modelMatrix, Matrix4.IDENTITY));
|
this._modelMatrix = Matrix4.clone(this.modelMatrix);
|
|
this._ready = false;
|
this._readyPromise = when.defer();
|
|
/**
|
* This property is for debugging only; it is not for production use nor is it optimized.
|
* <p>
|
* Draws the bounding sphere for each draw command in the model. A glTF primitive corresponds
|
* to one draw command. A glTF mesh has an array of primitives, often of length one.
|
* </p>
|
*
|
* @type {Boolean}
|
*
|
* @default false
|
*/
|
this.debugShowBoundingVolume = defaultValue(options.debugShowBoundingVolume, false);
|
this._debugShowBoundingVolume = false;
|
|
/**
|
* This property is for debugging only; it is not for production use nor is it optimized.
|
* <p>
|
* Draws the model in wireframe.
|
* </p>
|
*
|
* @type {Boolean}
|
*
|
* @default false
|
*/
|
this.debugWireframe = defaultValue(options.debugWireframe, false);
|
this._debugWireframe = false;
|
|
this._classificationType = options.classificationType;
|
|
// Undocumented options
|
this._vertexShaderLoaded = options.vertexShaderLoaded;
|
this._classificationShaderLoaded = options.classificationShaderLoaded;
|
this._uniformMapLoaded = options.uniformMapLoaded;
|
this._pickIdLoaded = options.pickIdLoaded;
|
this._ignoreCommands = defaultValue(options.ignoreCommands, false);
|
this._upAxis = defaultValue(options.upAxis, Axis.Y);
|
this._batchTable = options.batchTable;
|
|
this._computedModelMatrix = new Matrix4(); // Derived from modelMatrix and axis
|
this._initialRadius = undefined; // Radius without model's scale property, model-matrix scale, animations, or skins
|
this._boundingSphere = undefined;
|
this._scaledBoundingSphere = new BoundingSphere();
|
this._state = ModelState.NEEDS_LOAD;
|
this._loadResources = undefined;
|
|
this._mode = undefined;
|
this._dirty = false; // true when the model was transformed this frame
|
|
this._nodeMatrix = new Matrix4();
|
this._primitive = undefined;
|
|
this._extensionsUsed = undefined; // Cached used glTF extensions
|
this._extensionsRequired = undefined; // Cached required glTF extensions
|
this._quantizedUniforms = undefined; // Quantized uniforms for WEB3D_quantized_attributes
|
|
this._buffers = {};
|
this._vertexArray = undefined;
|
this._shaderProgram = undefined;
|
this._uniformMap = undefined;
|
|
this._geometryByteLength = 0;
|
this._trianglesLength = 0;
|
|
// CESIUM_RTC extension
|
this._rtcCenter = undefined; // reference to either 3D or 2D
|
this._rtcCenterEye = undefined; // in eye coordinates
|
this._rtcCenter3D = undefined; // in world coordinates
|
this._rtcCenter2D = undefined; // in projected world coordinates
|
}
|
|
Object.defineProperties(ClassificationModel.prototype, {
|
/**
|
* The object for the glTF JSON, including properties with default values omitted
|
* from the JSON provided to this model.
|
*
|
* @memberof ClassificationModel.prototype
|
*
|
* @type {Object}
|
* @readonly
|
*
|
* @default undefined
|
*/
|
gltf : {
|
get : function() {
|
return this._gltf;
|
}
|
},
|
|
/**
|
* The model's bounding sphere in its local coordinate system.
|
*
|
* @memberof ClassificationModel.prototype
|
*
|
* @type {BoundingSphere}
|
* @readonly
|
*
|
* @default undefined
|
*
|
* @exception {DeveloperError} The model is not loaded. Use ClassificationModel.readyPromise or wait for ClassificationModel.ready to be true.
|
*
|
* @example
|
* // Center in WGS84 coordinates
|
* var center = Cesium.Matrix4.multiplyByPoint(model.modelMatrix, model.boundingSphere.center, new Cesium.Cartesian3());
|
*/
|
boundingSphere : {
|
get : function() {
|
//>>includeStart('debug', pragmas.debug);
|
if (this._state !== ModelState.LOADED) {
|
throw new DeveloperError('The model is not loaded. Use ClassificationModel.readyPromise or wait for ClassificationModel.ready to be true.');
|
}
|
//>>includeEnd('debug');
|
|
var modelMatrix = this.modelMatrix;
|
var nonUniformScale = Matrix4.getScale(modelMatrix, boundingSphereCartesian3Scratch);
|
|
var scaledBoundingSphere = this._scaledBoundingSphere;
|
scaledBoundingSphere.center = Cartesian3.multiplyComponents(this._boundingSphere.center, nonUniformScale, scaledBoundingSphere.center);
|
scaledBoundingSphere.radius = Cartesian3.maximumComponent(nonUniformScale) * this._initialRadius;
|
|
if (defined(this._rtcCenter)) {
|
Cartesian3.add(this._rtcCenter, scaledBoundingSphere.center, scaledBoundingSphere.center);
|
}
|
|
return scaledBoundingSphere;
|
}
|
},
|
|
/**
|
* When <code>true</code>, this model is ready to render, i.e., the external binary, image,
|
* and shader files were downloaded and the WebGL resources were created. This is set to
|
* <code>true</code> right before {@link ClassificationModel#readyPromise} is resolved.
|
*
|
* @memberof ClassificationModel.prototype
|
*
|
* @type {Boolean}
|
* @readonly
|
*
|
* @default false
|
*/
|
ready : {
|
get : function() {
|
return this._ready;
|
}
|
},
|
|
/**
|
* Gets the promise that will be resolved when this model is ready to render, i.e., when the external binary, image,
|
* and shader files were downloaded and the WebGL resources were created.
|
* <p>
|
* This promise is resolved at the end of the frame before the first frame the model is rendered in.
|
* </p>
|
*
|
* @memberof ClassificationModel.prototype
|
* @type {Promise.<ClassificationModel>}
|
* @readonly
|
*
|
* @see ClassificationModel#ready
|
*/
|
readyPromise : {
|
get : function() {
|
return this._readyPromise.promise;
|
}
|
},
|
|
/**
|
* Returns true if the model was transformed this frame
|
*
|
* @memberof ClassificationModel.prototype
|
*
|
* @type {Boolean}
|
* @readonly
|
*
|
* @private
|
*/
|
dirty : {
|
get : function() {
|
return this._dirty;
|
}
|
},
|
|
/**
|
* Returns an object with all of the glTF extensions used.
|
*
|
* @memberof ClassificationModel.prototype
|
*
|
* @type {Object}
|
* @readonly
|
*/
|
extensionsUsed : {
|
get : function() {
|
if (!defined(this._extensionsUsed)) {
|
this._extensionsUsed = ModelUtility.getUsedExtensions(this.gltf);
|
}
|
return this._extensionsUsed;
|
}
|
},
|
|
/**
|
* Returns an object with all of the glTF extensions required.
|
*
|
* @memberof ClassificationModel.prototype
|
*
|
* @type {Object}
|
* @readonly
|
*/
|
extensionsRequired : {
|
get : function() {
|
if (!defined(this._extensionsRequired)) {
|
this._extensionsRequired = ModelUtility.getRequiredExtensions(this.gltf);
|
}
|
return this._extensionsRequired;
|
}
|
},
|
|
/**
|
* Gets the model's up-axis.
|
* By default models are y-up according to the glTF spec, however geo-referenced models will typically be z-up.
|
*
|
* @memberof ClassificationModel.prototype
|
*
|
* @type {Number}
|
* @default Axis.Y
|
* @readonly
|
*
|
* @private
|
*/
|
upAxis : {
|
get : function() {
|
return this._upAxis;
|
}
|
},
|
|
/**
|
* Gets the model's triangle count.
|
*
|
* @private
|
*/
|
trianglesLength : {
|
get : function() {
|
return this._trianglesLength;
|
}
|
},
|
|
/**
|
* Gets the model's geometry memory in bytes. This includes all vertex and index buffers.
|
*
|
* @private
|
*/
|
geometryByteLength : {
|
get : function() {
|
return this._geometryByteLength;
|
}
|
},
|
|
/**
|
* Gets the model's texture memory in bytes.
|
*
|
* @private
|
*/
|
texturesByteLength : {
|
get : function() {
|
return 0;
|
}
|
},
|
|
/**
|
* Gets the model's classification type.
|
* @memberof ClassificationModel.prototype
|
* @type {ClassificationType}
|
*/
|
classificationType : {
|
get : function() {
|
return this._classificationType;
|
}
|
}
|
});
|
|
///////////////////////////////////////////////////////////////////////////
|
|
function addBuffersToLoadResources(model) {
|
var gltf = model.gltf;
|
var loadResources = model._loadResources;
|
ForEach.buffer(gltf, function(buffer, id) {
|
loadResources.buffers[id] = buffer.extras._pipeline.source;
|
});
|
}
|
|
function parseBufferViews(model) {
|
var bufferViews = model.gltf.bufferViews;
|
|
var vertexBuffersToCreate = model._loadResources.vertexBuffersToCreate;
|
|
// Only ARRAY_BUFFER here. ELEMENT_ARRAY_BUFFER created below.
|
ForEach.bufferView(model.gltf, function(bufferView, id) {
|
if (bufferView.target === WebGLConstants.ARRAY_BUFFER) {
|
vertexBuffersToCreate.enqueue(id);
|
}
|
});
|
|
var indexBuffersToCreate = model._loadResources.indexBuffersToCreate;
|
var indexBufferIds = {};
|
|
// The Cesium Renderer requires knowing the datatype for an index buffer
|
// at creation type, which is not part of the glTF bufferview so loop
|
// through glTF accessors to create the bufferview's index buffer.
|
ForEach.accessor(model.gltf, function(accessor) {
|
var bufferViewId = accessor.bufferView;
|
var bufferView = bufferViews[bufferViewId];
|
|
if ((bufferView.target === WebGLConstants.ELEMENT_ARRAY_BUFFER) && !defined(indexBufferIds[bufferViewId])) {
|
indexBufferIds[bufferViewId] = true;
|
indexBuffersToCreate.enqueue({
|
id : bufferViewId,
|
componentType : accessor.componentType
|
});
|
}
|
});
|
}
|
|
function createVertexBuffer(bufferViewId, model) {
|
var loadResources = model._loadResources;
|
var bufferViews = model.gltf.bufferViews;
|
var bufferView = bufferViews[bufferViewId];
|
var vertexBuffer = loadResources.getBuffer(bufferView);
|
model._buffers[bufferViewId] = vertexBuffer;
|
model._geometryByteLength += vertexBuffer.byteLength;
|
}
|
|
function createIndexBuffer(bufferViewId, componentType, model) {
|
var loadResources = model._loadResources;
|
var bufferViews = model.gltf.bufferViews;
|
var bufferView = bufferViews[bufferViewId];
|
var indexBuffer = {
|
typedArray : loadResources.getBuffer(bufferView),
|
indexDatatype : componentType
|
};
|
model._buffers[bufferViewId] = indexBuffer;
|
model._geometryByteLength += indexBuffer.typedArray.byteLength;
|
}
|
|
function createBuffers(model) {
|
var loadResources = model._loadResources;
|
|
if (loadResources.pendingBufferLoads !== 0) {
|
return;
|
}
|
|
var vertexBuffersToCreate = loadResources.vertexBuffersToCreate;
|
var indexBuffersToCreate = loadResources.indexBuffersToCreate;
|
|
while (vertexBuffersToCreate.length > 0) {
|
createVertexBuffer(vertexBuffersToCreate.dequeue(), model);
|
}
|
|
while (indexBuffersToCreate.length > 0) {
|
var i = indexBuffersToCreate.dequeue();
|
createIndexBuffer(i.id, i.componentType, model);
|
}
|
}
|
|
function modifyShaderForQuantizedAttributes(shader, model) {
|
var primitive = model.gltf.meshes[0].primitives[0];
|
var result = ModelUtility.modifyShaderForQuantizedAttributes(model.gltf, primitive, shader);
|
model._quantizedUniforms = result.uniforms;
|
return result.shader;
|
}
|
|
function modifyShader(shader, callback) {
|
if (defined(callback)) {
|
shader = callback(shader);
|
}
|
return shader;
|
}
|
|
function createProgram(model) {
|
var gltf = model.gltf;
|
|
var positionName = ModelUtility.getAttributeOrUniformBySemantic(gltf, 'POSITION');
|
var batchIdName = ModelUtility.getAttributeOrUniformBySemantic(gltf, '_BATCHID');
|
|
var attributeLocations = {};
|
attributeLocations[positionName] = 0;
|
attributeLocations[batchIdName] = 1;
|
|
var modelViewProjectionName = ModelUtility.getAttributeOrUniformBySemantic(gltf, 'MODELVIEWPROJECTION');
|
|
var uniformDecl;
|
var toClip;
|
|
if (!defined(modelViewProjectionName)) {
|
var projectionName = ModelUtility.getAttributeOrUniformBySemantic(gltf, 'PROJECTION');
|
var modelViewName = ModelUtility.getAttributeOrUniformBySemantic(gltf, 'MODELVIEW');
|
if (!defined(modelViewName)) {
|
modelViewName = ModelUtility.getAttributeOrUniformBySemantic(gltf, 'CESIUM_RTC_MODELVIEW');
|
}
|
|
uniformDecl =
|
'uniform mat4 ' + modelViewName + ';\n' +
|
'uniform mat4 ' + projectionName + ';\n';
|
toClip = projectionName + ' * ' + modelViewName + ' * vec4(' + positionName + ', 1.0)';
|
} else {
|
uniformDecl = 'uniform mat4 ' + modelViewProjectionName + ';\n';
|
toClip = modelViewProjectionName + ' * vec4(' + positionName + ', 1.0)';
|
}
|
|
var computePosition = ' vec4 positionInClipCoords = ' + toClip + ';\n';
|
|
var vs =
|
'attribute vec3 ' + positionName + ';\n' +
|
'attribute float ' + batchIdName + ';\n' +
|
uniformDecl +
|
'void main() {\n' +
|
computePosition +
|
' gl_Position = czm_depthClampFarPlane(positionInClipCoords);\n' +
|
'}\n';
|
var fs =
|
'#ifdef GL_EXT_frag_depth\n' +
|
'#extension GL_EXT_frag_depth : enable\n' +
|
'#endif\n' +
|
'void main() \n' +
|
'{ \n' +
|
' gl_FragColor = vec4(1.0); \n' +
|
' czm_writeDepthClampedToFarPlane();\n' +
|
'}\n';
|
|
if (model.extensionsUsed.WEB3D_quantized_attributes) {
|
vs = modifyShaderForQuantizedAttributes(vs, model);
|
}
|
|
var drawVS = modifyShader(vs, model._vertexShaderLoaded);
|
var drawFS = modifyShader(fs, model._classificationShaderLoaded);
|
|
drawVS = ModelUtility.modifyVertexShaderForLogDepth(drawVS, toClip);
|
drawFS = ModelUtility.modifyFragmentShaderForLogDepth(drawFS);
|
|
model._shaderProgram = {
|
vertexShaderSource : drawVS,
|
fragmentShaderSource : drawFS,
|
attributeLocations : attributeLocations
|
};
|
}
|
|
function getAttributeLocations() {
|
return {
|
POSITION : 0,
|
_BATCHID : 1
|
};
|
}
|
|
function createVertexArray(model) {
|
var loadResources = model._loadResources;
|
if (!loadResources.finishedBuffersCreation() || defined(model._vertexArray)) {
|
return;
|
}
|
|
var rendererBuffers = model._buffers;
|
var gltf = model.gltf;
|
var accessors = gltf.accessors;
|
var meshes = gltf.meshes;
|
var primitives = meshes[0].primitives;
|
|
var primitive = primitives[0];
|
var attributeLocations = getAttributeLocations();
|
var attributes = {};
|
ForEach.meshPrimitiveAttribute(primitive, function(accessorId, attributeName) {
|
// Skip if the attribute is not used by the material, e.g., because the asset
|
// was exported with an attribute that wasn't used and the asset wasn't optimized.
|
var attributeLocation = attributeLocations[attributeName];
|
if (defined(attributeLocation)) {
|
var a = accessors[accessorId];
|
attributes[attributeName] = {
|
index: attributeLocation,
|
vertexBuffer: rendererBuffers[a.bufferView],
|
componentsPerAttribute: numberOfComponentsForType(a.type),
|
componentDatatype: a.componentType,
|
offsetInBytes: a.byteOffset,
|
strideInBytes: getAccessorByteStride(gltf, a)
|
};
|
}
|
});
|
|
var indexBuffer;
|
if (defined(primitive.indices)) {
|
var accessor = accessors[primitive.indices];
|
indexBuffer = rendererBuffers[accessor.bufferView];
|
}
|
model._vertexArray = {
|
attributes : attributes,
|
indexBuffer : indexBuffer
|
};
|
}
|
|
var gltfSemanticUniforms = {
|
PROJECTION : function(uniformState, model) {
|
return ModelUtility.getGltfSemanticUniforms().PROJECTION(uniformState, model);
|
},
|
MODELVIEW : function(uniformState, model) {
|
return ModelUtility.getGltfSemanticUniforms().MODELVIEW(uniformState, model);
|
},
|
CESIUM_RTC_MODELVIEW : function(uniformState, model) {
|
return ModelUtility.getGltfSemanticUniforms().CESIUM_RTC_MODELVIEW(uniformState, model);
|
},
|
MODELVIEWPROJECTION : function(uniformState, model) {
|
return ModelUtility.getGltfSemanticUniforms().MODELVIEWPROJECTION(uniformState, model);
|
}
|
};
|
|
function createUniformMap(model, context) {
|
if (defined(model._uniformMap)) {
|
return;
|
}
|
|
var uniformMap = {};
|
ForEach.technique(model.gltf, function(technique) {
|
ForEach.techniqueUniform(technique, function(uniform, uniformName) {
|
if (!defined(uniform.semantic) || !defined(gltfSemanticUniforms[uniform.semantic])) {
|
return;
|
}
|
|
uniformMap[uniformName] = gltfSemanticUniforms[uniform.semantic](context.uniformState, model);
|
});
|
});
|
|
model._uniformMap = uniformMap;
|
}
|
|
function createUniformsForQuantizedAttributes(model, primitive) {
|
return ModelUtility.createUniformsForQuantizedAttributes(model.gltf, primitive, model._quantizedUniforms);
|
}
|
|
function triangleCountFromPrimitiveIndices(primitive, indicesCount) {
|
switch (primitive.mode) {
|
case PrimitiveType.TRIANGLES:
|
return (indicesCount / 3);
|
case PrimitiveType.TRIANGLE_STRIP:
|
case PrimitiveType.TRIANGLE_FAN:
|
return Math.max(indicesCount - 2, 0);
|
default:
|
return 0;
|
}
|
}
|
|
function createPrimitive(model) {
|
var batchTable = model._batchTable;
|
|
var uniformMap = model._uniformMap;
|
var vertexArray = model._vertexArray;
|
|
var gltf = model.gltf;
|
var accessors = gltf.accessors;
|
var gltfMeshes = gltf.meshes;
|
var primitive = gltfMeshes[0].primitives[0];
|
var ix = accessors[primitive.indices];
|
|
var positionAccessor = primitive.attributes.POSITION;
|
var minMax = ModelUtility.getAccessorMinMax(gltf, positionAccessor);
|
var boundingSphere = BoundingSphere.fromCornerPoints(Cartesian3.fromArray(minMax.min), Cartesian3.fromArray(minMax.max));
|
|
var offset;
|
var count;
|
if (defined(ix)) {
|
count = ix.count;
|
offset = (ix.byteOffset / IndexDatatype.getSizeInBytes(ix.componentType)); // glTF has offset in bytes. Cesium has offsets in indices
|
}
|
else {
|
var positions = accessors[primitive.attributes.POSITION];
|
count = positions.count;
|
offset = 0;
|
}
|
|
// Update model triangle count using number of indices
|
model._trianglesLength += triangleCountFromPrimitiveIndices(primitive, count);
|
|
// Allow callback to modify the uniformMap
|
if (defined(model._uniformMapLoaded)) {
|
uniformMap = model._uniformMapLoaded(uniformMap);
|
}
|
|
// Add uniforms for decoding quantized attributes if used
|
if (model.extensionsUsed.WEB3D_quantized_attributes) {
|
var quantizedUniformMap = createUniformsForQuantizedAttributes(model, primitive);
|
uniformMap = combine(uniformMap, quantizedUniformMap);
|
}
|
|
var attribute = vertexArray.attributes.POSITION;
|
var componentDatatype = attribute.componentDatatype;
|
var typedArray = attribute.vertexBuffer;
|
var byteOffset = typedArray.byteOffset;
|
var bufferLength = typedArray.byteLength / ComponentDatatype.getSizeInBytes(componentDatatype);
|
var positionsBuffer = ComponentDatatype.createArrayBufferView(componentDatatype, typedArray.buffer, byteOffset, bufferLength);
|
|
attribute = vertexArray.attributes._BATCHID;
|
componentDatatype = attribute.componentDatatype;
|
typedArray = attribute.vertexBuffer;
|
byteOffset = typedArray.byteOffset;
|
bufferLength = typedArray.byteLength / ComponentDatatype.getSizeInBytes(componentDatatype);
|
var vertexBatchIds = ComponentDatatype.createArrayBufferView(componentDatatype, typedArray.buffer, byteOffset, bufferLength);
|
|
var buffer = vertexArray.indexBuffer.typedArray;
|
var indices;
|
if (vertexArray.indexBuffer.indexDatatype === IndexDatatype.UNSIGNED_SHORT) {
|
indices = new Uint16Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / Uint16Array.BYTES_PER_ELEMENT);
|
} else {
|
indices = new Uint32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / Uint32Array.BYTES_PER_ELEMENT);
|
}
|
|
positionsBuffer = arraySlice(positionsBuffer);
|
vertexBatchIds = arraySlice(vertexBatchIds);
|
indices = arraySlice(indices, offset, offset + count);
|
|
var batchIds = [];
|
var indexCounts = [];
|
var indexOffsets = [];
|
var batchedIndices = [];
|
|
var currentId = vertexBatchIds[indices[0]];
|
batchIds.push(currentId);
|
indexOffsets.push(0);
|
|
var batchId;
|
var indexOffset;
|
var indexCount;
|
var indicesLength = indices.length;
|
for (var j = 1; j < indicesLength; ++j) {
|
batchId = vertexBatchIds[indices[j]];
|
if (batchId !== currentId) {
|
indexOffset = indexOffsets[indexOffsets.length - 1];
|
indexCount = j - indexOffset;
|
|
batchIds.push(batchId);
|
indexCounts.push(indexCount);
|
indexOffsets.push(j);
|
|
batchedIndices.push(new Vector3DTileBatch({
|
offset : indexOffset,
|
count : indexCount,
|
batchIds : [currentId],
|
color : Color.WHITE
|
}));
|
|
currentId = batchId;
|
}
|
}
|
|
indexOffset = indexOffsets[indexOffsets.length - 1];
|
indexCount = indicesLength - indexOffset;
|
|
indexCounts.push(indexCount);
|
batchedIndices.push(new Vector3DTileBatch({
|
offset : indexOffset,
|
count : indexCount,
|
batchIds : [currentId],
|
color : Color.WHITE
|
}));
|
|
var shader = model._shaderProgram;
|
var vertexShaderSource = shader.vertexShaderSource;
|
var fragmentShaderSource = shader.fragmentShaderSource;
|
var attributeLocations = shader.attributeLocations;
|
var pickId = defined(model._pickIdLoaded) ? model._pickIdLoaded() : undefined;
|
|
model._primitive = new Vector3DTilePrimitive({
|
classificationType : model._classificationType,
|
positions : positionsBuffer,
|
indices : indices,
|
indexOffsets : indexOffsets,
|
indexCounts : indexCounts,
|
batchIds : batchIds,
|
vertexBatchIds : vertexBatchIds,
|
batchedIndices : batchedIndices,
|
batchTable : batchTable,
|
boundingVolume : new BoundingSphere(), // updated in update()
|
_vertexShaderSource : vertexShaderSource,
|
_fragmentShaderSource : fragmentShaderSource,
|
_attributeLocations : attributeLocations,
|
_uniformMap : uniformMap,
|
_pickId : pickId,
|
_modelMatrix : new Matrix4(), // updated in update()
|
_boundingSphere : boundingSphere // used to update boundingVolume
|
});
|
|
// Release CPU resources
|
model._buffers = undefined;
|
model._vertexArray = undefined;
|
model._shaderProgram = undefined;
|
model._uniformMap = undefined;
|
}
|
|
function createRuntimeNodes(model) {
|
var loadResources = model._loadResources;
|
if (!loadResources.finished()) {
|
return;
|
}
|
|
if (defined(model._primitive)) {
|
return;
|
}
|
|
var gltf = model.gltf;
|
var nodes = gltf.nodes;
|
var gltfNode = nodes[0];
|
model._nodeMatrix = ModelUtility.getTransform(gltfNode, model._nodeMatrix);
|
|
createPrimitive(model);
|
}
|
|
function createResources(model, frameState) {
|
var context = frameState.context;
|
|
ModelUtility.checkSupportedGlExtensions(model.gltf.glExtensionsUsed, context);
|
createBuffers(model); // using glTF bufferViews
|
createProgram(model);
|
createVertexArray(model); // using glTF meshes
|
createUniformMap(model, context); // using glTF materials/techniques
|
createRuntimeNodes(model); // using glTF scene
|
}
|
|
///////////////////////////////////////////////////////////////////////////
|
|
var scratchComputedTranslation = new Cartesian4();
|
var scratchComputedMatrixIn2D = new Matrix4();
|
|
function updateNodeModelMatrix(model, modelTransformChanged, justLoaded, projection) {
|
var computedModelMatrix = model._computedModelMatrix;
|
|
if ((model._mode !== SceneMode.SCENE3D) && !model._ignoreCommands) {
|
var translation = Matrix4.getColumn(computedModelMatrix, 3, scratchComputedTranslation);
|
if (!Cartesian4.equals(translation, Cartesian4.UNIT_W)) {
|
computedModelMatrix = Transforms.basisTo2D(projection, computedModelMatrix, scratchComputedMatrixIn2D);
|
model._rtcCenter = model._rtcCenter3D;
|
} else {
|
var center = model.boundingSphere.center;
|
var to2D = Transforms.wgs84To2DModelMatrix(projection, center, scratchComputedMatrixIn2D);
|
computedModelMatrix = Matrix4.multiply(to2D, computedModelMatrix, scratchComputedMatrixIn2D);
|
|
if (defined(model._rtcCenter)) {
|
Matrix4.setTranslation(computedModelMatrix, Cartesian4.UNIT_W, computedModelMatrix);
|
model._rtcCenter = model._rtcCenter2D;
|
}
|
}
|
}
|
|
var primitive = model._primitive;
|
|
if (modelTransformChanged || justLoaded) {
|
Matrix4.multiplyTransformation(computedModelMatrix, model._nodeMatrix, primitive._modelMatrix);
|
BoundingSphere.transform(primitive._boundingSphere, primitive._modelMatrix, primitive._boundingVolume);
|
|
if (defined(model._rtcCenter)) {
|
Cartesian3.add(model._rtcCenter, primitive._boundingVolume.center, primitive._boundingVolume.center);
|
}
|
}
|
}
|
|
///////////////////////////////////////////////////////////////////////////
|
|
ClassificationModel.prototype.updateCommands = function(batchId, color) {
|
this._primitive.updateCommands(batchId, color);
|
};
|
|
ClassificationModel.prototype.update = function(frameState) {
|
if (frameState.mode === SceneMode.MORPHING) {
|
return;
|
}
|
|
if (!FeatureDetection.supportsWebP.initialized) {
|
FeatureDetection.supportsWebP.initialize();
|
return;
|
}
|
var supportsWebP = FeatureDetection.supportsWebP();
|
|
if ((this._state === ModelState.NEEDS_LOAD) && defined(this.gltf)) {
|
this._state = ModelState.LOADING;
|
if (this._state !== ModelState.FAILED) {
|
var extensions = this.gltf.extensions;
|
if (defined(extensions) && defined(extensions.CESIUM_RTC)) {
|
var center = Cartesian3.fromArray(extensions.CESIUM_RTC.center);
|
if (!Cartesian3.equals(center, Cartesian3.ZERO)) {
|
this._rtcCenter3D = center;
|
|
var projection = frameState.mapProjection;
|
var ellipsoid = projection.ellipsoid;
|
var cartographic = ellipsoid.cartesianToCartographic(this._rtcCenter3D);
|
var projectedCart = projection.project(cartographic);
|
Cartesian3.fromElements(projectedCart.z, projectedCart.x, projectedCart.y, projectedCart);
|
this._rtcCenter2D = projectedCart;
|
|
this._rtcCenterEye = new Cartesian3();
|
this._rtcCenter = this._rtcCenter3D;
|
}
|
}
|
|
this._loadResources = new ModelLoadResources();
|
ModelUtility.parseBuffers(this);
|
}
|
}
|
|
var loadResources = this._loadResources;
|
var justLoaded = false;
|
|
if (this._state === ModelState.LOADING) {
|
// Transition from LOADING -> LOADED once resources are downloaded and created.
|
// Textures may continue to stream in while in the LOADED state.
|
if (loadResources.pendingBufferLoads === 0) {
|
ModelUtility.checkSupportedExtensions(this.extensionsRequired, supportsWebP);
|
|
addBuffersToLoadResources(this);
|
parseBufferViews(this);
|
|
this._boundingSphere = ModelUtility.computeBoundingSphere(this);
|
this._initialRadius = this._boundingSphere.radius;
|
createResources(this, frameState);
|
}
|
if (loadResources.finished()) {
|
this._state = ModelState.LOADED;
|
justLoaded = true;
|
}
|
}
|
|
if (defined(loadResources) && (this._state === ModelState.LOADED)) {
|
if (!justLoaded) {
|
createResources(this, frameState);
|
}
|
|
if (loadResources.finished()) {
|
this._loadResources = undefined; // Clear CPU memory since WebGL resources were created.
|
}
|
}
|
|
var show = this.show;
|
|
if ((show && this._state === ModelState.LOADED) || justLoaded) {
|
this._dirty = false;
|
var modelMatrix = this.modelMatrix;
|
|
var modeChanged = frameState.mode !== this._mode;
|
this._mode = frameState.mode;
|
|
// ClassificationModel's model matrix needs to be updated
|
var modelTransformChanged = !Matrix4.equals(this._modelMatrix, modelMatrix) || modeChanged;
|
|
if (modelTransformChanged || justLoaded) {
|
Matrix4.clone(modelMatrix, this._modelMatrix);
|
|
var computedModelMatrix = this._computedModelMatrix;
|
Matrix4.clone(modelMatrix, computedModelMatrix);
|
if (this._upAxis === Axis.Y) {
|
Matrix4.multiplyTransformation(computedModelMatrix, Axis.Y_UP_TO_Z_UP, computedModelMatrix);
|
} else if (this._upAxis === Axis.X) {
|
Matrix4.multiplyTransformation(computedModelMatrix, Axis.X_UP_TO_Z_UP, computedModelMatrix);
|
}
|
}
|
|
// Update modelMatrix throughout the graph as needed
|
if (modelTransformChanged || justLoaded) {
|
updateNodeModelMatrix(this, modelTransformChanged, justLoaded, frameState.mapProjection);
|
this._dirty = true;
|
}
|
}
|
|
if (justLoaded) {
|
// Called after modelMatrix update.
|
var model = this;
|
frameState.afterRender.push(function() {
|
model._ready = true;
|
model._readyPromise.resolve(model);
|
});
|
return;
|
}
|
|
if (show && !this._ignoreCommands) {
|
this._primitive.debugShowBoundingVolume = this.debugShowBoundingVolume;
|
this._primitive.debugWireframe = this.debugWireframe;
|
this._primitive.update(frameState);
|
}
|
};
|
|
ClassificationModel.prototype.isDestroyed = function() {
|
return false;
|
};
|
|
ClassificationModel.prototype.destroy = function() {
|
this._primitive = this._primitive && this._primitive.destroy();
|
return destroyObject(this);
|
};
|
export default ClassificationModel;
|
