340 lines
11 KiB
JavaScript
340 lines
11 KiB
JavaScript
define([
|
|
'../Core/Color',
|
|
'../Core/combine',
|
|
'../Core/defaultValue',
|
|
'../Core/defined',
|
|
'../Core/defineProperties',
|
|
'../Core/destroyObject',
|
|
'../Core/DeveloperError',
|
|
'../Core/FeatureDetection',
|
|
'../Core/Math',
|
|
'../Renderer/Pass',
|
|
'../Renderer/ShaderSource',
|
|
'./Cesium3DTileBatchTable',
|
|
'./Cesium3DTileFeature',
|
|
'./Cesium3DTileRefine',
|
|
'./PointCloud',
|
|
'./SceneMode'
|
|
], function(
|
|
Color,
|
|
combine,
|
|
defaultValue,
|
|
defined,
|
|
defineProperties,
|
|
destroyObject,
|
|
DeveloperError,
|
|
FeatureDetection,
|
|
CesiumMath,
|
|
Pass,
|
|
ShaderSource,
|
|
Cesium3DTileBatchTable,
|
|
Cesium3DTileFeature,
|
|
Cesium3DTileRefine,
|
|
PointCloud,
|
|
SceneMode) {
|
|
'use strict';
|
|
|
|
/**
|
|
* Represents the contents of a
|
|
* {@link https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification/TileFormats/PointCloud|Point Cloud}
|
|
* tile in a {@link https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification|3D Tiles} tileset.
|
|
* <p>
|
|
* Implements the {@link Cesium3DTileContent} interface.
|
|
* </p>
|
|
*
|
|
* @alias PointCloud3DTileContent
|
|
* @constructor
|
|
*
|
|
* @private
|
|
*/
|
|
function PointCloud3DTileContent(tileset, tile, resource, arrayBuffer, byteOffset) {
|
|
this._tileset = tileset;
|
|
this._tile = tile;
|
|
this._resource = resource;
|
|
this._pickId = undefined; // Only defined when batchTable is undefined
|
|
this._batchTable = undefined; // Used when feature table contains BATCH_ID semantic
|
|
this._styleDirty = false;
|
|
this._features = undefined;
|
|
|
|
/**
|
|
* @inheritdoc Cesium3DTileContent#featurePropertiesDirty
|
|
*/
|
|
this.featurePropertiesDirty = false;
|
|
|
|
this._pointCloud = new PointCloud({
|
|
arrayBuffer : arrayBuffer,
|
|
byteOffset : byteOffset,
|
|
cull : false,
|
|
opaquePass : Pass.CESIUM_3D_TILE,
|
|
vertexShaderLoaded : getVertexShaderLoaded(this),
|
|
fragmentShaderLoaded : getFragmentShaderLoaded(this),
|
|
uniformMapLoaded : getUniformMapLoaded(this),
|
|
batchTableLoaded : getBatchTableLoaded(this),
|
|
pickIdLoaded : getPickIdLoaded(this)
|
|
});
|
|
}
|
|
|
|
defineProperties(PointCloud3DTileContent.prototype, {
|
|
featuresLength : {
|
|
get : function() {
|
|
if (defined(this._batchTable)) {
|
|
return this._batchTable.featuresLength;
|
|
}
|
|
return 0;
|
|
}
|
|
},
|
|
|
|
pointsLength : {
|
|
get : function() {
|
|
return this._pointCloud.pointsLength;
|
|
}
|
|
},
|
|
|
|
trianglesLength : {
|
|
get : function() {
|
|
return 0;
|
|
}
|
|
},
|
|
|
|
geometryByteLength : {
|
|
get : function() {
|
|
return this._pointCloud.geometryByteLength;
|
|
}
|
|
},
|
|
|
|
texturesByteLength : {
|
|
get : function() {
|
|
return 0;
|
|
}
|
|
},
|
|
|
|
batchTableByteLength : {
|
|
get : function() {
|
|
if (defined(this._batchTable)) {
|
|
return this._batchTable.memorySizeInBytes;
|
|
}
|
|
return 0;
|
|
}
|
|
},
|
|
|
|
innerContents : {
|
|
get : function() {
|
|
return undefined;
|
|
}
|
|
},
|
|
|
|
readyPromise : {
|
|
get : function() {
|
|
return this._pointCloud.readyPromise;
|
|
}
|
|
},
|
|
|
|
tileset : {
|
|
get : function() {
|
|
return this._tileset;
|
|
}
|
|
},
|
|
|
|
tile : {
|
|
get : function() {
|
|
return this._tile;
|
|
}
|
|
},
|
|
|
|
url : {
|
|
get : function() {
|
|
return this._resource.getUrlComponent(true);
|
|
}
|
|
},
|
|
|
|
batchTable : {
|
|
get : function() {
|
|
return this._batchTable;
|
|
}
|
|
}
|
|
});
|
|
|
|
function getVertexShaderLoaded(content) {
|
|
return function(vs) {
|
|
if (defined(content._batchTable)) {
|
|
return content._batchTable.getVertexShaderCallback(false, 'a_batchId', undefined)(vs);
|
|
|
|
}
|
|
return vs;
|
|
};
|
|
}
|
|
|
|
function getFragmentShaderLoaded(content) {
|
|
return function(fs) {
|
|
if (defined(content._batchTable)) {
|
|
return content._batchTable.getFragmentShaderCallback(false, undefined)(fs);
|
|
}
|
|
return 'uniform vec4 czm_pickColor;\n' + fs;
|
|
};
|
|
}
|
|
|
|
function getUniformMapLoaded(content) {
|
|
return function(uniformMap) {
|
|
if (defined(content._batchTable)) {
|
|
return content._batchTable.getUniformMapCallback()(uniformMap);
|
|
}
|
|
return combine(uniformMap, {
|
|
czm_pickColor : function() {
|
|
return content._pickId.color;
|
|
}
|
|
});
|
|
};
|
|
}
|
|
|
|
function getBatchTableLoaded(content) {
|
|
return function(batchLength, batchTableJson, batchTableBinary) {
|
|
content._batchTable = new Cesium3DTileBatchTable(content, batchLength, batchTableJson, batchTableBinary);
|
|
};
|
|
}
|
|
|
|
function getPickIdLoaded(content) {
|
|
return function() {
|
|
return defined(content._batchTable) ? content._batchTable.getPickId() : 'czm_pickColor';
|
|
};
|
|
}
|
|
|
|
function getGeometricError(content) {
|
|
var pointCloudShading = content._tileset.pointCloudShading;
|
|
var sphereVolume = content._tile.contentBoundingVolume.boundingSphere.volume();
|
|
var baseResolutionApproximation = CesiumMath.cbrt(sphereVolume / content.pointsLength);
|
|
|
|
var geometricError = content._tile.geometricError;
|
|
if (geometricError === 0) {
|
|
if (defined(pointCloudShading) && defined(pointCloudShading.baseResolution)) {
|
|
geometricError = pointCloudShading.baseResolution;
|
|
} else {
|
|
geometricError = baseResolutionApproximation;
|
|
}
|
|
}
|
|
return geometricError;
|
|
}
|
|
|
|
function createFeatures(content) {
|
|
var featuresLength = content.featuresLength;
|
|
if (!defined(content._features) && (featuresLength > 0)) {
|
|
var features = new Array(featuresLength);
|
|
for (var i = 0; i < featuresLength; ++i) {
|
|
features[i] = new Cesium3DTileFeature(content, i);
|
|
}
|
|
content._features = features;
|
|
}
|
|
}
|
|
|
|
PointCloud3DTileContent.prototype.hasProperty = function(batchId, name) {
|
|
if (defined(this._batchTable)) {
|
|
return this._batchTable.hasProperty(batchId, name);
|
|
}
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* Part of the {@link Cesium3DTileContent} interface.
|
|
*
|
|
* In this context a feature refers to a group of points that share the same BATCH_ID.
|
|
* For example all the points that represent a door in a house point cloud would be a feature.
|
|
*
|
|
* Features are backed by a batch table and can be colored, shown/hidden, picked, etc like features
|
|
* in b3dm and i3dm.
|
|
*
|
|
* When the BATCH_ID semantic is omitted and the point cloud stores per-point properties, they
|
|
* are not accessible by getFeature. They are only used for dynamic styling.
|
|
*/
|
|
PointCloud3DTileContent.prototype.getFeature = function(batchId) {
|
|
if (!defined(this._batchTable)) {
|
|
return undefined;
|
|
}
|
|
var featuresLength = this.featuresLength;
|
|
//>>includeStart('debug', pragmas.debug);
|
|
if (!defined(batchId) || (batchId < 0) || (batchId >= featuresLength)) {
|
|
throw new DeveloperError('batchId is required and between zero and featuresLength - 1 (' + (featuresLength - 1) + ').');
|
|
}
|
|
//>>includeEnd('debug');
|
|
createFeatures(this);
|
|
return this._features[batchId];
|
|
};
|
|
|
|
PointCloud3DTileContent.prototype.applyDebugSettings = function(enabled, color) {
|
|
this._pointCloud.color = enabled ? color : Color.WHITE;
|
|
};
|
|
|
|
PointCloud3DTileContent.prototype.applyStyle = function(style) {
|
|
if (defined(this._batchTable)) {
|
|
this._batchTable.applyStyle(style);
|
|
} else {
|
|
this._styleDirty = true;
|
|
}
|
|
};
|
|
|
|
PointCloud3DTileContent.prototype.update = function(tileset, frameState) {
|
|
var pointCloud = this._pointCloud;
|
|
var pointCloudShading = tileset.pointCloudShading;
|
|
var tile = this._tile;
|
|
var batchTable = this._batchTable;
|
|
var mode = frameState.mode;
|
|
var clippingPlanes = tileset.clippingPlanes;
|
|
|
|
if (!defined(this._pickId) && !defined(batchTable)) {
|
|
this._pickId = frameState.context.createPickId({
|
|
primitive : tileset,
|
|
content : this
|
|
});
|
|
}
|
|
|
|
if (defined(batchTable)) {
|
|
batchTable.update(tileset, frameState);
|
|
}
|
|
|
|
var boundingSphere;
|
|
if (defined(tile._contentBoundingVolume)) {
|
|
boundingSphere = mode === SceneMode.SCENE3D ? tile._contentBoundingVolume.boundingSphere : tile._contentBoundingVolume2D.boundingSphere;
|
|
} else {
|
|
boundingSphere = mode === SceneMode.SCENE3D ? tile._boundingVolume.boundingSphere : tile._boundingVolume2D.boundingSphere;
|
|
}
|
|
|
|
var styleDirty = this._styleDirty;
|
|
this._styleDirty = false;
|
|
|
|
pointCloud.clippingPlanesOriginMatrix = tileset.clippingPlanesOriginMatrix;
|
|
|
|
pointCloud.style = defined(batchTable) ? undefined : tileset.style;
|
|
pointCloud.styleDirty = styleDirty;
|
|
pointCloud.modelMatrix = tile.computedTransform;
|
|
pointCloud.time = tileset.timeSinceLoad;
|
|
pointCloud.shadows = tileset.shadows;
|
|
pointCloud.boundingSphere = boundingSphere;
|
|
pointCloud.clippingPlanes = clippingPlanes;
|
|
pointCloud.isClipped = defined(clippingPlanes) && clippingPlanes.enabled && tile._isClipped;
|
|
pointCloud.clippingPlanesDirty = tile.clippingPlanesDirty;
|
|
pointCloud.attenuation = defined(pointCloudShading) ? pointCloudShading.attenuation : false;
|
|
pointCloud.geometricError = getGeometricError(this);
|
|
pointCloud.geometricErrorScale = defined(pointCloudShading) ? pointCloudShading.geometricErrorScale : 1.0;
|
|
if (defined(pointCloudShading) && defined(pointCloudShading.maximumAttenuation)) {
|
|
pointCloud.maximumAttenuation = pointCloudShading.maximumAttenuation;
|
|
} else if (tile.refine === Cesium3DTileRefine.ADD) {
|
|
pointCloud.maximumAttenuation = 5.0;
|
|
} else {
|
|
pointCloud.maximumAttenuation = tileset.maximumScreenSpaceError;
|
|
}
|
|
|
|
pointCloud.update(frameState);
|
|
};
|
|
|
|
PointCloud3DTileContent.prototype.isDestroyed = function() {
|
|
return false;
|
|
};
|
|
|
|
PointCloud3DTileContent.prototype.destroy = function() {
|
|
this._pickId = this._pickId && this._pickId.destroy();
|
|
this._pointCloud = this._pointCloud && this._pointCloud.destroy();
|
|
this._batchTable = this._batchTable && this._batchTable.destroy();
|
|
return destroyObject(this);
|
|
};
|
|
|
|
return PointCloud3DTileContent;
|
|
});
|