@cesium/engine 17.0.0 → 18.0.1-splats.0

package/Source/Scene/Model/ModelRenderResources.js

@@ -101,6 +101,19 @@ function ModelRenderResources(model) {
    * @private
    */
   this.hasSkipLevelOfDetail = false;
+
+  /**
+   * The NodeRenderResources for the nodes of the scene graph.
+   *
+   * Note that elements of this array may be <code>undefined</code> when
+   * there was no runtime node for a certain node.
+   *
+   * @type {NodeRenderResources[]}
+   * @default []
+   *
+   * @private
+   */
+  this.nodeRenderResources = [];
 }
 
 export default ModelRenderResources;

package/Source/Scene/Model/ModelRuntimePrimitive.js

@@ -12,6 +12,7 @@ import CustomShaderPipelineStage from "./CustomShaderPipelineStage.js";
 import DequantizationPipelineStage from "./DequantizationPipelineStage.js";
 import FeatureIdPipelineStage from "./FeatureIdPipelineStage.js";
 import GeometryPipelineStage from "./GeometryPipelineStage.js";
+import ImageryPipelineStage from "./ImageryPipelineStage.js";
 import LightingPipelineStage from "./LightingPipelineStage.js";
 import MaterialPipelineStage from "./MaterialPipelineStage.js";
 import MetadataPickingPipelineStage from "./MetadataPickingPipelineStage.js";
@@ -27,6 +28,7 @@ import SelectedFeatureIdPipelineStage from "./SelectedFeatureIdPipelineStage.js"
 import SkinningPipelineStage from "./SkinningPipelineStage.js";
 import VerticalExaggerationPipelineStage from "./VerticalExaggerationPipelineStage.js";
 import WireframePipelineStage from "./WireframePipelineStage.js";
+import oneTimeWarning from "../../Core/oneTimeWarning.js";
 
 /**
  * In memory representation of a single primitive, that is, a primitive
@@ -206,6 +208,12 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
   const hasMorphTargets =
     defined(primitive.morphTargets) && primitive.morphTargets.length > 0;
   const hasSkinning = defined(node.skin);
+
+  // Check whether the model is part of a `Model3DTileContent` that
+  // belongs to a tileset that has imagery layers. If this is the
+  // case, then the `ImageryPipelineStage` will be required.
+  const hasImageryLayers = defined(model.imageryLayers);
+
   const hasCustomShader = defined(customShader);
   const hasCustomFragmentShader =
     hasCustomShader && defined(customShader.fragmentShaderText);
@@ -215,6 +223,7 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
   const hasQuantization = ModelUtility.hasQuantizedAttributes(
     primitive.attributes,
   );
+
   const generateWireframeIndices =
     model.debugWireframe &&
     PrimitiveType.isTriangles(primitive.primitiveType) &&
@@ -270,6 +279,17 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
     pipelineStages.push(DequantizationPipelineStage);
   }
 
+  if (hasImageryLayers) {
+    if (hasOutlines) {
+      oneTimeWarning(
+        "outlines-and-draping",
+        "Primitive outlines disable imagery draping",
+      );
+    } else {
+      pipelineStages.push(ImageryPipelineStage);
+    }
+  }
+
   if (materialsEnabled) {
     pipelineStages.push(MaterialPipelineStage);
   }

package/Source/Scene/Model/ModelSceneGraph.js

@@ -445,6 +445,7 @@ const scratchModelPositionMin = new Cartesian3();
 const scratchModelPositionMax = new Cartesian3();
 const scratchPrimitivePositionMin = new Cartesian3();
 const scratchPrimitivePositionMax = new Cartesian3();
+
 /**
  * Generates the {@link ModelDrawCommand} for each primitive in the model.
  * If the model is used for classification, a {@link ClassificationModelDrawCommand}
@@ -456,6 +457,30 @@ const scratchPrimitivePositionMax = new Cartesian3();
  * @private
  */
 ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
