text: import Color from '../Core/Color.js';
  import combine from '../Core/combine.js';
  import defaultValue from '../Core/defaultValue.js';
  import defined from '../Core/defined.js';
  import defineProperties from '../Core/defineProperties.js';
  import destroyObject from '../Core/destroyObject.js';
  import DeveloperError from '../Core/DeveloperError.js';
  import CesiumMath from '../Core/Math.js';
  import Pass from '../Renderer/Pass.js';
  import Cesium3DTileBatchTable from './Cesium3DTileBatchTable.js';
  import Cesium3DTileFeature from './Cesium3DTileFeature.js';
  import Cesium3DTileRefine from './Cesium3DTileRefine.js';
  import PointCloud from './PointCloud.js';
  import PointCloudShading from './PointCloudShading.js';
  import SceneMode from './SceneMode.js';
  
      /**
       * Represents the contents of a
       * {@link https://github.com/CesiumGS/3d-tiles/tree/master/specification/TileFormats/PointCloud|Point Cloud}
       * tile in a {@link https://github.com/CesiumGS/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;
          }
      };
  
      var defaultShading = new PointCloudShading();
  
      PointCloud3DTileContent.prototype.update = function(tileset, frameState) {
          var pointCloud = this._pointCloud;
          var pointCloudShading = defaultValue(tileset.pointCloudShading, defaultShading);
          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 = pointCloudShading.attenuation;
          pointCloud.backFaceCulling = pointCloudShading.backFaceCulling;
          pointCloud.normalShading = pointCloudShading.normalShading;
          pointCloud.geometricError = getGeometricError(this);
          pointCloud.geometricErrorScale = pointCloudShading.geometricErrorScale;
          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);
      };
  export default PointCloud3DTileContent;
  