@rtzh/engine 0.0.5 → 0.0.7

package/Source/Scene/Model/BarycentricWireframePipelineStage.js

@@ -1,5 +1,6 @@
 import Buffer from "../../Renderer/Buffer.js";
 import BufferUsage from "../../Renderer/BufferUsage.js";
+import Cartesian3 from "../../Core/Cartesian3.js";
 import Color from "../../Core/Color.js";
 import ComponentDatatype from "../../Core/ComponentDatatype.js";
 import defined from "../../Core/defined.js";
@@ -8,6 +9,9 @@ import ModelUtility from "./ModelUtility.js";
 import PrimitiveType from "../../Core/PrimitiveType.js";
 import ShaderDestination from "../../Renderer/ShaderDestination.js";
 import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
+import oneTimeWarning from "../../Core/oneTimeWarning.js";
+import AttributeType from "../AttributeType.js";
+import Pass from "../../Renderer/Pass.js";
 
 const BarycentricWireframePipelineStage = {
   name: "BarycentricWireframePipelineStage",
@@ -20,6 +24,15 @@ BarycentricWireframePipelineStage.process = function (
 ) {
   const shaderBuilder = renderResources.shaderBuilder;
   const model = renderResources.model;
+  const webgl2 = frameState.context.webgl2;
+
+  if (!webgl2) {
+    oneTimeWarning(
+      "barycentric-wireframe-webgl1",
+      "Barycentric wireframe mode requires WebGL 2. Falling back to lines mode.",
+    );
+    return;
+  }
 
   const barycentricAttributeLocation = shaderBuilder.addAttribute(
     "vec3",
@@ -29,7 +42,7 @@ BarycentricWireframePipelineStage.process = function (
   shaderBuilder.addDefine(
     "HAS_BARYCENTRIC_WIREFRAME",
     undefined,
-    ShaderDestination.FRAGMENT,
+    ShaderDestination.BOTH,
   );
 
   if (model.debugWireframeOverlay) {
@@ -40,7 +53,17 @@ BarycentricWireframePipelineStage.process = function (
     );
   }
 
+  if ((model._debugWireframeScanSpeed ?? 0.0) > 0.0) {
+    shaderBuilder.addDefine(
+      "WIREFRAME_SCANLINE",
+      undefined,
+      ShaderDestination.FRAGMENT,
+    );
+  }
+
   shaderBuilder.addVarying("vec3", "v_barycentric");
+  shaderBuilder.addVarying("vec3", "v_wireframeWorldPos");
+  shaderBuilder.addVarying("vec3", "v_wireframeLocalPos");
 
   shaderBuilder.addUniform(
     "float",
@@ -52,16 +75,95 @@ BarycentricWireframePipelineStage.process = function (
     "u_wireframeColor",
     ShaderDestination.FRAGMENT,
   );
+  shaderBuilder.addUniform(
+    "float",
+    "u_wireframeFillAlpha",
+    ShaderDestination.FRAGMENT,
+  );
+  shaderBuilder.addUniform(
+    "float",
+    "u_wireframeGlow",
+    ShaderDestination.FRAGMENT,
+  );
+  shaderBuilder.addUniform(
+    "float",
+    "u_wireframeScanSpeed",
+    ShaderDestination.FRAGMENT,
+  );
+  shaderBuilder.addUniform(
+    "float",
+    "u_wireframeTime",
+    ShaderDestination.FRAGMENT,
+  );
+  shaderBuilder.addUniform(
+    "float",
+    "u_wireframeModelMinHeight",
+    ShaderDestination.BOTH,
+  );
+  shaderBuilder.addUniform(
+    "float",
+    "u_wireframeModelMaxHeight",
+    ShaderDestination.BOTH,
+  );
+  shaderBuilder.addUniform(
+    "vec3",
+    "u_wireframeScanAxis",
+    ShaderDestination.FRAGMENT,
+  );
+  shaderBuilder.addUniform(
+    "float",
+    "u_wireframeScanMin",
+    ShaderDestination.FRAGMENT,
+  );
+  shaderBuilder.addUniform(
+    "float",
+    "u_wireframeScanMax",
+    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;
+    return model.debugWireframeColor ?? Color.WHITE;
   };
+  stageUniforms.u_wireframeFillAlpha = function () {
+    return defined(model._debugWireframeFillColor)
+      ? 1.0
+      : (model._debugWireframeFillAlpha ?? 1.0);
+  };
+  stageUniforms.u_wireframeGlow = function () {
+    return model._debugWireframeGlow ?? 0.0;
+  };
+  stageUniforms.u_wireframeScanSpeed = function () {
+    return model._debugWireframeScanSpeed ?? 0.0;
+  };
+  stageUniforms.u_wireframeTime = function () {
+    return frameState.time.secondsOfDay;
+  };
+  stageUniforms.u_wireframeModelMinHeight = function () {
+    return model._debugWireframeModelMinHeight ?? 0.0;
+  };
+  stageUniforms.u_wireframeModelMaxHeight = function () {
+    return model._debugWireframeModelMaxHeight ?? 1.0;
+  };
+  stageUniforms.u_wireframeScanAxis = function () {
+    return model._debugWireframeScanAxis ?? new Cartesian3(0, 0, 1);
+  };
+  stageUniforms.u_wireframeScanMin = function () {
+    return model._debugWireframeScanMin ?? 0.0;
+  };
+  stageUniforms.u_wireframeScanMax = function () {
+    return model._debugWireframeScanMax ?? 1.0;
+  };
+
+  // Enable alpha blending when fillAlpha < 1.0 in preserve-original-color mode
+  if (!defined(model._debugWireframeFillColor) && (model._debugWireframeFillAlpha ?? 1.0) < 1.0) {
+    renderResources.alphaOptions.pass = Pass.TRANSLUCENT;
+  }
 
-  addBarycentricAttribute(
+  deindexGeometryAndAddBarycentric(
     renderResources,
     primitive,
     barycentricAttributeLocation,
@@ -69,108 +171,260 @@ BarycentricWireframePipelineStage.process = function (
   );
 };
 
-function getOriginalIndices(primitive, indices, frameState) {
-  const positionAttribute = ModelUtility.getAttributeBySemantic(
-    primitive,
-    VertexAttributeSemantic.POSITION,
+function getAttributeIndex(shaderBuilder, semantic, setIndex) {
+  return shaderBuilder.attributeLocations[semantic + "_" + (setIndex ?? 0)];
+}
+
+function getComponentsFromType(type) {
+  return AttributeType.getNumberOfComponents(type);
+}
+
+function extractAttributeData(attribute) {
+  if (!defined(attribute)) {
+    return undefined;
+  }
+
+  const typedArray = attribute.typedArray;
+  if (!defined(typedArray)) {
+    return undefined;
+  }
+
+  const componentDatatype = attribute.componentDatatype;
+  const componentsPerAttribute = getComponentsFromType(attribute.type);
+  const count = attribute.count;
+  const byteOffset = attribute.byteOffset ?? 0;
+  const byteStride = attribute.byteStride;
+  const componentSize = ComponentDatatype.getSizeInBytes(componentDatatype);
+  const stride = defined(byteStride) && byteStride !== 0
+    ? byteStride
+    : componentsPerAttribute * componentSize;
+
+  const result = ComponentDatatype.createTypedArray(
+    componentDatatype,
+    count * componentsPerAttribute,
   );
-  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;
+  const baseOffset = byteOffset;
+  for (let i = 0; i < count; i++) {
+    const byteIndex = baseOffset + i * stride;
+    const elementIndex = byteIndex / componentSize;
+    for (let c = 0; c < componentsPerAttribute; c++) {
+      result[i * componentsPerAttribute + c] = typedArray[elementIndex + c];
+    }
+  }
+
+  return {
+    data: result,
+    count: count,
+    componentsPerAttribute: componentsPerAttribute,
+    componentDatatype: componentDatatype,
+    normalized: attribute.normalized,
+  };
+}
+
+function extractIndicesData(primitive) {
+  const indices = primitive.indices;
+  if (!defined(indices)) {
+    return undefined;
+  }
+
+  const typedArray = indices.typedArray;
+  if (defined(typedArray)) {
+    return typedArray;
+  }
+
+  return undefined;
+}
+
+function deindexAttributeData(
+  originalData,
+  originalIndices,
+  componentsPerAttribute,
+  componentDatatype,
+) {
+  const newVertexCount = originalIndices.length;
+  const totalComponents = newVertexCount * componentsPerAttribute;
+  const newData = ComponentDatatype.createTypedArray(componentDatatype, totalComponents);
+
+  for (let i = 0; i < newVertexCount; i++) {
+    const oldIndex = originalIndices[i];
+    const srcOffset = oldIndex * componentsPerAttribute;
+    const dstOffset = i * componentsPerAttribute;
+    for (let c = 0; c < componentsPerAttribute; c++) {
+      newData[dstOffset + c] = originalData[srcOffset + c];
     }
   }
-  return originalIndices;
+
+  return newData;
 }
 
-function addBarycentricAttribute(
+function createVertexBuffer(typedArray, frameState, model) {
+  const buffer = Buffer.createVertexBuffer({
+    context: frameState.context,
+    typedArray: typedArray,
+    usage: BufferUsage.STATIC_DRAW,
+  });
+  model._pipelineResources.push(buffer);
+  return buffer;
+}
+
+function deindexGeometryAndAddBarycentric(
   renderResources,
   primitive,
-  attributeLocation,
+  barycentricAttributeLocation,
   frameState,
 ) {
-  const positionAttribute = ModelUtility.getAttributeBySemantic(
+  const model = renderResources.model;
+  const shaderBuilder = renderResources.shaderBuilder;
+  const originalIndices = extractIndicesData(primitive);
+  const positionAttr = 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(positionAttr)) {
+    return;
+  }
+
+  const originalVertexCount = positionAttr.count;
+
+  if (!defined(originalIndices)) {
+    const barycentricValues = new Float32Array(originalVertexCount * 3);
+    for (let i = 0; i < originalVertexCount; i += 3) {
+      barycentricValues[i * 3] = 1.0;
+      barycentricValues[i * 3 + 1] = 0.0;
+      barycentricValues[i * 3 + 2] = 0.0;
 
-  if (defined(originalIndices)) {
-    const indexCount = indices.count;
-    const primitiveType = primitive.primitiveType;
+      barycentricValues[(i + 1) * 3] = 0.0;
+      barycentricValues[(i + 1) * 3 + 1] = 1.0;
+      barycentricValues[(i + 1) * 3 + 2] = 0.0;
 
-    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[(i + 2) * 3] = 0.0;
+      barycentricValues[(i + 2) * 3 + 1] = 0.0;
+      barycentricValues[(i + 2) * 3 + 2] = 1.0;
+    }
+
+    const barycentricBuffer = createVertexBuffer(barycentricValues, frameState, model);
 
-        barycentricValues[i0 * 3] = 1.0;
-        barycentricValues[i0 * 3 + 1] = 0.0;
-        barycentricValues[i0 * 3 + 2] = 0.0;
+    const barycentricAttribute = {
+      index: barycentricAttributeLocation,
+      vertexBuffer: barycentricBuffer,
+      count: originalVertexCount,
+      componentsPerAttribute: 3,
+      componentDatatype: ComponentDatatype.FLOAT,
+      offsetInBytes: 0,
+      strideInBytes: 0,
+      normalize: false,
+    };
+    renderResources.attributes.push(barycentricAttribute);
+    return;
+  }
 
-        barycentricValues[i1 * 3] = 0.0;
-        barycentricValues[i1 * 3 + 1] = 1.0;
-        barycentricValues[i1 * 3 + 2] = 0.0;
+  const primitiveType = primitive.primitiveType;
+  if (!PrimitiveType.isTriangles(primitiveType)) {
+    return;
+  }
 
-        barycentricValues[i2 * 3] = 0.0;
-        barycentricValues[i2 * 3 + 1] = 0.0;
-        barycentricValues[i2 * 3 + 2] = 1.0;
-      }
+  const newVertexCount = originalIndices.length;
+  const newAttributes = [];
+  const originalAttributes = primitive.attributes;
+
+  for (let i = 0; i < originalAttributes.length; i++) {
+    const attr = originalAttributes[i];
+    const semantic = attr.semantic;
+    const setIndex = attr.setIndex;
+
+    let attributeIndex;
+    if (semantic === VertexAttributeSemantic.POSITION) {
+      attributeIndex = shaderBuilder.attributeLocations.position;
+    } else if (semantic === VertexAttributeSemantic.NORMAL) {
+      attributeIndex = shaderBuilder.attributeLocations.normal;
+    } else if (semantic === VertexAttributeSemantic.TANGENT) {
+      attributeIndex = shaderBuilder.attributeLocations.tangent;
+    } else if (semantic === VertexAttributeSemantic.TEXCOORD) {
+      attributeIndex = shaderBuilder.attributeLocations["texCoord_" + setIndex];
+    } else if (semantic === VertexAttributeSemantic.COLOR) {
+      attributeIndex = shaderBuilder.attributeLocations["color_" + setIndex];
+    } else if (semantic === VertexAttributeSemantic.JOINTS) {
+      attributeIndex = shaderBuilder.attributeLocations["joints_" + setIndex];
+    } else if (semantic === VertexAttributeSemantic.WEIGHTS) {
+      attributeIndex = shaderBuilder.attributeLocations["weights_" + setIndex];
+    } else {
+      continue;
     }
-  } 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;
+
+    if (!defined(attributeIndex)) {
+      continue;
     }
+
+    const extracted = extractAttributeData(attr);
+    if (!defined(extracted)) {
+      continue;
+    }
+
+    const newData = deindexAttributeData(
+      extracted.data,
+      originalIndices,
+      extracted.componentsPerAttribute,
+      extracted.componentDatatype,
+    );
+
+    const newBuffer = createVertexBuffer(newData, frameState, model);
+
+    newAttributes.push({
+      index: attributeIndex,
+      vertexBuffer: newBuffer,
+      count: newVertexCount,
+      componentsPerAttribute: extracted.componentsPerAttribute,
+      componentDatatype: extracted.componentDatatype,
+      offsetInBytes: 0,
+      strideInBytes: 0,
+      normalize: extracted.normalized,
+    });
   }
 
-  const barycentricBuffer = Buffer.createVertexBuffer({
-    context: frameState.context,
-    typedArray: barycentricValues,
-    usage: BufferUsage.STATIC_DRAW,
-  });
+  const instanceAttributes = renderResources.attributes.filter(
+    function (attr) {
+      return attr.instanceDivisor === 1;
+    },
+  );
+  for (let i = 0; i < instanceAttributes.length; i++) {
+    newAttributes.push(instanceAttributes[i]);
+  }
 
-  const model = renderResources.model;
-  model._pipelineResources.push(barycentricBuffer);
+  const barycentricValues = new Float32Array(newVertexCount * 3);
+  for (let i = 0; i < newVertexCount; i += 3) {
+    barycentricValues[i * 3] = 1.0;
+    barycentricValues[i * 3 + 1] = 0.0;
+    barycentricValues[i * 3 + 2] = 0.0;
+
+    barycentricValues[(i + 1) * 3] = 0.0;
+    barycentricValues[(i + 1) * 3 + 1] = 1.0;
+    barycentricValues[(i + 1) * 3 + 2] = 0.0;
+
+    barycentricValues[(i + 2) * 3] = 0.0;
+    barycentricValues[(i + 2) * 3 + 1] = 0.0;
+    barycentricValues[(i + 2) * 3 + 2] = 1.0;
+  }
 
-  const barycentricAttribute = {
-    index: attributeLocation,
+  const barycentricBuffer = createVertexBuffer(barycentricValues, frameState, model);
+
+  newAttributes.push({
+    index: barycentricAttributeLocation,
     vertexBuffer: barycentricBuffer,
+    count: newVertexCount,
     componentsPerAttribute: 3,
     componentDatatype: ComponentDatatype.FLOAT,
     offsetInBytes: 0,
     strideInBytes: 0,
     normalize: false,
-  };
+  });
 
-  renderResources.attributes.push(barycentricAttribute);
+  renderResources.attributes = newAttributes;
+  renderResources.indices = undefined;
+  renderResources.count = newVertexCount;
+  renderResources.primitiveType = PrimitiveType.TRIANGLES;
+  renderResources.wireframeIndexBuffer = undefined;
 }
 
 export default BarycentricWireframePipelineStage;