+  const modelRenderResources = this.buildRenderResources(frameState);
+  this.computeBoundingVolumes(modelRenderResources);
+  this.createDrawCommands(modelRenderResources, frameState);
+};
+
+/**
+ * Generates the {@link ModelRenderResources} for the model.
+ *
+ * This will traverse the model, nodes and primitives of the scene graph,
+ * and perform the following tasks:
+ *
+ * - configure the pipeline stages by calling `configurePipeline`,
+ *   `runtimeNode.configurePipeline`, and `runtimePrimitive.configurePipeline`
+ * - create the `ModelRenderResources`, `NodeRenderResources`, and
+ *   `PrimitiveRenderResources`
+ * - Process the render resources with the respective pipelines
+ *
+ * @param {FrameState} frameState The current frame state. This is needed to
+ * allocate GPU resources as needed.
+ * @returns {ModelRenderResources} The model render resources
+ *
+ * @private
+ */
+ModelSceneGraph.prototype.buildRenderResources = function (frameState) {
   const model = this._model;
   const modelRenderResources = new ModelRenderResources(model);
 
@@ -465,26 +490,12 @@ ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
   this.configurePipeline(frameState);
   const modelPipelineStages = this.modelPipelineStages;
 
-  let i, j, k;
-  for (i = 0; i < modelPipelineStages.length; i++) {
+  for (let i = 0; i < modelPipelineStages.length; i++) {
     const modelPipelineStage = modelPipelineStages[i];
     modelPipelineStage.process(modelRenderResources, model, frameState);
   }
 
-  const modelPositionMin = Cartesian3.fromElements(
-    Number.MAX_VALUE,
-    Number.MAX_VALUE,
-    Number.MAX_VALUE,
-    scratchModelPositionMin,
-  );
-  const modelPositionMax = Cartesian3.fromElements(
-    -Number.MAX_VALUE,
-    -Number.MAX_VALUE,
-    -Number.MAX_VALUE,
-    scratchModelPositionMax,
-  );
-
-  for (i = 0; i < this._runtimeNodes.length; i++) {
+  for (let i = 0; i < this._runtimeNodes.length; i++) {
     const runtimeNode = this._runtimeNodes[i];
 
     // If a node in the model was unreachable from the scene graph, there will
@@ -500,8 +511,9 @@ ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
       modelRenderResources,
       runtimeNode,
     );
+    modelRenderResources.nodeRenderResources[i] = nodeRenderResources;
 
-    for (j = 0; j < nodePipelineStages.length; j++) {
+    for (let j = 0; j < nodePipelineStages.length; j++) {
       const nodePipelineStage = nodePipelineStages[j];
 
       nodePipelineStage.process(
@@ -511,8 +523,7 @@ ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
       );
     }
 
-    const nodeTransform = runtimeNode.computedTransform;
-    for (j = 0; j < runtimeNode.runtimePrimitives.length; j++) {
+    for (let j = 0; j < runtimeNode.runtimePrimitives.length; j++) {
       const runtimePrimitive = runtimeNode.runtimePrimitives[j];
 
       runtimePrimitive.configurePipeline(frameState);
@@ -522,16 +533,76 @@ ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
         nodeRenderResources,
         runtimePrimitive,
       );
+      nodeRenderResources.primitiveRenderResources[j] =
+        primitiveRenderResources;
 
-      for (k = 0; k < primitivePipelineStages.length; k++) {
+      for (let k = 0; k < primitivePipelineStages.length; k++) {
         const primitivePipelineStage = primitivePipelineStages[k];
-
         primitivePipelineStage.process(
           primitiveRenderResources,
           runtimePrimitive.primitive,
           frameState,
         );
       }
+    }
+  }
+  return modelRenderResources;
+};
+
+/**
+ * Computes the bounding volumes for the scene graph and the model.
+ *
+ * This will traverse the model, nodes and primitives of the scene graph,
+ * and compute the bounding volumes. Specifically, it will compute
+ *
+ * - this._boundingSphere
+ * - model._boundingSphere
+ *
+ * With the latter being modified as of
+ *
+ * - model._initialRadius = model._boundingSphere.radius;
+ * - model._boundingSphere.radius *= model._clampedScale;
+ *
+ * NOTE: This contains some bugs. See https://github.com/CesiumGS/cesium/issues/12108
+ *
+ * @param {ModelRenderResources} modelRenderResources The model render resources
+ *
+ * @private
+ */
+ModelSceneGraph.prototype.computeBoundingVolumes = function (
+  modelRenderResources,
+) {
+  const model = this._model;
+
+  const modelPositionMin = Cartesian3.fromElements(
+    Number.MAX_VALUE,
+    Number.MAX_VALUE,
+    Number.MAX_VALUE,
+    scratchModelPositionMin,
+  );
+  const modelPositionMax = Cartesian3.fromElements(
+    -Number.MAX_VALUE,
+    -Number.MAX_VALUE,
+    -Number.MAX_VALUE,
+    scratchModelPositionMax,
+  );
+
+  for (let i = 0; i < this._runtimeNodes.length; i++) {
+    const runtimeNode = this._runtimeNodes[i];
+
+    // If a node in the model was unreachable from the scene graph, there will
+    // be no corresponding runtime node and therefore should be skipped.
+    if (!defined(runtimeNode)) {
+      continue;
+    }
+
+    const nodeRenderResources = modelRenderResources.nodeRenderResources[i];
+    const nodeTransform = runtimeNode.computedTransform;
+    for (let j = 0; j < runtimeNode.runtimePrimitives.length; j++) {
+      const runtimePrimitive = runtimeNode.runtimePrimitives[j];
+
+      const primitiveRenderResources =
+        nodeRenderResources.primitiveRenderResources[j];
 
       runtimePrimitive.boundingSphere = BoundingSphere.clone(
         primitiveRenderResources.boundingSphere,
@@ -559,12 +630,6 @@ ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
         primitivePositionMax,
         modelPositionMax,
       );
-
-      const drawCommand = ModelDrawCommands.buildModelDrawCommand(
-        primitiveRenderResources,
-        frameState,
-      );
-      runtimePrimitive.drawCommand = drawCommand;
     }
   }
 
@@ -596,6 +661,47 @@ ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
   model._boundingSphere.radius *= model._clampedScale;
 };
 
+/**
+ * Creates the draw commands for the primitives in the scene graph.
+ *
+ * This will traverse the model, nodes and primitives of the scene graph,
+ * and create the respective draw commands for the primitives, storing
+ * them as the `runtimePrimitive.drawCommand`, respectively.
+ *
+ * @param {ModelRenderResources} modelRenderResources The model render resources
+ *
+ * @private
+ */
+ModelSceneGraph.prototype.createDrawCommands = function (
+  modelRenderResources,
+  frameState,
+) {
+  for (let i = 0; i < this._runtimeNodes.length; i++) {
+    const runtimeNode = this._runtimeNodes[i];
+
+    // If a node in the model was unreachable from the scene graph, there will
+    // be no corresponding runtime node and therefore should be skipped.
+    if (!defined(runtimeNode)) {
+      continue;
+    }
+
+    const nodeRenderResources = modelRenderResources.nodeRenderResources[i];
+
+    for (let j = 0; j < runtimeNode.runtimePrimitives.length; j++) {
+      const runtimePrimitive = runtimeNode.runtimePrimitives[j];
+
+      const primitiveRenderResources =
+        nodeRenderResources.primitiveRenderResources[j];
+
+      const drawCommand = ModelDrawCommands.buildModelDrawCommand(
+        primitiveRenderResources,
+        frameState,
+      );
+      runtimePrimitive.drawCommand = drawCommand;
+    }
+  }
+};
+
 /**
  * Configure the model pipeline stages. If the pipeline needs to be re-run, call
  * this method again to ensure the correct sequence of pipeline stages are

package/Source/Scene/Model/ModelUtility.js

@@ -368,6 +368,8 @@ ModelUtility.supportedExtensions = {
   KHR_techniques_webgl: true,
   KHR_texture_basisu: true,
   KHR_texture_transform: true,
+  KHR_gaussian_splatting: true,
+  KHR_spz_gaussian_splats_compression: true,
   WEB3D_quantized_attributes: true,
 };
 

package/Source/Scene/Model/NodeRenderResources.js

@@ -155,6 +155,16 @@ function NodeRenderResources(modelRenderResources, runtimeNode) {
    * @private
    */
   this.instanceCount = 0;
+
+  /**
+   * The PrimitiveRenderResources for the primitives of the node.
+   *
+   * @type {PrimitiveRenderResources[]}
+   * @default []
+   *
+   * @private
+   */
+  this.primitiveRenderResources = [];
 }
 
 export default NodeRenderResources;

package/Source/Scene/ModelComponents.js

@@ -620,6 +620,16 @@ function Primitive() {
    * @private
    */
   this.outlineCoordinates = undefined;
+
+  /**
+   * If the model is part of a Model3DTileContent of a Cesium3DTileset that
+   * has 'imageryLayers', then this will represent the information that is
+   * required for draping the imagery over this primitive.
+   *
+   * @type {ModelPrimitiveImagery|undefined}
+   * @private
+   */
+  this.modelPrimitiveImagery = undefined;
 }
 
 /**

package/Source/Scene/PrimitiveLoadPlan.js

@@ -7,6 +7,8 @@ import BufferUsage from "../Renderer/BufferUsage.js";
 import AttributeType from "./AttributeType.js";
 import ModelComponents from "./ModelComponents.js";
 import PrimitiveOutlineGenerator from "./Model/PrimitiveOutlineGenerator.js";
+import VertexAttributeSemantic from "./VertexAttributeSemantic.js";
+import ModelUtility from "./Model/ModelUtility.js";
 
 /**
  * Simple struct for tracking whether an attribute will be loaded as a buffer
@@ -157,6 +159,15 @@ function PrimitiveLoadPlan(primitive) {
    * @private
    */
   this.outlineIndices = undefined;
+
+  /**
+   * Set this true to indicate that the primitive has the
+   * KHR_gaussian_splatting extension and needs to be post-processed
+   *
+   * @type {boolean}
+   * @private
+   */
+  this.needsGaussianSplats = false;
 }
 
 /**
@@ -174,6 +185,11 @@ PrimitiveLoadPlan.prototype.postProcess = function (context) {
     generateOutlines(this);
     generateBuffers(this, context);
   }
+
+  if (this.needsGaussianSplats) {
+    prepareSpzData(this, context);
+    setupGaussianSplatBuffers(this, context);
+  }
 };
 
 function generateOutlines(loadPlan) {
@@ -226,6 +242,49 @@ function makeOutlineCoordinatesAttribute(outlineCoordinatesTypedArray) {
   return attribute;
 }
 
+function prepareSpzData(loadPlan, context) {
+  const position = ModelUtility.getAttributeBySemantic(
+    loadPlan.primitive,
+    VertexAttributeSemantic.POSITION,
+  );
+
+  for (let i = 0; i < position.typedArray.length; i += 3) {
+    position.typedArray[i + 1] = -position.typedArray[i + 1];
+    position.typedArray[i + 2] = -position.typedArray[i + 2];
+  }
+
+  const rotations = ModelUtility.getAttributeBySemantic(
+    loadPlan.primitive,
+    VertexAttributeSemantic.ROTATION,
+  );
+
+  //180* rotation around X.
+  //Temporary until we can get SPZ supporting Z-up assets natively
+  const rots = rotations.typedArray;
+  for (let q = 0; q < rots.length; q += 4) {
+    const w = rots[q];
+    const x = -rots[q + 3];
+    const y = rots[q + 2];
+    const z = -rots[q + 1];
+
+    rots[q] = y;
+    rots[q + 1] = -x;
+    rots[q + 2] = w;
+    rots[q + 3] = -z;
+  }
+  rotations.typedArray = rots;
+}
+
+function setupGaussianSplatBuffers(loadPlan, context) {
+  const attributePlans = loadPlan.attributePlans;
+  const attrLen = attributePlans.length;
+  for (let i = 0; i < attrLen; i++) {
+    const attributePlan = attributePlans[i];
+    attributePlan.loadBuffer = false;
+    attributePlan.loadTypedArray = true;
+  }
+}
+
 function generateBuffers(loadPlan, context) {
   generateAttributeBuffers(loadPlan.attributePlans, context);
 

package/Source/Scene/ResourceCache.js

@@ -10,6 +10,7 @@ import GltfIndexBufferLoader from "./GltfIndexBufferLoader.js";
 import GltfJsonLoader from "./GltfJsonLoader.js";
 import GltfTextureLoader from "./GltfTextureLoader.js";
 import GltfVertexBufferLoader from "./GltfVertexBufferLoader.js";
+import GltfSpzLoader from "./GltfSpzLoader.js";
 import MetadataSchemaLoader from "./MetadataSchemaLoader.js";
 import ResourceCacheKey from "./ResourceCacheKey.js";
 import ResourceCacheStatistics from "./ResourceCacheStatistics.js";
@@ -390,6 +391,57 @@ ResourceCache.getDracoLoader = function (options) {
   return ResourceCache.add(dracoLoader);
 };
 
+/**
+ * Gets an existing SPZ loader from the cache, or creates a new loader if one does not already exist.
+ * This loader is used to decode SPZ (Splat Point Cloud) data in glTF.
+ * 
+ * @param {object} options Object with the following properties:
+ * @param {object} options.gltf The glTF JSON.
+ * @param {object} options.primitive The primitive containing the SPZ extension.
+ * @param {object} options.spz The SPZ extension object.
+ * @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
+ * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
+ *
+ * @return {GltfSpzLoader} The cached SPZ loader.
+ @private
+ * */
+ResourceCache.getSpzLoader = function (options) {
+  options = options ?? Frozen.EMPTY_OBJECT;
+  const { gltf, primitive, spz, gltfResource, baseResource } = options;
+
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("options.gltf", gltf);
+  Check.typeOf.object("options.primitive", primitive);
+  Check.typeOf.object("options.spz", spz);
+  Check.typeOf.object("options.gltfResource", gltfResource);
+  Check.typeOf.object("options.baseResource", baseResource);
+  //>>includeEnd('debug');
+
+  const cacheKey = ResourceCacheKey.getSpzCacheKey({
+    gltf: gltf,
+    primitive: primitive,
+    gltfResource: gltfResource,
+    baseResource: baseResource,
+  });
+
+  let spzLoader = ResourceCache.get(cacheKey);
+  if (defined(spzLoader)) {
+    return spzLoader;
+  }
+
+  spzLoader = new GltfSpzLoader({
+    resourceCache: ResourceCache,
+    gltf: gltf,
+    primitive: primitive,
+    spz: spz,
+    gltfResource: gltfResource,
+    baseResource: baseResource,
+    cacheKey: cacheKey,
+  });
+
+  return ResourceCache.add(spzLoader);
+};
+
 /**
  * Gets an existing glTF vertex buffer from the cache, or creates a new loader if one does not already exist.
  *
@@ -424,6 +476,7 @@ ResourceCache.getVertexBufferLoader = function (options) {
     bufferViewId,
     primitive,
     draco,
+    spz,
     attributeSemantic,
     accessorId,
     asynchronous = true,
@@ -448,10 +501,11 @@ ResourceCache.getVertexBufferLoader = function (options) {
   const hasDraco = hasDracoCompression(draco, attributeSemantic);
   const hasAttributeSemantic = defined(attributeSemantic);
   const hasAccessorId = defined(accessorId);
+  const hasSpz = defined(spz);
 
-  if (hasBufferViewId === hasDraco) {
+  if (hasBufferViewId === (hasDraco !== hasSpz)) {
     throw new DeveloperError(
-      "One of options.bufferViewId and options.draco must be defined.",
+      "One of options.bufferViewId, options.draco, or options.spz must be defined.",
     );
   }
 
@@ -463,7 +517,7 @@ ResourceCache.getVertexBufferLoader = function (options) {
 
   if (hasDraco && !hasAccessorId) {
     throw new DeveloperError(
-      "When options.draco is defined options.haAccessorId must also be defined.",
+      "When options.draco is defined options.hasAccessorId must also be defined.",
     );
   }
 
@@ -478,6 +532,7 @@ ResourceCache.getVertexBufferLoader = function (options) {
     Check.typeOf.string("options.attributeSemantic", attributeSemantic);
     Check.typeOf.number("options.accessorId", accessorId);
   }
+
   //>>includeEnd('debug');
 
   const cacheKey = ResourceCacheKey.getVertexBufferCacheKey({
@@ -487,6 +542,7 @@ ResourceCache.getVertexBufferLoader = function (options) {
     frameState: frameState,
     bufferViewId: bufferViewId,
     draco: draco,
+    spz: spz,
     attributeSemantic: attributeSemantic,
     dequantize: dequantize,
     loadBuffer: loadBuffer,
@@ -506,6 +562,7 @@ ResourceCache.getVertexBufferLoader = function (options) {
     bufferViewId: bufferViewId,
     primitive: primitive,
     draco: draco,
+    spz: spz,
     attributeSemantic: attributeSemantic,
     accessorId: accessorId,
     cacheKey: cacheKey,

package/Source/Scene/ResourceCacheKey.js

@@ -71,6 +71,24 @@ function getDracoCacheKey(gltf, draco, gltfResource, baseResource) {
   return `${bufferCacheKey}-range-${bufferViewCacheKey}`;
 }
 
+function getSpzCacheKey(gltf, primitive, gltfResource, baseResource) {
+  const bufferViewId = 0;
+  const bufferView = gltf.bufferViews[bufferViewId];
+  const bufferId = bufferView.buffer;
+  const buffer = gltf.buffers[bufferId];
+
+  const bufferCacheKey = getBufferCacheKey(
+    buffer,
+    bufferId,
+    gltfResource,
+    baseResource,
+  );
+
+  const bufferViewCacheKey = getBufferViewCacheKey(bufferView);
+
+  return `${bufferCacheKey}-range-${bufferViewCacheKey}`;
+}
+
 function getImageCacheKey(gltf, imageId, gltfResource, baseResource) {
   const image = gltf.images[imageId];
   const bufferViewId = image.bufferView;
@@ -272,6 +290,19 @@ ResourceCacheKey.getDracoCacheKey = function (options) {
   return `draco:${getDracoCacheKey(gltf, draco, gltfResource, baseResource)}`;
 };
 
+ResourceCacheKey.getSpzCacheKey = function (options) {
+  options = options ?? Frozen.EMPTY_OBJECT;
+  const { gltf, primitive, gltfResource, baseResource } = options;
+
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("options.gltf", gltf);
+  Check.typeOf.object("options.primitive", primitive);
+  Check.typeOf.object("options.gltfResource", gltfResource);
+  Check.typeOf.object("options.baseResource", baseResource);
+  //>>includeEnd('debug');
+
+  return `spz:${getSpzCacheKey(gltf, primitive, gltfResource, baseResource)}`;
+};
 /**
  * Gets the vertex buffer cache key.
  *
@@ -301,6 +332,7 @@ ResourceCacheKey.getVertexBufferCacheKey = function (options) {
     frameState,
     bufferViewId,
     draco,
+    spz,
     attributeSemantic,
     dequantize = false,
     loadBuffer = false,
@@ -316,8 +348,9 @@ ResourceCacheKey.getVertexBufferCacheKey = function (options) {
   const hasBufferViewId = defined(bufferViewId);
   const hasDraco = hasDracoCompression(draco, attributeSemantic);
   const hasAttributeSemantic = defined(attributeSemantic);
+  const hasSpz = defined(spz);
 
-  if (hasBufferViewId === hasDraco) {
+  if (hasBufferViewId === (hasDraco !== hasSpz)) {
     throw new DeveloperError(
       "One of options.bufferViewId and options.draco must be defined.",
     );
@@ -365,6 +398,11 @@ ResourceCacheKey.getVertexBufferCacheKey = function (options) {
     return `vertex-buffer:${dracoCacheKey}-draco-${attributeSemantic}${cacheKeySuffix}`;
   }
 
+  if (spz) {
+    const spzCacheKey = getSpzCacheKey(gltf, spz, gltfResource, baseResource);
+    return `vertex-buffer:${spzCacheKey}-spz-${attributeSemantic}${cacheKeySuffix}`;
+  }
+
   const bufferView = gltf.bufferViews[bufferViewId];
   const bufferId = bufferView.buffer;
   const buffer = gltf.buffers[bufferId];

package/Source/Scene/Scene.js

@@ -2318,6 +2318,23 @@ function backToFront(a, b, position) {
   );
 }
 
+const scratchCart3 = new Cartesian3();
+function distanceSquaredToCenter(center, position) {
+  const diff = Cartesian3.subtract(center, position, scratchCart3);
+  const distance = Math.max(0.0, Cartesian3.magnitude(diff));
+  return distance * distance;
+}
+
+function backToFrontSplats(a, b, position) {
+  const boxA = a.boundingVolume;
+  const boxB = b.boundingVolume;
+
+  return (
+    distanceSquaredToCenter(boxB.center, position) -
+    distanceSquaredToCenter(boxA.center, position)
+  );
+}
+
 function frontToBack(a, b, position) {
   // When distances are equal equal favor sorting b before a. This gives render priority to commands later in the list.
   return (
@@ -2362,7 +2379,6 @@ function executeTranslucentCommandsFrontToBack(
     executeFunction(commands[i], scene, passState);
   }
 }
-
 /**
  * Execute commands to render voxels in the scene.
  *
@@ -2385,6 +2401,19 @@ function performVoxelsPass(scene, passState, frustumCommands) {
   }
 }
 
+function performGaussianSplatPass(scene, passState, frustumCommands) {
+  scene.context.uniformState.updatePass(Pass.GAUSSIAN_SPLATS);
+
+  const commands = frustumCommands.commands[Pass.GAUSSIAN_SPLATS];
+  commands.length = frustumCommands.indices[Pass.GAUSSIAN_SPLATS];
+
+  mergeSort(commands, backToFrontSplats, scene.camera.positionWC);
+
+  for (let i = 0; i < commands.length; ++i) {
+    executeCommand(commands[i], scene, passState);
+  }
+}
+
 const scratchPerspectiveFrustum = new PerspectiveFrustum();
 const scratchPerspectiveOffCenterFrustum = new PerspectiveOffCenterFrustum();
 const scratchOrthographicFrustum = new OrthographicFrustum();
@@ -2782,6 +2811,8 @@ function executeCommands(scene, passState) {
 
     performPass(frustumCommands, Pass.OPAQUE);
 
+    performGaussianSplatPass(scene, passState, frustumCommands);
+
     if (index !== 0 && scene.mode !== SceneMode.SCENE2D) {
       // Do not overlap frustums in the translucent pass to avoid blending artifacts
       frustum.near = frustumCommands.near;