@hztxi/cesium-engine 25.0.6 → 26.2.1

package/Source/Scene/renderBufferPolygonCollection.js

@@ -21,6 +21,8 @@ import EncodedCartesian3 from "../Core/EncodedCartesian3.js";
 import AttributeCompression from "../Core/AttributeCompression.js";
 import IndexDatatype from "../Core/IndexDatatype.js";
 import BufferPolygonMaterial from "./BufferPolygonMaterial.js";
+import BlendOption from "./BlendOption.js";
+import WebGLConstants from "../Core/WebGLConstants.js";
 
 /** @import {TypedArray} from "../Core/globalTypes.js"; */
 /** @import FrameState from "./FrameState.js"; */
@@ -28,29 +30,47 @@ import BufferPolygonMaterial from "./BufferPolygonMaterial.js";
 
 /**
  * TODO(PR#13211): Need 'keyof' syntax to avoid duplicating attribute names.
- * @typedef {'positionHigh' | 'positionLow' | 'pickColor' | 'showAndColor'} BufferPolygonAttribute
+ * @typedef {'positionHigh' | 'positionLow' | 'pickColor' | 'showColorAlpha' | 'outlineWidthColorAlpha'} BufferPolygonAttribute
  * @ignore
  */
 
 /**
+ * Attribute locations when using 64-bit position precision.
  * @type {Record<BufferPolygonAttribute, number>}
  * @ignore
  */
