@hztxi/cesium-engine 25.0.7 → 26.2.1

package/Source/Scene/findMeshoptExtension.js

@@ -0,0 +1,23 @@
+import defined from "../Core/defined.js";
+
+/**
+ * Returns the meshopt compression extension object, KHR_meshopt_compression or
+ * EXT_meshopt_compression, on a glTF bufferView or buffer. If both are present,
+ * KHR is preferred.
+ * @param {object} gltfObject A glTF bufferView or buffer.
+ * @returns {object|undefined} The meshopt extension object, or undefined.
+ * @private
+ */
+function findMeshoptExtension(gltfObject) {
+  const extensions = gltfObject?.extensions;
+  if (!defined(extensions)) {
+    return undefined;
+  }
+
+  return (
+    extensions["KHR_meshopt_compression"] ??
+    extensions["EXT_meshopt_compression"]
+  );
+}
+
+export default findMeshoptExtension;

package/Source/Scene/renderBufferPointCollection.js

@@ -20,6 +20,7 @@ import BufferPointMaterialFS from "../Shaders/BufferPointMaterialFS.js";
 import EncodedCartesian3 from "../Core/EncodedCartesian3.js";
 import AttributeCompression from "../Core/AttributeCompression.js";
 import BufferPointMaterial from "./BufferPointMaterial.js";
+import BlendOption from "./BlendOption.js";
 
 /** @import FrameState from "./FrameState.js"; */
 /** @import BufferPointCollection from "./BufferPointCollection.js"; */
@@ -27,26 +28,39 @@ import BufferPointMaterial from "./BufferPointMaterial.js";
 
 /**
  * TODO(PR#13211): Need 'keyof' syntax to avoid duplicating attribute names.
- * @typedef {'positionHigh' | 'positionLow' | 'pickColor' | 'showSizeAndColor' | 'outlineWidthAndOutlineColor'} BufferPointAttribute
+ * @typedef {'positionHigh' | 'positionLow' | 'pickColor' | 'showSizeColorAlpha' | 'outlineWidthColorAlpha'} BufferPointAttribute
  * @ignore
  */
 
 /**
+ * Attribute locations when using 64-bit position precision.
  * @type {Record<BufferPointAttribute, number>}
  * @ignore
  */
