@cesium/engine 23.0.0 → 24.0.0

package/Source/Scene/Model/MaterialPipelineStage.js

@@ -8,6 +8,7 @@ import MaterialStageFS from "../../Shaders/Model/MaterialStageFS.js";
 import AlphaMode from "../AlphaMode.js";
 import ModelComponents from "../ModelComponents.js";
 import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
+import PrimitiveType from "../../Core/PrimitiveType.js";
 import LightingModel from "./LightingModel.js";
 import ModelUtility from "./ModelUtility.js";
 
@@ -184,6 +185,16 @@ MaterialPipelineStage.process = function (
     };
   }
 
+  if (defined(material.lineStyle)) {
+    processLineStyleUniforms(
+      material.lineStyle,
+      primitive,
+      frameState,
+      uniformMap,
+      shaderBuilder,
+    );
+  }
+
   shaderBuilder.addFragmentLines(MaterialStageFS);
 
   if (material.doubleSided) {
@@ -195,6 +206,142 @@ MaterialPipelineStage.process = function (
   }
 };
 
+/**
+ * Add uniforms and defines for the BENTLEY_materials_line_style extension.
+ *
+ * @param {ModelComponents.LineStyle} lineStyle The line style properties.
+ * @param {ModelComponents.Primitive} primitive The primitive being processed.
+ * @param {FrameState} frameState The frame state.
+ * @param {object} uniformMap The uniform map for the primitive.
+ * @param {ShaderBuilder} shaderBuilder The shader builder to modify.
+ * @private
+ */
+function processLineStyleUniforms(
+  lineStyle,
+  primitive,
+  frameState,
+  uniformMap,
+  shaderBuilder,
+) {
+  const { width, pattern } = lineStyle;
+
+  if (defined(width)) {
+    shaderBuilder.addUniform("float", "u_lineWidth", ShaderDestination.VERTEX);
+    uniformMap.u_lineWidth = function () {
+      return width * frameState.pixelRatio;
+    };
+  }
+
+  if (defined(pattern)) {
+    shaderBuilder.addDefine(
+      "HAS_LINE_PATTERN",
+      undefined,
+      ShaderDestination.BOTH,
+    );
+    shaderBuilder.addUniform(
+      "float",
+      "u_linePattern",
+      ShaderDestination.FRAGMENT,
+    );
+    shaderBuilder.addVarying("float", "v_lineCoord");
+    uniformMap.u_linePattern = function () {
+      return pattern;
+    };
+  }
+
+  const cumDistAttribute = ModelUtility.getAttributeBySemantic(
+    primitive,
+    VertexAttributeSemantic.CUMULATIVE_DISTANCE,
+  );
+  if (
+    defined(pattern) &&
+    defined(cumDistAttribute) &&
+    (primitive.primitiveType === PrimitiveType.LINES ||
+      primitive.primitiveType === PrimitiveType.TRIANGLE_STRIP)
+  ) {
+    shaderBuilder.addDefine(
+      "HAS_LINE_CUMULATIVE_DISTANCE",
+      undefined,
+      ShaderDestination.VERTEX,
+    );
+
+    if (cumDistAttribute.normalized) {
+      shaderBuilder.addDefine(
+        "LINE_CUM_DIST_NORMALIZED",
+        undefined,
+        ShaderDestination.VERTEX,
+      );
+    }
+
+    shaderBuilder.addUniform(
+      "float",
+      "u_cumulativeDistanceMax",
+      ShaderDestination.VERTEX,
+    );
+    shaderBuilder.addUniform(
+      "float",
+      "u_pixelsPerWorld",
+      ShaderDestination.VERTEX,
+    );
+
+    const cumDistMax = defined(cumDistAttribute.max)
+      ? cumDistAttribute.max
+      : 1.0;
+    uniformMap.u_cumulativeDistanceMax = function () {
+      return cumDistMax;
+    };
+    uniformMap.u_pixelsPerWorld = function () {
+      // Match iTwin behavior: stable pattern scaling in orthographic views.
+      const frustum = frameState.camera.frustum;
+      let pixelsPerWorld = 1.0;
+      let worldWidth;
+      if (defined(frustum.right) && defined(frustum.left)) {
+        worldWidth = frustum.right - frustum.left;
+      } else if (defined(frustum.width)) {
+        worldWidth = frustum.width;
+      }
+      if (defined(worldWidth) && worldWidth > 0) {
+        pixelsPerWorld = frameState.context.drawingBufferWidth / worldWidth;
+      }
+
+      return pixelsPerWorld;
+    };
+
+    const cumDistVar =
+      ModelUtility.getAttributeInfo(cumDistAttribute).variableName;
+    shaderBuilder.addVertexLines(`
+#ifdef HAS_LINE_CUMULATIVE_DISTANCE
+void lineStyleStageVS(in ProcessedAttributes attributes)
+{
+    float cumDist = attributes.${cumDistVar};
+#ifdef LINE_CUM_DIST_NORMALIZED
+    cumDist *= u_cumulativeDistanceMax;
+#endif
+    const float textureCoordinateBase = 8192.0;
+    v_lineCoord = textureCoordinateBase + cumDist * u_pixelsPerWorld;
+}
+#endif
+`);
+  } else if (defined(pattern)) {
+    shaderBuilder.addVertexLines(`
+#ifdef HAS_LINE_PATTERN
+void lineStyleStageVS(in ProcessedAttributes attributes)
+{
+    vec4 posClip = gl_Position;
+    vec2 screenPos = ((posClip.xy / posClip.w) * 0.5 + 0.5) * czm_viewport.zw;
+
+    const float textureCoordinateBase = 8192.0;
+    if (czm_viewport.z > czm_viewport.w) {
+        v_lineCoord = textureCoordinateBase + screenPos.x;
+    } else {
+        v_lineCoord = textureCoordinateBase + screenPos.y;
+    }
+}
+#endif
+`);
+  }
+}
+
 /**
  * Process a single texture transformation and add it to the shader and uniform map.
  *

package/Source/Scene/Model/MetadataPipelineStage.js

@@ -1030,20 +1030,20 @@ function collectMetadataUsedInPointCloudStyling(
     return;
   }
 
-  const colorVariables = style.color?.getVariables() ?? [];
+  const colorVariables = style.color?.getVariables?.() ?? [];
   for (const propertyId of colorVariables) {
     usedInVertex.add(propertyId);
     usedInFragment.add(propertyId);
   }
 
-  const showVariables = style.show?.getVariables() ?? [];
+  const showVariables = style.show?.getVariables?.() ?? [];
   for (const propertyId of showVariables) {
     usedInVertex.add(propertyId);
     usedInFragment.add(propertyId);
   }
 
   // Only used in vertex shader
-  const pointSizeVariables = style.pointSize?.getVariables() ?? [];
+  const pointSizeVariables = style.pointSize?.getVariables?.() ?? [];
   for (const propertyId of pointSizeVariables) {
     usedInVertex.add(propertyId);
   }

package/Source/Scene/Model/ModelDrawCommand.js

@@ -574,6 +574,11 @@ ModelDrawCommand.prototype.pushCommands = function (frameState, result) {
 
   pushCommand(result, this._originalCommand, use2D);
 
+  // Push edge commands after the original command
+  if (this._needsEdgeCommands) {
+    pushCommand(result, this._edgeCommand, use2D);
+  }
+
   return result;
 };
 
@@ -815,6 +820,7 @@ function deriveEdgeCommand(command, renderResources) {
   };
   edgeCommand.uniformMap = uniformMap;
 
+  edgeCommand.uniformMap = uniformMap;
   edgeCommand.castShadows = false;
   edgeCommand.receiveShadows = false;
 

package/Source/Scene/Model/ModelReader.js

@@ -53,7 +53,7 @@ class ModelReader {
    *
    * The result will be THE actual attribute data.
    *
-   * @param {ModelComponents.Attribute} attribute The attribute
+   * @param {Attribute} attribute The attribute
    * @returns {TypedArray} The attribute data
    */
   static readAttributeAsTypedArray(attribute) {

package/Source/Scene/Model/ModelUtility.js

@@ -10,6 +10,8 @@ import CullFace from "../CullFace.js";
 import PrimitiveType from "../../Core/PrimitiveType.js";
 import Matrix3 from "../../Core/Matrix3.js";
 
+/** @import {Attribute} from "../ModelComponents.js"; */
+
 /**
  * Utility functions for {@link Model}.
  *
@@ -69,7 +71,7 @@ ModelUtility.getNodeTransform = function (node) {
  * @param {ModelComponents.Primitive|ModelComponents.Instances} object The primitive components or instances object
  * @param {VertexAttributeSemantic|InstanceAttributeSemantic} semantic The semantic to search for
  * @param {number} [setIndex] The set index of the semantic. May be undefined for some semantics (POSITION, NORMAL, TRANSLATION, ROTATION, for example)
- * @return {ModelComponents.Attribute} The selected attribute, or undefined if not found.
+ * @return {Attribute} The selected attribute, or undefined if not found.
  *
  * @private
  */

package/Source/Scene/Model/createVectorTileBuffersFromModelComponents.js

@@ -0,0 +1,330 @@
+// @ts-check
+
+import Cartesian3 from "../../Core/Cartesian3.js";
+import assert from "../../Core/assert.js";
+import defined from "../../Core/defined.js";
+import Matrix4 from "../../Core/Matrix4.js";
+import PrimitiveType from "../../Core/PrimitiveType.js";
+import RuntimeError from "../../Core/RuntimeError.js";
+import BufferPoint from "../BufferPoint.js";
+import BufferPointCollection from "../BufferPointCollection.js";
+import BufferPolygon from "../BufferPolygon.js";
+import BufferPolygonCollection from "../BufferPolygonCollection.js";
+import BufferPolyline from "../BufferPolyline.js";
+import BufferPolylineCollection from "../BufferPolylineCollection.js";
+import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
+import ModelReader from "./ModelReader.js";
+import ModelUtility from "./ModelUtility.js";
+import ModelComponents from "../ModelComponents.js";
+
+/** @import { TypedArray } from "../../Core/globalTypes.js"; */
+/** @import BufferPrimitive from "../BufferPrimitive.js"; */
+/** @import BufferPrimitiveCollection from "../BufferPrimitiveCollection.js"; */
+/** @import VectorGltf3DTileContent from "../VectorGltf3DTileContent.js"; */
+/** @import {Attribute, Components, Node, Primitive} from "../ModelComponents.js"; */
+
+/**
+ * @typedef {object} VectorTileResult
+ * @property {Array<BufferPrimitiveCollection<BufferPrimitive>>} collections
+ * @property {Array<Matrix4>} collectionLocalMatrices
+ * @ignore
+ */
+
+const scratchPosition = new Cartesian3();
+const scratchPoint = new BufferPoint();
+const scratchPolyline = new BufferPolyline();
+const scratchPolygon = new BufferPolygon();
+
+/**
+ * Creates vector buffers from model components.
+ *
+ * @param {VectorGltf3DTileContent} content
+ * @param {Components} components
+ * @returns {VectorTileResult}
+ *
+ * @ignore
+ */
+function createVectorTileBuffersFromModelComponents(content, components) {
+  const rootNodes = components.scene.nodes;
+
+  /** @type {VectorTileResult} */
+  const result = { collections: [], collectionLocalMatrices: [] };
+
+  for (let i = 0; i < rootNodes.length; i++) {
+    appendNodeToBuffers(content, rootNodes[i], Matrix4.IDENTITY, result);
+  }
+
+  return result;
+}
+
+/**
+ * @param {TypedArray} indices
+ * @ignore
+ */
+function getPrimitiveRestartIndex(indices) {
+  const bits = indices.BYTES_PER_ELEMENT * 8;
+  return Math.pow(2, bits) - 1;
+}
+
+/**
+ * @param {TypedArray} indices
+ * @param {Function} callback
+ * @ignore
+ */
+function forEachLineStripSegment(indices, callback) {
+  const restart = getPrimitiveRestartIndex(indices);
+  let segmentStart = 0;
+  for (let i = 0; i <= indices.length; i++) {
+    if (i === indices.length || indices[i] === restart) {
+      const segmentCount = i - segmentStart;
+      if (segmentCount > 0) {
+        callback(segmentStart, segmentCount);
+      }
+      segmentStart = i + 1;
+    }
+  }
+}
+
+/**
+ * @param {Primitive} primitive
+ * @ignore
+ */
+function gatherPrimitiveStats(primitive) {
+  const stats = {
+    pointPrimitiveCount: 0,
+    pointVertexCount: 0,
+    polylinePrimitiveCount: 0,
+    polylineVertexCount: 0,
+    polygonPrimitiveCount: 0,
+    polygonVertexCount: 0,
+    polygonHoleCount: 0,
+    polygonTriangleCount: 0,
+  };
+
+  const vector = primitive.vector;
+  const primitiveType = primitive.primitiveType;
+  const positionAttribute = ModelUtility.getAttributeBySemantic(
+    primitive,
+    VertexAttributeSemantic.POSITION,
+  );
+  const positionCount = positionAttribute.count;
+
+  const indices = primitive.indices
+    ? ModelReader.readIndicesAsTypedArray(primitive.indices)
+    : undefined;
+
+  // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
+  if (primitiveType === PrimitiveType.POINTS) {
+    stats.pointPrimitiveCount += vector.count;
+    stats.pointVertexCount += vector.count;
+
+    // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
+  } else if (primitiveType === PrimitiveType.LINE_STRIP) {
+    //>>includeStart('debug', pragmas.debug);
+    assert(defined(indices), "Vector LINE_STRIP primitive must be indexed.");
+    //>>includeEnd('debug');
+
+    stats.polylinePrimitiveCount += vector.count;
+    stats.polylineVertexCount += indices.length - (vector.count - 1);
+
+    // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
+  } else if (primitiveType === PrimitiveType.TRIANGLES) {
+    //>>includeStart('debug', pragmas.debug);
+    assert(defined(indices), "Vector TRIANGLES primitive must be indexed.");
+    //>>includeEnd('debug');
+
+    stats.polygonPrimitiveCount += vector.count;
+    stats.polygonVertexCount += positionCount;
+    stats.polygonTriangleCount += indices.length / 3;
+
+    const polygonHoleCounts = vector.polygonHoleCounts;
+    if (polygonHoleCounts) {
+      for (let i = 0; i < polygonHoleCounts.length; i++) {
+        stats.polygonHoleCount += polygonHoleCounts[i];
+      }
+    }
+  } else {
+    throw new RuntimeError(`Unexpected primitive type: ${primitiveType}`);
+  }
+
+  return stats;
+}
+
+/**
+ * @param {VectorGltf3DTileContent} content
+ * @param {Primitive} primitive
+ * @param {BufferPrimitiveCollection<BufferPrimitive>} collection
+ * @ignore
+ */
+function appendPrimitiveToBuffers(content, primitive, collection) {
+  const vector = primitive.vector;
+  const positionAttribute = ModelUtility.getAttributeBySemantic(
+    primitive,
+    VertexAttributeSemantic.POSITION,
+  );
+  /** @type {TypedArray} */
+  const collectionPositions =
+    positionAttribute.typedArray ??
+    ModelReader.readAttributeAsTypedArray(positionAttribute);
+  const vertexCount = collectionPositions.length / 3;
+
+  /** @type {TypedArray} */
+  const indices = primitive.indices
+    ? ModelReader.readIndicesAsTypedArray(primitive.indices)
+    : undefined;
+
+  const featureIdComponent = primitive.featureIds?.[0];
+  /** @type {Attribute} */
+  let featureIdAttribute;
+  /** @type {TypedArray} */
+  let featureIdArray;
+  if (featureIdComponent instanceof ModelComponents.FeatureIdAttribute) {
+    featureIdAttribute = ModelUtility.getAttributeBySemantic(
+      primitive,
+      VertexAttributeSemantic.FEATURE_ID,
+      featureIdComponent.setIndex,
+    );
+    featureIdArray =
+      featureIdAttribute.typedArray ??
+      ModelReader.readAttributeAsTypedArray(featureIdAttribute);
+  }
+
+  if (collection instanceof BufferPointCollection) {
+    for (let i = 0, il = indices ? indices.length : vertexCount; i < il; i++) {
+      const vertexOffset = indices ? indices[i] : i;
+      Cartesian3.fromArray(
+        // @ts-expect-error TODO(tsd-jsdoc): See https://github.com/CesiumGS/cesium/pull/13302.
+        collectionPositions,
+        vertexOffset * 3,
+        scratchPosition,
+      );
+      collection.add({ position: scratchPosition }, scratchPoint);
+
+      const featureId = Math.trunc(featureIdArray[vertexOffset]);
+      if (featureId !== featureIdComponent.nullFeatureId) {
+        scratchPoint.featureId = featureId;
+      }
+    }
+  } else if (collection instanceof BufferPolylineCollection) {
+    // @ts-expect-error TODO
+    forEachLineStripSegment(indices, (indexOffset, indexCount) => {
+      const vertexOffset = indices[indexOffset];
+      const positions = collectionPositions.subarray(
+        vertexOffset * 3,
+        (vertexOffset + indexCount) * 3,
+      );
+      collection.add({ positions }, scratchPolyline);
+
+      const featureId = Math.trunc(featureIdArray[vertexOffset]);
+      if (featureId !== featureIdComponent.nullFeatureId) {
+        scratchPolyline.featureId = featureId;
+      }
+    });
+  } else if (collection instanceof BufferPolygonCollection) {
+    const polygonAttributeOffsets = vector.polygonAttributeOffsets;
+    const polygonIndicesOffsets = vector.polygonIndicesOffsets;
+    const polygonHoleCounts = vector.polygonHoleCounts;
+    const polygonHoleOffsets = vector.polygonHoleOffsets;
+
+    const polygonCount = polygonAttributeOffsets.length;
+    for (let i = 0; i < polygonCount; i++) {
+      const polygonVertexStart = polygonAttributeOffsets[i];
+      const polygonVertexEnd =
+        i + 1 < polygonCount ? polygonAttributeOffsets[i + 1] : vertexCount;
+
+      const positions = collectionPositions.subarray(
+        polygonVertexStart * 3,
+        polygonVertexEnd * 3,
+      );
+
+      let holes;
+      if (defined(polygonHoleCounts) && polygonHoleCounts[i] > 0) {
+        const holeCount = polygonHoleCounts[i];
+        holes = polygonHoleOffsets.slice(i, i + holeCount);
+        for (let h = 0; h < holeCount; h++) {
+          holes[i] -= polygonVertexStart;
+        }
+      }
+
+      const triangleIndexStart = polygonIndicesOffsets[i];
+      const triangleIndexEnd =
+        i + 1 < polygonCount ? polygonIndicesOffsets[i + 1] : indices.length;
+      const triangles = indices.slice(triangleIndexStart, triangleIndexEnd);
+      for (let t = 0; t < triangleIndexEnd; t++) {
+        triangles[t] -= polygonVertexStart;
+      }
+
+      collection.add({ positions, triangles, holes }, scratchPolygon);
+
+      const featureId = Math.trunc(featureIdArray[polygonVertexStart]);
+      if (featureId !== featureIdComponent.nullFeatureId) {
+        scratchPolygon.featureId = featureId;
+      }
+    }
+  }
+}
+
+/**
+ * @param {VectorGltf3DTileContent} content
+ * @param {Node} node
+ * @param {Matrix4} parentTransform
+ * @param {VectorTileResult} result
+ * @ignore
+ */
+function appendNodeToBuffers(content, node, parentTransform, result) {
+  const localTransform = ModelUtility.getNodeTransform(node);
+  const nodeTransform = Matrix4.multiplyTransformation(
+    parentTransform,
+    localTransform,
+    new Matrix4(),
+  );
+
+  const primitives = node.primitives;
+  for (let i = 0; i < primitives.length; i++) {
+    const primitive = primitives[i];
+    const primitiveType = primitive.primitiveType;
+    if (!primitive.vector) {
+      continue;
+    }
+
+    /** @type {BufferPrimitiveCollection<BufferPrimitive>} */
+    let collection;
+
+    const stats = gatherPrimitiveStats(primitive);
+
+    // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
+    if (primitiveType === PrimitiveType.POINTS) {
+      collection = new BufferPointCollection({
+        primitiveCountMax: stats.pointPrimitiveCount,
+      });
+
+      // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
+    } else if (primitiveType === PrimitiveType.LINE_STRIP) {
+      collection = new BufferPolylineCollection({
+        primitiveCountMax: stats.polylinePrimitiveCount,
+        vertexCountMax: stats.polylineVertexCount,
+      });
+
+      // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
+    } else if (primitiveType === PrimitiveType.TRIANGLES) {
+      collection = new BufferPolygonCollection({
+        primitiveCountMax: stats.polygonPrimitiveCount,
+        vertexCountMax: stats.polygonVertexCount,
+        holeCountMax: stats.polygonHoleCount,
+        triangleCountMax: stats.polygonTriangleCount,
+      });
+    }
+
+    result.collections.push(collection);
+    result.collectionLocalMatrices.push(Matrix4.clone(nodeTransform));
+
+    appendPrimitiveToBuffers(content, primitive, collection);
+  }
+
+  const children = node.children;
+  for (let i = 0; i < children.length; i++) {
+    appendNodeToBuffers(content, children[i], nodeTransform, result);
+  }
+}
+
+export default createVectorTileBuffersFromModelComponents;