@cesium/engine 18.0.0 → 18.2.0

package/Source/Scene/GltfVertexBufferLoader.js

@@ -9,6 +9,7 @@ import JobType from "./JobType.js";
 import ModelComponents from "./ModelComponents.js";
 import ResourceLoader from "./ResourceLoader.js";
 import ResourceLoaderState from "./ResourceLoaderState.js";
+import CesiumMath from "../Core/Math.js";
 
 /**
  * Loads a vertex buffer from a glTF buffer view.
@@ -53,6 +54,7 @@ function GltfVertexBufferLoader(options) {
   const attributeSemantic = options.attributeSemantic;
   const accessorId = options.accessorId;
   const cacheKey = options.cacheKey;
+  const spz = options.spz;
   const asynchronous = options.asynchronous ?? true;
   const loadBuffer = options.loadBuffer ?? false;
   const loadTypedArray = options.loadTypedArray ?? false;
@@ -73,10 +75,10 @@ function GltfVertexBufferLoader(options) {
   const hasDraco = hasDracoCompression(draco, attributeSemantic);
   const hasAttributeSemantic = defined(attributeSemantic);
   const hasAccessorId = defined(accessorId);
-
-  if (hasBufferViewId === hasDraco) {
+  const hasSpz = defined(spz);
+  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.",
     );
   }
 
@@ -104,6 +106,7 @@ function GltfVertexBufferLoader(options) {
     Check.typeOf.string("options.attributeSemantic", attributeSemantic);
     Check.typeOf.number("options.accessorId", accessorId);
   }
+
   //>>includeEnd('debug');
 
   this._resourceCache = resourceCache;
@@ -113,6 +116,7 @@ function GltfVertexBufferLoader(options) {
   this._bufferViewId = bufferViewId;
   this._primitive = primitive;
   this._draco = draco;
+  this._spz = spz;
   this._attributeSemantic = attributeSemantic;
   this._accessorId = accessorId;
   this._cacheKey = cacheKey;
@@ -210,6 +214,11 @@ GltfVertexBufferLoader.prototype.load = async function () {
     return this._promise;
   }
 
+  if (defined(this._spz)) {
+    this._promise = loadFromSpz(this);
+    return this._promise;
+  }
+
   if (hasDracoCompression(this._draco, this._attributeSemantic)) {
     this._promise = loadFromDraco(this);
     return this._promise;
@@ -270,6 +279,74 @@ function getQuantizationInformation(
   return quantization;
 }
 
+async function loadFromSpz(vertexBufferLoader) {
+  vertexBufferLoader._state = ResourceLoaderState.LOADING;
+  const resourceCache = vertexBufferLoader._resourceCache;
+  try {
+    const spzLoader = resourceCache.getSpzLoader({
+      gltf: vertexBufferLoader._gltf,
+      primitive: vertexBufferLoader._primitive,
+      spz: vertexBufferLoader._spz,
+      gltfResource: vertexBufferLoader._gltfResource,
+      baseResource: vertexBufferLoader._baseResource,
+    });
+    vertexBufferLoader._spzLoader = spzLoader;
+    await spzLoader.load();
+
+    if (vertexBufferLoader.isDestroyed()) {
+      return;
+    }
+
+    vertexBufferLoader._state = ResourceLoaderState.LOADED;
+    return vertexBufferLoader;
+  } catch {
+    if (vertexBufferLoader.isDestroyed()) {
+      return;
+    }
+  }
+}
+
+function processSpz(vertexBufferLoader) {
+  vertexBufferLoader._state = ResourceLoaderState.PROCESSING;
+  const spzLoader = vertexBufferLoader._spzLoader;
+
+  const gcloudData = spzLoader.decodedData.gcloud;
+
+  if (vertexBufferLoader._attributeSemantic === "POSITION") {
+    vertexBufferLoader._typedArray = gcloudData.positions;
+  } else if (vertexBufferLoader._attributeSemantic === "_SCALE") {
+    vertexBufferLoader._typedArray = gcloudData.scales;
+  } else if (vertexBufferLoader._attributeSemantic === "_ROTATION") {
+    vertexBufferLoader._typedArray = gcloudData.rotations;
+  } else if (vertexBufferLoader._attributeSemantic === "COLOR_0") {
+    const colors = gcloudData.colors;
+    const alphas = gcloudData.alphas;
+    vertexBufferLoader._typedArray = new Uint8Array((colors.length / 3) * 4);
+    for (let i = 0; i < colors.length / 3; i++) {
+      vertexBufferLoader._typedArray[i * 4] = CesiumMath.clamp(
+        colors[i * 3] * 255.0,
+        0.0,
+        255.0,
+      );
+      vertexBufferLoader._typedArray[i * 4 + 1] = CesiumMath.clamp(
+        colors[i * 3 + 1] * 255.0,
+        0.0,
+        255.0,
+      );
+      vertexBufferLoader._typedArray[i * 4 + 2] = CesiumMath.clamp(
+        colors[i * 3 + 2] * 255.0,
+        0.0,
+        255.0,
+      );
+      vertexBufferLoader._typedArray[i * 4 + 3] = CesiumMath.clamp(
+        alphas[i] * 255.0,
+        0.0,
+        255.0,
+      );
+    }
+  }
+}
+
 async function loadFromDraco(vertexBufferLoader) {
   vertexBufferLoader._state = ResourceLoaderState.LOADING;
   const resourceCache = vertexBufferLoader._resourceCache;
@@ -427,6 +504,19 @@ GltfVertexBufferLoader.prototype.process = function (frameState) {
     processDraco(this);
   }
 
+  if (defined(this._spzLoader)) {
+    try {
+      const ready = this._spzLoader.process(frameState);
+      if (!ready) {
+        return false;
+      }
+    } catch (error) {
+      handleError(this, error);
+    }
+
+    processSpz(this);
+  }
+
   let buffer;
   const typedArray = this._typedArray;
   if (this._loadBuffer && this._asynchronous) {
@@ -474,8 +564,13 @@ GltfVertexBufferLoader.prototype.unload = function () {
     resourceCache.unload(this._dracoLoader);
   }
 
+  if (defined(this._spzLoader)) {
+    resourceCache.unload(this._spzLoader);
+  }
+
   this._bufferViewLoader = undefined;
   this._dracoLoader = undefined;
+  this._spzLoader = undefined;
   this._typedArray = undefined;
   this._buffer = undefined;
   this._gltf = undefined;

package/Source/Scene/Model/ModelRuntimePrimitive.js

@@ -223,6 +223,7 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
   const hasQuantization = ModelUtility.hasQuantizedAttributes(
     primitive.attributes,
   );
+
   const generateWireframeIndices =
     model.debugWireframe &&
     PrimitiveType.isTriangles(primitive.primitiveType) &&

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/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;

package/Source/Scene/VertexAttributeSemantic.js

@@ -73,6 +73,20 @@ const VertexAttributeSemantic = {
    * @constant
    */
   FEATURE_ID: "_FEATURE_ID",