-const BufferPolygonAttributeLocations = {
+const BufferPolygonAttributeLocationsFloat64 = {
   positionHigh: 0,
   positionLow: 1,
   pickColor: 2,
-  showAndColor: 3,
+  showColorAlpha: 3,
+  outlineWidthColorAlpha: 4,
+};
+
+/**
+ * Attribute locations when using <= 32-bit position precision.
+ * @type {Record<string, number>}
+ * @ignore
+ */
+const BufferPolygonAttributeLocations = {
+  position: 0,
+  pickColor: 1,
+  showColorAlpha: 2,
+  outlineWidthColorAlpha: 3,
 };
 
 /**
  * @typedef {object} BufferPolygonRenderContext
  * @property {VertexArray} [vertexArray]
- * @property {Record<BufferPolygonAttribute, TypedArray>} [attributeArrays]
+ * @property {Record<string, TypedArray>} [attributeArrays]
  * @property {TypedArray} [indexArray]
+ * @property {number} [triangleIndexMax]
  * @property {RenderState} [renderState]
+ * @property {RenderState} [outlineRenderState]
  * @property {ShaderProgram} [shaderProgram]
+ * @property {ShaderProgram} [outlineShaderProgram]
  * @property {DrawCommand} [command]
+ * @property {DrawCommand} [outlineCommand]
  * @property {Function} destroy
  * @ignore
  */
@@ -60,7 +80,7 @@ const polygon = new BufferPolygon();
 const material = new BufferPolygonMaterial();
 const pickColor = new Color();
 const cartesian = new Cartesian3();
-const encodedCartesian = new EncodedCartesian3();
+const encodedC = new EncodedCartesian3();
 
 /**
  * @param {BufferPolygonCollection} collection
@@ -72,24 +92,35 @@ const encodedCartesian = new EncodedCartesian3();
 function renderBufferPolygonCollection(collection, frameState, renderContext) {
   const context = frameState.context;
   renderContext = renderContext || { destroy: destroyRenderContext };
+  const useFloat64 = collection._positionDatatype === ComponentDatatype.DOUBLE;
+  const attributeLocations = useFloat64
+    ? BufferPolygonAttributeLocationsFloat64
+    : BufferPolygonAttributeLocations;
 
   if (
     !defined(renderContext.attributeArrays) ||
     !defined(renderContext.indexArray)
   ) {
     const { vertexCountMax, triangleCountMax } = collection;
+    const triangleIndexMax = triangleCountMax * 3;
+    renderContext.triangleIndexMax = triangleIndexMax;
 
     // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
     renderContext.indexArray = IndexDatatype.createTypedArray(
       vertexCountMax,
-      triangleCountMax * 3,
+      triangleIndexMax + vertexCountMax * 2,
     );
 
     renderContext.attributeArrays = {
-      positionHigh: new Float32Array(vertexCountMax * 3),
-      positionLow: new Float32Array(vertexCountMax * 3),
+      ...(!useFloat64
+        ? { position: collection._positionView }
+        : {
+            positionHigh: new Float32Array(vertexCountMax * 3),
+            positionLow: new Float32Array(vertexCountMax * 3),
+          }),
       pickColor: new Uint8Array(vertexCountMax * 4),
-      showAndColor: new Float32Array(vertexCountMax * 2),
+      showColorAlpha: new Float32Array(vertexCountMax * 3),
+      outlineWidthColorAlpha: new Float32Array(vertexCountMax * 3),
     };
   }
 
@@ -97,11 +128,13 @@ function renderBufferPolygonCollection(collection, frameState, renderContext) {
     const { attributeArrays } = renderContext;
     const { _dirtyOffset, _dirtyCount } = collection;
 
-    const indexArray = renderContext.indexArray;
     const positionHighArray = attributeArrays.positionHigh;
     const positionLowArray = attributeArrays.positionLow;
+    const indexArray = renderContext.indexArray;
     const pickColorArray = attributeArrays.pickColor;
-    const showAndColorArray = attributeArrays.showAndColor;
+    const showColorAlphaArray = attributeArrays.showColorAlpha;
+    const outlineWidthColorAlphaArray = attributeArrays.outlineWidthColorAlpha;
+    const triangleIndexMax = renderContext.triangleIndexMax;
 
     for (let i = _dirtyOffset, il = _dirtyOffset + _dirtyCount; i < il; i++) {
       collection.get(i, polygon);
@@ -125,36 +158,49 @@ function renderBufferPolygonCollection(collection, frameState, renderContext) {
       }
 
       const show = polygon.show;
-      const cartesianArray = polygon.getPositions();
+      const cartesianArray = !useFloat64 ? null : polygon.getPositions();
       polygon.getMaterial(material);
       const encodedColor = AttributeCompression.encodeRGB8(material.color);
+      const hasOutline = material.outlineWidth > 0;
+      const encodedOutlineColor = AttributeCompression.encodeRGB8(
+        hasOutline ? material.outlineColor : material.color,
+      );
       Color.fromRgba(polygon._pickId, pickColor);
 
       // Update vertex arrays.
       for (let j = 0, jl = polygon.vertexCount; j < jl; j++) {
-        // @ts-expect-error TODO(tsd-jsdoc): See https://github.com/CesiumGS/cesium/pull/13302.
-        Cartesian3.fromArray(cartesianArray, j * 3, cartesian);
-        EncodedCartesian3.fromCartesian(cartesian, encodedCartesian);
-
-        positionHighArray[vOffset * 3] = encodedCartesian.high.x;
-        positionHighArray[vOffset * 3 + 1] = encodedCartesian.high.y;
-        positionHighArray[vOffset * 3 + 2] = encodedCartesian.high.z;
-
-        positionLowArray[vOffset * 3] = encodedCartesian.low.x;
-        positionLowArray[vOffset * 3 + 1] = encodedCartesian.low.y;
-        positionLowArray[vOffset * 3 + 2] = encodedCartesian.low.z;
+        if (useFloat64) {
+          // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+          Cartesian3.fromArray(cartesianArray, j * 3, cartesian);
+          EncodedCartesian3.fromCartesian(cartesian, encodedC);
+          // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+          Cartesian3.pack(encodedC.high, positionHighArray, vOffset * 3);
+          // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+          Cartesian3.pack(encodedC.low, positionLowArray, vOffset * 3);
+        }
 
         pickColorArray[vOffset * 4] = Color.floatToByte(pickColor.red);
         pickColorArray[vOffset * 4 + 1] = Color.floatToByte(pickColor.green);
         pickColorArray[vOffset * 4 + 2] = Color.floatToByte(pickColor.blue);
         pickColorArray[vOffset * 4 + 3] = Color.floatToByte(pickColor.alpha);
 
-        showAndColorArray[vOffset * 2] = show ? 1 : 0;
-        showAndColorArray[vOffset * 2 + 1] = encodedColor;
+        showColorAlphaArray[vOffset * 3] = show ? 1 : 0;
+        showColorAlphaArray[vOffset * 3 + 1] = encodedColor;
+        showColorAlphaArray[vOffset * 3 + 2] = material.color.alpha;
+
+        outlineWidthColorAlphaArray[vOffset * 3] = hasOutline
+          ? material.outlineWidth
+          : 0;
+        outlineWidthColorAlphaArray[vOffset * 3 + 1] = encodedOutlineColor;
+        outlineWidthColorAlphaArray[vOffset * 3 + 2] = hasOutline
+          ? material.outlineColor.alpha
+          : 0;
 
         vOffset++;
       }
 
+      updatePolygonOutlineIndices(polygon, indexArray, triangleIndexMax);
+
       polygon._dirty = false;
     }
   }
@@ -174,42 +220,68 @@ function renderBufferPolygonCollection(collection, frameState, renderContext) {
       }),
 
       attributes: [
+        ...(!useFloat64
+          ? [
+              {
+                index: BufferPolygonAttributeLocations.position,
+                componentDatatype: collection._positionDatatype,
+                componentsPerAttribute: 3,
+                normalize: collection._positionNormalized,
+                vertexBuffer: Buffer.createVertexBuffer({
+                  typedArray: attributeArrays.position,
+                  context,
+                  usage: BufferUsage.STATIC_DRAW,
+                }),
+              },
+            ]
+          : [
+              {
+                index: BufferPolygonAttributeLocationsFloat64.positionHigh,
+                componentDatatype: ComponentDatatype.FLOAT,
+                componentsPerAttribute: 3,
+                vertexBuffer: Buffer.createVertexBuffer({
+                  typedArray: attributeArrays.positionHigh,
+                  context,
+                  usage: BufferUsage.STATIC_DRAW,
+                }),
+              },
+              {
+                index: BufferPolygonAttributeLocationsFloat64.positionLow,
+                componentDatatype: ComponentDatatype.FLOAT,
+                componentsPerAttribute: 3,
+                vertexBuffer: Buffer.createVertexBuffer({
+                  typedArray: attributeArrays.positionLow,
+                  context,
+                  usage: BufferUsage.STATIC_DRAW,
+                }),
+              },
+            ]),
         {
-          index: BufferPolygonAttributeLocations.positionHigh,
-          componentDatatype: ComponentDatatype.FLOAT,
-          componentsPerAttribute: 3,
+          index: attributeLocations.pickColor,
+          componentDatatype: ComponentDatatype.UNSIGNED_BYTE,
+          componentsPerAttribute: 4,
           vertexBuffer: Buffer.createVertexBuffer({
-            typedArray: attributeArrays.positionHigh,
+            typedArray: attributeArrays.pickColor,
             context,
             usage: BufferUsage.STATIC_DRAW,
           }),
         },
         {
-          index: BufferPolygonAttributeLocations.positionLow,
+          index: attributeLocations.showColorAlpha,
           componentDatatype: ComponentDatatype.FLOAT,
           componentsPerAttribute: 3,
           vertexBuffer: Buffer.createVertexBuffer({
-            typedArray: attributeArrays.positionLow,
+            typedArray: attributeArrays.showColorAlpha,
             context,
             usage: BufferUsage.STATIC_DRAW,
           }),
         },
         {
-          index: BufferPolygonAttributeLocations.pickColor,
-          componentDatatype: ComponentDatatype.UNSIGNED_BYTE,
-          componentsPerAttribute: 4,
-          vertexBuffer: Buffer.createVertexBuffer({
-            typedArray: attributeArrays.pickColor,
-            context,
-            usage: BufferUsage.STATIC_DRAW,
-          }),
-        },
-        {
-          index: BufferPolygonAttributeLocations.showAndColor,
+          index: attributeLocations.outlineWidthColorAlpha,
           componentDatatype: ComponentDatatype.FLOAT,
-          componentsPerAttribute: 2,
+          componentsPerAttribute: 3,
           vertexBuffer: Buffer.createVertexBuffer({
-            typedArray: attributeArrays.showAndColor,
+            typedArray: attributeArrays.outlineWidthColorAlpha,
             context,
             usage: BufferUsage.STATIC_DRAW,
           }),
@@ -225,12 +297,20 @@ function renderBufferPolygonCollection(collection, frameState, renderContext) {
       indexOffset,
       indexCount,
     );
+    const triangleIndexMax = /** @type {number} */ (
+      renderContext.triangleIndexMax
+    );
+    renderContext.vertexArray.copyIndexFromRange(
+      renderContext.indexArray,
+      triangleIndexMax + vertexOffset * 2,
+      vertexCount * 2,
+    );
 
-    for (const key in BufferPolygonAttributeLocations) {
-      if (Object.hasOwn(BufferPolygonAttributeLocations, key)) {
+    for (const key in attributeLocations) {
+      if (Object.hasOwn(attributeLocations, key)) {
         const attribute = /** @type {BufferPolygonAttribute} */ (key);
         renderContext.vertexArray.copyAttributeFromRange(
-          BufferPolygonAttributeLocations[attribute],
+          attributeLocations[attribute],
           renderContext.attributeArrays[attribute],
           vertexOffset,
           vertexCount,
@@ -241,21 +321,53 @@ function renderBufferPolygonCollection(collection, frameState, renderContext) {
 
   if (!defined(renderContext.renderState)) {
     renderContext.renderState = RenderState.fromCache({
-      blending: BlendingState.DISABLED,
+      blending:
+        collection._blendOption === BlendOption.OPAQUE
+          ? BlendingState.DISABLED
+          : BlendingState.ALPHA_BLEND,
       depthTest: { enabled: true },
     });
   }
 
+  if (!defined(renderContext.outlineRenderState)) {
+    renderContext.outlineRenderState = RenderState.fromCache({
+      blending:
+        collection._blendOption === BlendOption.OPAQUE
+          ? BlendingState.DISABLED
+          : BlendingState.ALPHA_BLEND,
+      depthTest: {
+        enabled: true,
+        func: WebGLConstants.LEQUAL,
+      },
+    });
+  }
+
   if (!defined(renderContext.shaderProgram)) {
     renderContext.shaderProgram = ShaderProgram.fromCache({
       context,
       vertexShaderSource: new ShaderSource({
         sources: [BufferPolygonMaterialVS],
+        defines: useFloat64 ? ["USE_FLOAT64"] : [],
+      }),
+      fragmentShaderSource: new ShaderSource({
+        sources: [BufferPolygonMaterialFS],
+      }),
+      attributeLocations,
+    });
+  }
+
+  if (!defined(renderContext.outlineShaderProgram)) {
+    renderContext.outlineShaderProgram = ShaderProgram.fromCache({
+      context,
+      vertexShaderSource: new ShaderSource({
+        sources: [BufferPolygonMaterialVS],
+        defines: useFloat64 ? ["USE_FLOAT64"] : [],
       }),
       fragmentShaderSource: new ShaderSource({
         sources: [BufferPolygonMaterialFS],
+        defines: ["OUTLINE"],
       }),
-      attributeLocations: BufferPolygonAttributeLocations,
+      attributeLocations,
     });
   }
 
@@ -267,12 +379,15 @@ function renderBufferPolygonCollection(collection, frameState, renderContext) {
       renderState: renderContext.renderState,
       shaderProgram: renderContext.shaderProgram,
       primitiveType: PrimitiveType.TRIANGLES,
-      pass: Pass.OPAQUE,
+      pass:
+        collection._blendOption === BlendOption.OPAQUE
+          ? Pass.OPAQUE
+          : Pass.TRANSLUCENT,
       pickId: collection._allowPicking ? "v_pickColor" : undefined,
       owner: collection,
       count: drawCount,
       modelMatrix: collection.modelMatrix, // shared reference
-      boundingVolume: collection.boundingVolumeWC, // shared reference
+      boundingVolume: collection.boundingVolume, // shared reference
       debugShowBoundingVolume: collection.debugShowBoundingVolume,
     });
   }
@@ -289,12 +404,89 @@ function renderBufferPolygonCollection(collection, frameState, renderContext) {
 
   frameState.commandList.push(command);
 
-  collection._dirtyCount = 0;
-  collection._dirtyOffset = 0;
+  if (collection._polygonOutlineEnabled) {
+    if (!defined(renderContext.outlineCommand)) {
+      renderContext.outlineCommand = new DrawCommand({
+        vertexArray: renderContext.vertexArray,
+        renderState: renderContext.outlineRenderState,
+        shaderProgram: renderContext.outlineShaderProgram,
+        primitiveType: PrimitiveType.LINES,
+        pass: Pass.OVERLAY,
+        pickId: collection._allowPicking ? "v_pickColor" : undefined,
+        owner: collection,
+        count: collection.vertexCount * 2,
+        modelMatrix: collection.modelMatrix, // shared reference
+        boundingVolume: collection.boundingVolume, // shared reference
+        debugShowBoundingVolume: collection.debugShowBoundingVolume,
+      });
+    }
+
+    const outlineCommand = renderContext.outlineCommand;
+    const outlineCount = collection.vertexCount * 2;
+    outlineCommand.offset = /** @type {number} */ (
+      renderContext.triangleIndexMax
+    );
+    if (outlineCommand.count !== outlineCount) {
+      outlineCommand.count = outlineCount;
+    }
+    if (
+      outlineCommand.debugShowBoundingVolume !==
+      collection.debugShowBoundingVolume
+    ) {
+      outlineCommand.debugShowBoundingVolume =
+        collection.debugShowBoundingVolume;
+    }
+    frameState.commandList.push(outlineCommand);
+  }
+
+  collection._makeClean();
 
   return renderContext;
 }
 
+/**
+ * Writes two indices per polygon vertex, closing each exterior/interior ring.
+ * Edges on a clipped tile boundary are emitted as degenerate segments so they
+ * do not draw artificial tile seams. The fixed 2 * vertexCount layout keeps
+ * every polygon's outline range at `triangleIndexMax + vertexOffset * 2`, so
+ * dirty updates stay contiguous.
+ *
+ * @param {BufferPolygon} polygon
+ * @param {TypedArray} indexArray
+ * @param {number} triangleIndexMax
+ * @ignore
+ */
+function updatePolygonOutlineIndices(polygon, indexArray, triangleIndexMax) {
+  const tileBoundaryFlags = polygon._collection._polygonTileBoundaryFlags;
+  const holes = polygon.getHoles();
+  const ringStarts = [0];
+  for (let i = 0; i < holes.length; i++) {
+    ringStarts.push(holes[i]);
+  }
+
+  const globalVertexStart = polygon.vertexOffset;
+  let writeOffset = triangleIndexMax + globalVertexStart * 2;
+
+  for (let i = 0; i < ringStarts.length; i++) {
+    const ringStart = ringStarts[i];
+    const ringEnd =
+      i + 1 < ringStarts.length ? ringStarts[i + 1] : polygon.vertexCount;
+    const ringVertexCount = ringEnd - ringStart;
+
+    for (let j = 0; j < ringVertexCount; j++) {
+      const next = (j + 1) % ringVertexCount;
+      const vertexA = globalVertexStart + ringStart + j;
+      const vertexB = globalVertexStart + ringStart + next;
+      const isTileBoundaryEdge =
+        defined(tileBoundaryFlags) &&
+        (tileBoundaryFlags[vertexA] & tileBoundaryFlags[vertexB]) !== 0;
+
+      indexArray[writeOffset++] = vertexA;
+      indexArray[writeOffset++] = isTileBoundaryEdge ? vertexA : vertexB;
+    }
+  }
+}
+
 /**
  * Computes dirty ranges for attribute and index buffers in a collection.
  * @param {BufferPolygonCollection} collection