@rtzh/engine 0.0.3 → 0.0.5

package/Build/Workers/upsampleVerticesFromCesium3DTilesTerrain.js

@@ -0,0 +1,95 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.5
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  Cesium3DTilesTerrainGeometryProcessor_default
+} from "./chunk-JJD7S2CV.js";
+import "./chunk-RO7SDGOD.js";
+import "./chunk-Z4IW5XUY.js";
+import {
+  createTaskProcessorWorker_default
+} from "./chunk-27JI7F7B.js";
+import "./chunk-6GNLKYQO.js";
+import "./chunk-OAFZ26QL.js";
+import "./chunk-3EZBCDBK.js";
+import "./chunk-4GPHI5UY.js";
+import "./chunk-GCZNJHST.js";
+import "./chunk-XOXF37BU.js";
+import "./chunk-CCPKBCZD.js";
+import "./chunk-OQK27J4J.js";
+import "./chunk-UTXXZ7XH.js";
+import "./chunk-MB2ZJQR3.js";
+import "./chunk-TEZGNCXH.js";
+import "./chunk-DKJMD2HX.js";
+import "./chunk-DVTKM7FF.js";
+import "./chunk-XNKQLSHI.js";
+import "./chunk-DAYNPAVN.js";
+import "./chunk-V4I3IKAK.js";
+import "./chunk-ZYTMDBCR.js";
+import "./chunk-IEBTKCMB.js";
+import "./chunk-RTJ6L5O4.js";
+import "./chunk-W2EK42GB.js";
+
+// packages/engine/Source/Workers/upsampleVerticesFromCesium3DTilesTerrain.js
+function upsampleVerticesFromCesium3DTilesTerrain(options, transferableObjects) {
+  const mesh = Cesium3DTilesTerrainGeometryProcessor_default.upsampleMesh(options);
+  const verticesBuffer = mesh.vertices.buffer;
+  const indicesBuffer = mesh.indices.buffer;
+  const westIndicesBuffer = mesh.westIndicesSouthToNorth.buffer;
+  const southIndicesBuffer = mesh.southIndicesEastToWest.buffer;
+  const eastIndicesBuffer = mesh.eastIndicesNorthToSouth.buffer;
+  const northIndicesBuffer = mesh.northIndicesWestToEast.buffer;
+  transferableObjects.push(
+    verticesBuffer,
+    indicesBuffer,
+    westIndicesBuffer,
+    southIndicesBuffer,
+    eastIndicesBuffer,
+    northIndicesBuffer
+  );
+  const result = {
+    verticesBuffer,
+    indicesBuffer,
+    vertexCountWithoutSkirts: mesh.vertexCountWithoutSkirts,
+    indexCountWithoutSkirts: mesh.indexCountWithoutSkirts,
+    encoding: mesh.encoding,
+    westIndicesBuffer,
+    southIndicesBuffer,
+    eastIndicesBuffer,
+    northIndicesBuffer,
+    minimumHeight: mesh.minimumHeight,
+    maximumHeight: mesh.maximumHeight,
+    boundingSphere: mesh.boundingSphere3D,
+    orientedBoundingBox: mesh.orientedBoundingBox,
+    horizonOcclusionPoint: mesh.horizonOcclusionPoint
+  };
+  return result;
+}
+var upsampleVerticesFromCesium3DTilesTerrain_default = createTaskProcessorWorker_default(
+  upsampleVerticesFromCesium3DTilesTerrain
+);
+export {
+  upsampleVerticesFromCesium3DTilesTerrain_default as default
+};

package/Source/Scene/Cesium3DTileset.js

@@ -63,6 +63,7 @@ import Cesium3DTilesetSkipTraversal from "./Cesium3DTilesetSkipTraversal.js";
 import Ray from "../Core/Ray.js";
 import DynamicEnvironmentMapManager from "./DynamicEnvironmentMapManager.js";
 import ImageryLayerCollection from "./ImageryLayerCollection.js";