-const BufferPointAttributeLocations = {
+const BufferPointAttributeLocationsFloat64 = {
   positionHigh: 0,
   positionLow: 1,
   pickColor: 2,
-  showSizeAndColor: 3,
-  outlineWidthAndOutlineColor: 4,
+  showSizeColorAlpha: 3,
+  outlineWidthColorAlpha: 4,
+};
+
+/**
+ * Attribute locations when using <= 32-bit position precision.
+ * @type {Record<string, number>}
+ * @ignore
+ */
+const BufferPointAttributeLocations = {
+  position: 0,
+  pickColor: 1,
+  showSizeColorAlpha: 2,
+  outlineWidthColorAlpha: 3,
 };
 
 /**
  * @typedef {object} BufferPointRenderContext
  * @property {VertexArray} [vertexArray]
- * @property {Record<BufferPointAttribute, TypedArray>} [attributeArrays]
+ * @property {Record<string, TypedArray>} [attributeArrays]
  * @property {RenderState} [renderState]
  * @property {ShaderProgram} [shaderProgram]
  * @property {DrawCommand} [command]
@@ -71,16 +85,24 @@ const encodedCartesian = new EncodedCartesian3();
 function renderBufferPointCollection(collection, frameState, renderContext) {
   const context = frameState.context;
   renderContext = renderContext || { destroy: destroyRenderContext };
+  const useFloat64 = collection._positionDatatype === ComponentDatatype.DOUBLE;
+  const attributeLocations = useFloat64
+    ? BufferPointAttributeLocationsFloat64
+    : BufferPointAttributeLocations;
 
   if (!defined(renderContext.attributeArrays)) {
     const featureCountMax = collection.primitiveCountMax;
 
     renderContext.attributeArrays = {
-      positionHigh: new Float32Array(featureCountMax * 3),
-      positionLow: new Float32Array(featureCountMax * 3),
+      ...(useFloat64
+        ? {
+            positionHigh: new Float32Array(featureCountMax * 3),
+            positionLow: new Float32Array(featureCountMax * 3),
+          }
+        : { position: collection._positionView }),
       pickColor: new Uint8Array(featureCountMax * 4),
-      showSizeAndColor: new Float32Array(featureCountMax * 3),
-      outlineWidthAndOutlineColor: new Float32Array(featureCountMax * 2),
+      showSizeColorAlpha: new Float32Array(featureCountMax * 4),
+      outlineWidthColorAlpha: new Float32Array(featureCountMax * 3),
     };
   }
 
@@ -90,9 +112,8 @@ function renderBufferPointCollection(collection, frameState, renderContext) {
     const positionHighArray = attributeArrays.positionHigh;
     const positionLowArray = attributeArrays.positionLow;
     const pickColorArray = attributeArrays.pickColor;
-    const showSizeAndColorArray = attributeArrays.showSizeAndColor;
-    const outlineWidthAndOutlineColorArray =
-      attributeArrays.outlineWidthAndOutlineColor;
+    const showSizeColorAlphaArray = attributeArrays.showSizeColorAlpha;
+    const outlineWidthColorAlphaArray = attributeArrays.outlineWidthColorAlpha;
 
     const { _dirtyOffset, _dirtyCount } = collection;
 
@@ -103,33 +124,40 @@ function renderBufferPointCollection(collection, frameState, renderContext) {
         continue;
       }
 
-      point.getPosition(cartesian);
-      EncodedCartesian3.fromCartesian(cartesian, encodedCartesian);
+      if (useFloat64) {
+        point.getPosition(cartesian);
+        EncodedCartesian3.fromCartesian(cartesian, encodedCartesian);
+        // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+        Cartesian3.pack(encodedCartesian.high, positionHighArray, i * 3);
+        // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+        Cartesian3.pack(encodedCartesian.low, positionLowArray, i * 3);
+      }
+
       point.getMaterial(material);
       Color.fromRgba(point._pickId, pickColor);
 
-      positionHighArray[i * 3] = encodedCartesian.high.x;
-      positionHighArray[i * 3 + 1] = encodedCartesian.high.y;
-      positionHighArray[i * 3 + 2] = encodedCartesian.high.z;
-
-      positionLowArray[i * 3] = encodedCartesian.low.x;
-      positionLowArray[i * 3 + 1] = encodedCartesian.low.y;
-      positionLowArray[i * 3 + 2] = encodedCartesian.low.z;
-
       pickColorArray[i * 4] = Color.floatToByte(pickColor.red);
       pickColorArray[i * 4 + 1] = Color.floatToByte(pickColor.green);
       pickColorArray[i * 4 + 2] = Color.floatToByte(pickColor.blue);
       pickColorArray[i * 4 + 3] = Color.floatToByte(pickColor.alpha);
 
-      showSizeAndColorArray[i * 3] = point.show ? 1 : 0;
-      showSizeAndColorArray[i * 3 + 1] = material.size;
-      showSizeAndColorArray[i * 3 + 2] = AttributeCompression.encodeRGB8(
+      showSizeColorAlphaArray[i * 4] = point.show ? 1 : 0;
+      showSizeColorAlphaArray[i * 4 + 1] = material.size;
+      showSizeColorAlphaArray[i * 4 + 2] = AttributeCompression.encodeRGB8(
         material.color,
       );
+      showSizeColorAlphaArray[i * 4 + 3] = material.color.alpha;
 
-      outlineWidthAndOutlineColorArray[i * 2] = material.outlineWidth;
-      outlineWidthAndOutlineColorArray[i * 2 + 1] =
-        AttributeCompression.encodeRGB8(material.outlineColor);
+      outlineWidthColorAlphaArray[i * 3] = material.outlineWidth;
+      outlineWidthColorAlphaArray[i * 3 + 1] = AttributeCompression.encodeRGB8(
+        // When outlineWidth=0, overwrite outlineColor to prevent subpixel bleeding.
+        material.outlineWidth > 0 ? material.outlineColor : material.color,
+      );
+      outlineWidthColorAlphaArray[i * 3 + 2] =
+        // When outlineWidth=0, overwrite outlineAlpha to prevent subpixel bleeding.
+        material.outlineWidth > 0
+          ? material.outlineColor.alpha
+          : material.color.alpha;
 
       point._dirty = false;
     }
@@ -141,28 +169,44 @@ function renderBufferPointCollection(collection, frameState, renderContext) {
     renderContext.vertexArray = new VertexArray({
       context,
       attributes: [
+        ...(!useFloat64
+          ? [
+              {
+                index: BufferPointAttributeLocations.position,
+                componentDatatype: collection._positionDatatype,
+                componentsPerAttribute: 3,
+                normalize: collection._positionNormalized,
+                vertexBuffer: Buffer.createVertexBuffer({
+                  typedArray: collection._positionView,
+                  context,
+                  usage: BufferUsage.STATIC_DRAW,
+                }),
+              },
+            ]
+          : [
+              {
+                index: BufferPointAttributeLocationsFloat64.positionHigh,
+                componentDatatype: ComponentDatatype.FLOAT,
+                componentsPerAttribute: 3,
+                vertexBuffer: Buffer.createVertexBuffer({
+                  typedArray: attributeArrays.positionHigh,
+                  context,
+                  usage: BufferUsage.STATIC_DRAW,
+                }),
+              },
+              {
+                index: BufferPointAttributeLocationsFloat64.positionLow,
+                componentDatatype: ComponentDatatype.FLOAT,
+                componentsPerAttribute: 3,
+                vertexBuffer: Buffer.createVertexBuffer({
+                  typedArray: attributeArrays.positionLow,
+                  context,
+                  usage: BufferUsage.STATIC_DRAW,
+                }),
+              },
+            ]),
         {
-          index: BufferPointAttributeLocations.positionHigh,
-          componentDatatype: ComponentDatatype.FLOAT,
-          componentsPerAttribute: 3,
-          vertexBuffer: Buffer.createVertexBuffer({
-            typedArray: attributeArrays.positionHigh,
-            context,
-            usage: BufferUsage.STATIC_DRAW,
-          }),
-        },
-        {
-          index: BufferPointAttributeLocations.positionLow,
-          componentDatatype: ComponentDatatype.FLOAT,
-          componentsPerAttribute: 3,
-          vertexBuffer: Buffer.createVertexBuffer({
-            typedArray: attributeArrays.positionLow,
-            context,
-            usage: BufferUsage.STATIC_DRAW,
-          }),
-        },
-        {
-          index: BufferPointAttributeLocations.pickColor,
+          index: attributeLocations.pickColor,
           componentDatatype: ComponentDatatype.UNSIGNED_BYTE,
           componentsPerAttribute: 4,
           vertexBuffer: Buffer.createVertexBuffer({
@@ -172,21 +216,21 @@ function renderBufferPointCollection(collection, frameState, renderContext) {
           }),
         },
         {
-          index: BufferPointAttributeLocations.showSizeAndColor,
+          index: attributeLocations.showSizeColorAlpha,
           componentDatatype: ComponentDatatype.FLOAT,
-          componentsPerAttribute: 3,
+          componentsPerAttribute: 4,
           vertexBuffer: Buffer.createVertexBuffer({
-            typedArray: attributeArrays.showSizeAndColor,
+            typedArray: attributeArrays.showSizeColorAlpha,
             context,
             usage: BufferUsage.STATIC_DRAW,
           }),
         },
         {
-          index: BufferPointAttributeLocations.outlineWidthAndOutlineColor,
+          index: attributeLocations.outlineWidthColorAlpha,
           componentDatatype: ComponentDatatype.FLOAT,
-          componentsPerAttribute: 2,
+          componentsPerAttribute: 3,
           vertexBuffer: Buffer.createVertexBuffer({
-            typedArray: attributeArrays.outlineWidthAndOutlineColor,
+            typedArray: attributeArrays.outlineWidthColorAlpha,
             context,
             usage: BufferUsage.STATIC_DRAW,
           }),
@@ -194,11 +238,11 @@ function renderBufferPointCollection(collection, frameState, renderContext) {
       ],
     });
   } else if (collection._dirtyCount > 0) {
-    for (const key in BufferPointAttributeLocations) {
-      if (Object.hasOwn(BufferPointAttributeLocations, key)) {
+    for (const key in attributeLocations) {
+      if (Object.hasOwn(attributeLocations, key)) {
         const attribute = /** @type {BufferPointAttribute} */ (key);
         renderContext.vertexArray.copyAttributeFromRange(
-          BufferPointAttributeLocations[attribute],
+          attributeLocations[attribute],
           renderContext.attributeArrays[attribute],
           collection._dirtyOffset,
           collection._dirtyCount,
@@ -209,7 +253,10 @@ function renderBufferPointCollection(collection, frameState, renderContext) {
 
   if (!defined(renderContext.renderState)) {
     renderContext.renderState = RenderState.fromCache({
-      blending: BlendingState.ALPHA_BLEND,
+      blending:
+        collection._blendOption === BlendOption.OPAQUE
+          ? BlendingState.DISABLED
+          : BlendingState.ALPHA_BLEND,
       depthTest: { enabled: true },
     });
   }
@@ -219,11 +266,12 @@ function renderBufferPointCollection(collection, frameState, renderContext) {
       context,
       vertexShaderSource: new ShaderSource({
         sources: [BufferPointMaterialVS],
+        defines: useFloat64 ? ["USE_FLOAT64"] : [],
       }),
       fragmentShaderSource: new ShaderSource({
         sources: [BufferPointMaterialFS],
       }),
-      attributeLocations: BufferPointAttributeLocations,
+      attributeLocations,
     });
   }
 
@@ -233,12 +281,15 @@ function renderBufferPointCollection(collection, frameState, renderContext) {
       renderState: renderContext.renderState,
       shaderProgram: renderContext.shaderProgram,
       primitiveType: PrimitiveType.POINTS,
-      pass: Pass.OPAQUE,
+      pass:
+        collection._blendOption === BlendOption.OPAQUE
+          ? Pass.OPAQUE
+          : Pass.TRANSLUCENT,
       pickId: collection._allowPicking ? "v_pickColor" : undefined,
       owner: collection,
       count: collection.primitiveCount,
       modelMatrix: collection.modelMatrix, // shared reference
-      boundingVolume: collection.boundingVolumeWC, // shared reference
+      boundingVolume: collection.boundingVolume, // shared reference
       debugShowBoundingVolume: collection.debugShowBoundingVolume,
     });
   }
@@ -255,8 +306,7 @@ function renderBufferPointCollection(collection, frameState, renderContext) {
 
   frameState.commandList.push(command);
 
-  collection._dirtyCount = 0;
-  collection._dirtyOffset = 0;
+  collection._makeClean();
 
   return renderContext;
 }