+  /**
+   * Gaussian Splat Scale
+   *
+   * @type {string}
+   * @constant
+   */
+  SCALE: "_SCALE",
+  /**
+   * Gaussian Splat Rotation
+   *
+   * @type {string}
+   * @constant
+   */
+  ROTATION: "_ROTATION",
 };
 
 function semanticToVariableName(semantic) {
@@ -93,6 +107,10 @@ function semanticToVariableName(semantic) {
       return "weights";
     case VertexAttributeSemantic.FEATURE_ID:
       return "featureId";
+    case VertexAttributeSemantic.SCALE:
+      return "scale";
+    case VertexAttributeSemantic.ROTATION:
+      return "rotation";
     //>>includeStart('debug', pragmas.debug);
     default:
       throw new DeveloperError("semantic is not a valid value.");
@@ -124,6 +142,8 @@ VertexAttributeSemantic.hasSetIndex = function (semantic) {
     case VertexAttributeSemantic.JOINTS:
     case VertexAttributeSemantic.WEIGHTS:
     case VertexAttributeSemantic.FEATURE_ID:
+    case VertexAttributeSemantic.SCALE:
+    case VertexAttributeSemantic.ROTATION:
       return true;
     //>>includeStart('debug', pragmas.debug);
     default:
@@ -172,6 +192,10 @@ VertexAttributeSemantic.fromGltfSemantic = function (gltfSemantic) {
       return VertexAttributeSemantic.WEIGHTS;
     case "_FEATURE_ID":
       return VertexAttributeSemantic.FEATURE_ID;
+    case "_SCALE":
+      return VertexAttributeSemantic.SCALE;
+    case "_ROTATION":
+      return VertexAttributeSemantic.ROTATION;
   }
 
   return undefined;
@@ -241,6 +265,12 @@ VertexAttributeSemantic.getGlslType = function (semantic) {
       return "vec4";
     case VertexAttributeSemantic.FEATURE_ID:
       return "int";
+    case VertexAttributeSemantic.SCALE:
+      return "vec3";
+    case VertexAttributeSemantic.ROTATION:
+      return "vec4";
+    case VertexAttributeSemantic.OPACITY:
+      return "float";
     //>>includeStart('debug', pragmas.debug);
     default:
       throw new DeveloperError("semantic is not a valid value.");

package/Source/Shaders/Builtin/Constants/passGaussianSplats.glsl

@@ -0,0 +1,9 @@
+/**
+ * The automatic GLSL constant for {@link Pass#GAUSSIAN_SPLATS}
+ *
+ * @name czm_passGaussianSplats
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passGaussianSplats = 10.0;

package/Source/Shaders/Builtin/Constants/passGaussianSplats.js

@@ -0,0 +1,11 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * The automatic GLSL constant for {@link Pass#GAUSSIAN_SPLATS}\n\
+ *\n\
+ * @name czm_passGaussianSplats\n\
+ * @glslConstant\n\
+ *\n\
+ * @see czm_pass\n\
+ */\n\
+const float czm_passGaussianSplats = 10.0;\n\
+";

package/Source/Shaders/Builtin/Constants/passOverlay.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passOverlay = 10.0;
+const float czm_passOverlay = 11.0;

package/Source/Shaders/Builtin/Constants/passOverlay.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passOverlay = 10.0;\n\
+const float czm_passOverlay = 11.0;\n\
 ";

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -17,6 +17,7 @@ import czm_passCesium3DTileClassificationIgnoreShow from './Constants/passCesium
 import czm_passClassification from './Constants/passClassification.js'
 import czm_passCompute from './Constants/passCompute.js'
 import czm_passEnvironment from './Constants/passEnvironment.js'
+import czm_passGaussianSplats from './Constants/passGaussianSplats.js'
 import czm_passGlobe from './Constants/passGlobe.js'
 import czm_passOpaque from './Constants/passOpaque.js'
 import czm_passOverlay from './Constants/passOverlay.js'
@@ -155,6 +156,7 @@ export default {
     czm_passClassification : czm_passClassification,
     czm_passCompute : czm_passCompute,
     czm_passEnvironment : czm_passEnvironment,
+    czm_passGaussianSplats : czm_passGaussianSplats,
     czm_passGlobe : czm_passGlobe,
     czm_passOpaque : czm_passOpaque,
     czm_passOverlay : czm_passOverlay,

package/Source/Shaders/Model/ModelFS.glsl

@@ -1,5 +1,6 @@
 
 precision highp float;
+
 czm_modelMaterial defaultModelMaterial()
 {
     czm_modelMaterial material;
@@ -86,7 +87,7 @@ void main()
 
     // When not picking metadata END
     //========================================================================
-    #else 
+    #else
     //========================================================================
     // When picking metadata START
 
@@ -124,3 +125,4 @@ void main()
 
     out_FragColor = color;
 }
+

package/Source/Shaders/Model/ModelFS.js

@@ -1,6 +1,7 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "\n\
 precision highp float;\n\
+\n\
 czm_modelMaterial defaultModelMaterial()\n\
 {\n\
     czm_modelMaterial material;\n\
@@ -87,7 +88,7 @@ void main()\n\
 \n\
     // When not picking metadata END\n\
     //========================================================================\n\
-    #else \n\
+    #else\n\
     //========================================================================\n\
     // When picking metadata START\n\
 \n\
@@ -125,4 +126,5 @@ void main()\n\
 \n\
     out_FragColor = color;\n\
 }\n\
+\n\
 ";