+import Cesium3DTileStyle from "./Cesium3DTileStyle.js";
 
 /**
  * @typedef {object} Cesium3DTileset.ConstructorOptions
@@ -949,6 +950,12 @@ function Cesium3DTileset(options) {
    */
   this.debugWireframe = options.debugWireframe ?? false;
 
+  this._wireframeOriginalStyle = undefined;
+  this._wireframeOriginalColorBlendMode = this.colorBlendMode;
+  this._debugWireframeLineWidth = options.debugWireframeLineWidth ?? 1.0;
+  this._debugWireframeMode = options.debugWireframeMode ?? "lines";
+  this._debugWireframeOverlay = options.debugWireframeOverlay ?? false;
+
   // Warning for improper setup of debug wireframe
   if (this.debugWireframe === true && this._enableDebugWireframe === false) {
     oneTimeWarning(
@@ -1092,6 +1099,71 @@ Object.defineProperties(Cesium3DTileset.prototype, {
     },
   },
 
+  /**
+   * This property is for debugging only; it is not optimized for production use.
+   * <p>
+   * The line width to use when rendering the tileset in wireframe mode.
+   * This only applies when <code>debugWireframeMode</code> is set to "barycentric".
+   * For "lines" mode, the line width is limited by the browser's WebGL implementation.
+   * </p>
+   *
+   * @memberof Cesium3DTileset.prototype
+   *
+   * @type {number}
+   * @default 1.0
+   */
+  debugWireframeLineWidth: {
+    get: function () {
+      return this._debugWireframeLineWidth;
+    },
+    set: function (value) {
+      this._debugWireframeLineWidth = value;
+    },
+  },
+
+  /**
+   * This property is for debugging only; it is not optimized for production use.
+   * <p>
+   * The mode to use when rendering the tileset in wireframe mode.
+   * </p>
+   *
+   * @memberof Cesium3DTileset.prototype
+   *
+   * @type {"lines" | "barycentric"}
+   * @default "lines"
+   */
+  debugWireframeMode: {
+    get: function () {
+      return this._debugWireframeMode;
+    },
+    set: function (value) {
+      this._debugWireframeMode = value;
+    },
+  },
+
+  /**
+   * This property is for debugging only; it is not optimized for production use.
+   * <p>
+   * When <code>true</code>, the wireframe color is overlaid on top of the tileset's
+   * original material. When <code>false</code>, the wireframe color replaces the
+   * tileset's original material entirely. Only applies when <code>debugWireframeMode</code>
+   * is set to "barycentric".
+   * </p>
+   *
+   * @memberof Cesium3DTileset.prototype
+   *
+   * @type {boolean}
+   * @default false
+   */
+  debugWireframeOverlay: {
+    get: function () {
+      return this._debugWireframeOverlay;
+    },
+    set: function (value) {
+      this._debugWireframeOverlay = value;
+    },
+  },
+
   /**
    * Gets the tileset's asset object property, which contains metadata about the tileset.
    * <p>
@@ -3929,4 +4001,105 @@ Cesium3DTileset.prototype.isGltfExtensionRequired = function (
  * @param {number} time The time of interpolation generally in the range <code>[0.0, 1.0]</code>.
  * @returns {number} The interpolated value.
  */
+
+/**
+ * Displays the tileset in wireframe mode.
+ * <p>
+ * Only affects this tileset; other tilesets in the scene remain unchanged.
+ * </p>
+ * <p>
+ * For WebGL1 environments using "lines" mode, <code>enableDebugWireframe</code>
+ * must be set to <code>true</code> when the tileset is created, otherwise this method
+ * will have no effect. The "barycentric" mode works without enableDebugWireframe.
+ * </p>
+ *
+ * @param {object} [options] Optional parameters for wireframe display
+ * @param {Color} [options.color=Color.WHITE] A color to apply to all features
+ * @param {Cesium3DTileColorBlendMode} [options.colorBlendMode=Cesium3DTileColorBlendMode.REPLACE] How the color blends with features
+ * @param {"lines" | "barycentric"} [options.mode="lines"] The wireframe rendering mode
+ * @param {boolean} [options.overlay=false] If true, wireframe color is overlaid on top of the tileset's original material (only applies to barycentric mode)
+ * @returns {Cesium3DTileset} This tileset instance, to allow chaining of method calls.
+ *
+ * @see Cesium3DTileset#hideWireframe
+ * @see Cesium3DTileset#toggleWireframe
+ * @see Cesium3DTileset#debugWireframe
+ */
+Cesium3DTileset.prototype.showWireframe = function ({
+  color = Color.WHITE,
+  colorBlendMode = Cesium3DTileColorBlendMode.REPLACE,
+  lineWidth = 1.0,
+  mode = "lines",
+  overlay = false,
+} = {}) {
+  if (!this.debugWireframe) {
+    this._wireframeOriginalStyle = this.style;
+    this._wireframeOriginalColorBlendMode = this.colorBlendMode;
+  }
+
+  this.colorBlendMode = colorBlendMode;
+  this.style = new Cesium3DTileStyle({
+    color: color.toCssColorString(),
+  });
+  this.debugWireframeLineWidth = lineWidth;
+  this.debugWireframeMode = mode;
+  this.debugWireframeOverlay = overlay;
+  this.debugWireframe = true;
+
+  return this;
+};
+
+/**
+ * Hides the tileset's wireframe, restoring it to normal rendering mode.
+ * <p>
+ * Only affects this tileset; other tilesets in the scene remain unchanged.
+ * </p>
+ *
+ * @returns {Cesium3DTileset} This tileset instance, to allow chaining of method calls.
+ *
+ * @see Cesium3DTileset#showWireframe
+ * @see Cesium3DTileset#toggleWireframe
+ * @see Cesium3DTileset#debugWireframe
+ */
+Cesium3DTileset.prototype.hideWireframe = function () {
+  this.debugWireframe = false;
+  this.colorBlendMode = this._wireframeOriginalColorBlendMode;
+  this.style = this._wireframeOriginalStyle;
+
+  return this;
+};
+
+/**
+ * Toggles the tileset's wireframe display state.
+ * <p>
+ * If the tileset is currently in wireframe mode, it will be switched to normal
+ * mode, and vice versa. Only affects this tileset; other tilesets in the scene
+ * remain unchanged.
+ * </p>
+ * <p>
+ * For WebGL1 environments using "lines" mode, <code>enableDebugWireframe</code>
+ * must be set to <code>true</code> when the tileset is created, otherwise enabling
+ * wireframe will have no effect. The "barycentric" mode works without enableDebugWireframe.
+ * </p>
+ *
+ * @param {object} [options] Optional parameters for wireframe display (only applied when switching to wireframe mode)
+ * @param {Color} [options.color=Color.WHITE] A color to apply to all features
+ * @param {Cesium3DTileColorBlendMode} [options.colorBlendMode=Cesium3DTileColorBlendMode.REPLACE] How the color blends with features
+ * @param {"lines" | "barycentric"} [options.mode="lines"] The wireframe rendering mode
+ * @param {boolean} [options.overlay=false] If true, wireframe color is overlaid on top of the tileset's original material (only applies to barycentric mode)
+ * @returns {boolean} <code>true</code> if the tileset is now displayed in
+ *          wireframe mode, <code>false</code> if it is in normal mode.
+ *
+ * @see Cesium3DTileset#showWireframe
+ * @see Cesium3DTileset#hideWireframe
+ * @see Cesium3DTileset#debugWireframe
+ */
+Cesium3DTileset.prototype.toggleWireframe = function (options) {
+  if (this.debugWireframe) {
+    this.hideWireframe();
+  } else {
+    this.showWireframe(options);
+  }
+  return this.debugWireframe;
+};
+
 export default Cesium3DTileset;

package/Source/Scene/GltfLoader.js

@@ -2201,7 +2201,7 @@ function loadPrimitive(loader, gltfPrimitive, hasInstances, frameState) {
     let fa = featureIdAttrs[fg];
     let label = "featureId_" + fa.setIndex;
     if (!existingSetIndices[fa.setIndex] && !existingLabels[label]) {
-      let newFeatId = new ModelComponents.FeatureIdAttribute();
+      let newFeatId = new FeatureIdAttribute();
       newFeatId.setIndex = fa.setIndex;
       newFeatId.positionalLabel = label;
       newFeatId.propertyTableId = 0;
@@ -2219,7 +2219,7 @@ function loadPrimitive(loader, gltfPrimitive, hasInstances, frameState) {
   for (let fh = 0; fh <= 1; fh++) {
     let defLabel = "featureId_" + fh;
     if (!existingLabels[defLabel]) {
-      let defFeatId = new ModelComponents.FeatureIdAttribute();
+      let defFeatId = new FeatureIdAttribute();
       defFeatId.setIndex = fh;
       defFeatId.positionalLabel = defLabel;
       defFeatId.propertyTableId = 0;

package/Source/Scene/Model/BarycentricWireframePipelineStage.js

@@ -0,0 +1,176 @@
+import Buffer from "../../Renderer/Buffer.js";
+import BufferUsage from "../../Renderer/BufferUsage.js";
+import Color from "../../Core/Color.js";
+import ComponentDatatype from "../../Core/ComponentDatatype.js";
+import defined from "../../Core/defined.js";
+import IndexDatatype from "../../Core/IndexDatatype.js";
+import ModelUtility from "./ModelUtility.js";
+import PrimitiveType from "../../Core/PrimitiveType.js";
+import ShaderDestination from "../../Renderer/ShaderDestination.js";
+import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
+
+const BarycentricWireframePipelineStage = {
+  name: "BarycentricWireframePipelineStage",
+};
+
+BarycentricWireframePipelineStage.process = function (
+  renderResources,
+  primitive,
+  frameState,
+) {
+  const shaderBuilder = renderResources.shaderBuilder;
+  const model = renderResources.model;
+
+  const barycentricAttributeLocation = shaderBuilder.addAttribute(
+    "vec3",
+    "a_barycentric",
+  );
+
+  shaderBuilder.addDefine(
+    "HAS_BARYCENTRIC_WIREFRAME",
+    undefined,
+    ShaderDestination.FRAGMENT,
+  );
+
+  if (model.debugWireframeOverlay) {
+    shaderBuilder.addDefine(
+      "WIREFRAME_OVERLAY",
+      undefined,
+      ShaderDestination.FRAGMENT,
+    );
+  }
+
+  shaderBuilder.addVarying("vec3", "v_barycentric");
+
+  shaderBuilder.addUniform(
+    "float",
+    "u_wireframeWidth",
+    ShaderDestination.FRAGMENT,
+  );
+  shaderBuilder.addUniform(
+    "vec4",
+    "u_wireframeColor",
+    ShaderDestination.FRAGMENT,
+  );
+
+  const stageUniforms = renderResources.uniformMap;
+  stageUniforms.u_wireframeWidth = function () {
+    return model.debugWireframeLineWidth ?? 1.0;
+  };
+  stageUniforms.u_wireframeColor = function () {
+    return defined(model.color) ? model.color : Color.WHITE;
+  };
+
+  addBarycentricAttribute(
+    renderResources,
+    primitive,
+    barycentricAttributeLocation,
+    frameState,
+  );
+};
+
+function getOriginalIndices(primitive, indices, frameState) {
+  const positionAttribute = ModelUtility.getAttributeBySemantic(
+    primitive,
+    VertexAttributeSemantic.POSITION,
+  );
+  const vertexCount = positionAttribute.count;
+  const webgl2 = frameState.context.webgl2;
+
+  let originalIndices;
+  if (defined(indices)) {
+    const indicesBuffer = indices.buffer;
+    const indicesCount = indices.count;
+    if (defined(indicesBuffer) && webgl2) {
+      const useUint8Array = indicesBuffer.sizeInBytes === indicesCount;
+      originalIndices = useUint8Array
+        ? new Uint8Array(indicesCount)
+        : IndexDatatype.createTypedArray(vertexCount, indicesCount);
+
+      indicesBuffer.getBufferData(originalIndices);
+    } else {
+      originalIndices = indices.typedArray;
+    }
+  }
+  return originalIndices;
+}
+
+function addBarycentricAttribute(
+  renderResources,
+  primitive,
+  attributeLocation,
+  frameState,
+) {
+  const positionAttribute = ModelUtility.getAttributeBySemantic(
+    primitive,
+    VertexAttributeSemantic.POSITION,
+  );
+  const vertexCount = positionAttribute.count;
+  const indices = renderResources.indices;
+  const originalIndices = getOriginalIndices(primitive, indices, frameState);
+
+  const barycentricValues = new Float32Array(vertexCount * 3);
+
+  if (defined(originalIndices)) {
+    const indexCount = indices.count;
+    const primitiveType = primitive.primitiveType;
+
+    if (PrimitiveType.isTriangles(primitiveType)) {
+      for (let i = 0; i < indexCount; i += 3) {
+        const i0 = originalIndices[i];
+        const i1 = originalIndices[i + 1];
+        const i2 = originalIndices[i + 2];
+
+        barycentricValues[i0 * 3] = 1.0;
+        barycentricValues[i0 * 3 + 1] = 0.0;
+        barycentricValues[i0 * 3 + 2] = 0.0;
+
+        barycentricValues[i1 * 3] = 0.0;
+        barycentricValues[i1 * 3 + 1] = 1.0;
+        barycentricValues[i1 * 3 + 2] = 0.0;
+
+        barycentricValues[i2 * 3] = 0.0;
+        barycentricValues[i2 * 3 + 1] = 0.0;
+        barycentricValues[i2 * 3 + 2] = 1.0;
+      }
+    }
+  } else {
+    for (let i = 0; i < vertexCount; i += 3) {
+      const baseIndex = i * 3;
+      barycentricValues[baseIndex] = 1.0;
+      barycentricValues[baseIndex + 1] = 0.0;
+      barycentricValues[baseIndex + 2] = 0.0;
+
+      barycentricValues[baseIndex + 3] = 0.0;
+      barycentricValues[baseIndex + 4] = 1.0;
+      barycentricValues[baseIndex + 5] = 0.0;
+
+      barycentricValues[baseIndex + 6] = 0.0;
+      barycentricValues[baseIndex + 7] = 0.0;
+      barycentricValues[baseIndex + 8] = 1.0;
+    }
+  }
+
+  const barycentricBuffer = Buffer.createVertexBuffer({
+    context: frameState.context,
+    typedArray: barycentricValues,
+    usage: BufferUsage.STATIC_DRAW,
+  });
+
+  const model = renderResources.model;
+  model._pipelineResources.push(barycentricBuffer);
+
+  const barycentricAttribute = {
+    index: attributeLocation,
+    vertexBuffer: barycentricBuffer,
+    componentsPerAttribute: 3,
+    componentDatatype: ComponentDatatype.FLOAT,
+    offsetInBytes: 0,
+    strideInBytes: 0,
+    normalize: false,
+  };
+
+  renderResources.attributes.push(barycentricAttribute);
+}
+
+export default BarycentricWireframePipelineStage;

package/Source/Scene/Model/I3dmLoader.js

@@ -623,7 +623,7 @@ function createInstances(loader, components, frameState) {
       featureId1Array[i] = defined(fid1) ? fid1 : 0;
     }
   }
-  let fid1Attr = new Attribute3();
+  let fid1Attr = new Attribute();
   fid1Attr.name = "Instance Feature ID 1";
   fid1Attr.setIndex = 1;
   fid1Attr.semantic = InstanceAttributeSemantic.FEATURE_ID;
@@ -639,7 +639,7 @@ function createInstances(loader, components, frameState) {
   buffers.push(fid1Buf);
   fid1Attr.buffer = fid1Buf;
   instances.attributes.push(fid1Attr);
-  let fid1FeatAttr = new FeatureIdAttribute4();
+  let fid1FeatAttr = new FeatureIdAttribute();
   fid1FeatAttr.propertyTableId = 0;
   fid1FeatAttr.setIndex = 1;
   fid1FeatAttr.positionalLabel = "instanceFeatureId_1";