@rtzh/engine 0.0.5 → 0.0.7

package/Source/Scene/Model/WireframePipelineStage.js

@@ -1,122 +1,122 @@
-import Buffer from "../../Renderer/Buffer.js";
-import BufferUsage from "../../Renderer/BufferUsage.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";
-import WireframeIndexGenerator from "../../Core/WireframeIndexGenerator.js";
-
-/**
- * The wireframe pipeline stage generates a new index buffer for rendering the
- * structure of the mesh with gl.LINES.
- *
- * @namespace WireframePipelineStage
- * @private
- */
-const WireframePipelineStage = {
-  name: "WireframePipelineStage", // Helps with debugging
-};
-
-/**
- * Process a primitive. This modifies the render resources as follows:
- * <ul>
- *   <li>Adds a define to the fragment shader to prevent extra shading of the lines.</li>
- *   <li>Adds a separate index buffer for wireframe indices</li>
- *   <li>Updates the primitive type and count for rendering with gl.LINES</li>
- * </ul>
- *
- * @param {PrimitiveRenderResources} renderResources The render resources for this node
- * @param {ModelComponents.primitive} primitive The primitive
- * @param {FrameState} frameState The frame state
- */
-WireframePipelineStage.process = function (
-  renderResources,
-  primitive,
-  frameState,
-) {
-  const model = renderResources.model;
-
-  if (model.debugWireframeMode === "barycentric") {
-    return;
-  }
-
-  // Applying normal mapping to the lines will result in rendering
-  // errors on Linux. This define is added to disable normal
-  // mapping in the shader.
-  const shaderBuilder = renderResources.shaderBuilder;
-  shaderBuilder.addDefine(
-    "HAS_WIREFRAME",
-    undefined,
-    ShaderDestination.FRAGMENT,
-  );
-  const wireframeIndexBuffer = createWireframeIndexBuffer(
-    primitive,
-    renderResources.indices,
-    frameState,
-  );
-  model._pipelineResources.push(wireframeIndexBuffer);
-  renderResources.wireframeIndexBuffer = wireframeIndexBuffer;
-
-  // We only need to count memory for the generated buffer. In WebGL 1, the CPU
-  // copy of the original indices is already counted in the geometry stage,
-  // and in WebGL 2, the CPU copy of the original indices (generated from the
-  // data of the original buffer) is discarded after generating the wireframe
-  // indices.
-  const hasCpuCopy = false;
-  model.statistics.addBuffer(wireframeIndexBuffer, hasCpuCopy);
-
-  // Update render resources so we render LINES with the correct index count
-  const originalPrimitiveType = renderResources.primitiveType;
-  const originalCount = renderResources.count;
-  renderResources.primitiveType = PrimitiveType.LINES;
-  renderResources.count = WireframeIndexGenerator.getWireframeIndicesCount(
-    originalPrimitiveType,
-    originalCount,
-  );
-};
-
-function createWireframeIndexBuffer(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;
-    }
-  }
-
-  const primitiveType = primitive.primitiveType;
-  const wireframeIndices = WireframeIndexGenerator.createWireframeIndices(
-    primitiveType,
-    vertexCount,
-    originalIndices,
-  );
-  const indexDatatype = IndexDatatype.fromSizeInBytes(
-    wireframeIndices.BYTES_PER_ELEMENT,
-  );
-
-  return Buffer.createIndexBuffer({
-    context: frameState.context,
-    typedArray: wireframeIndices,
-    usage: BufferUsage.STATIC_DRAW,
-    indexDatatype: indexDatatype,
-  });
-}
-
-export default WireframePipelineStage;
+import Buffer from "../../Renderer/Buffer.js";
+import BufferUsage from "../../Renderer/BufferUsage.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";
+import WireframeIndexGenerator from "../../Core/WireframeIndexGenerator.js";
+
+/**
+ * The wireframe pipeline stage generates a new index buffer for rendering the
+ * structure of the mesh with gl.LINES.
+ *
+ * @namespace WireframePipelineStage
+ * @private
+ */
+const WireframePipelineStage = {
+  name: "WireframePipelineStage", // Helps with debugging
+};
+
+/**
+ * Process a primitive. This modifies the render resources as follows:
+ * <ul>
+ *   <li>Adds a define to the fragment shader to prevent extra shading of the lines.</li>
+ *   <li>Adds a separate index buffer for wireframe indices</li>
+ *   <li>Updates the primitive type and count for rendering with gl.LINES</li>
+ * </ul>
+ *
+ * @param {PrimitiveRenderResources} renderResources The render resources for this node
+ * @param {ModelComponents.primitive} primitive The primitive
+ * @param {FrameState} frameState The frame state
+ */
+WireframePipelineStage.process = function (
+  renderResources,
+  primitive,
+  frameState,
+) {
+  const model = renderResources.model;
+
+  if (model.debugWireframeMode === "barycentric") {
+    return;
+  }
+
+  // Applying normal mapping to the lines will result in rendering
+  // errors on Linux. This define is added to disable normal
+  // mapping in the shader.
+  const shaderBuilder = renderResources.shaderBuilder;
+  shaderBuilder.addDefine(
+    "HAS_WIREFRAME",
+    undefined,
+    ShaderDestination.FRAGMENT,
+  );
+  const wireframeIndexBuffer = createWireframeIndexBuffer(
+    primitive,
+    renderResources.indices,
+    frameState,
+  );
+  model._pipelineResources.push(wireframeIndexBuffer);
+  renderResources.wireframeIndexBuffer = wireframeIndexBuffer;
+
+  // We only need to count memory for the generated buffer. In WebGL 1, the CPU
+  // copy of the original indices is already counted in the geometry stage,
+  // and in WebGL 2, the CPU copy of the original indices (generated from the
+  // data of the original buffer) is discarded after generating the wireframe
+  // indices.
+  const hasCpuCopy = false;
+  model.statistics.addBuffer(wireframeIndexBuffer, hasCpuCopy);
+
+  // Update render resources so we render LINES with the correct index count
+  const originalPrimitiveType = renderResources.primitiveType;
+  const originalCount = renderResources.count;
+  renderResources.primitiveType = PrimitiveType.LINES;
+  renderResources.count = WireframeIndexGenerator.getWireframeIndicesCount(
+    originalPrimitiveType,
+    originalCount,
+  );
+};
+
+function createWireframeIndexBuffer(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;
+    }
+  }
+
+  const primitiveType = primitive.primitiveType;
+  const wireframeIndices = WireframeIndexGenerator.createWireframeIndices(
+    primitiveType,
+    vertexCount,
+    originalIndices,
+  );
+  const indexDatatype = IndexDatatype.fromSizeInBytes(
+    wireframeIndices.BYTES_PER_ELEMENT,
+  );
+
+  return Buffer.createIndexBuffer({
+    context: frameState.context,
+    typedArray: wireframeIndices,
+    usage: BufferUsage.STATIC_DRAW,
+    indexDatatype: indexDatatype,
+  });
+}
+
+export default WireframePipelineStage;

package/Source/Shaders/Model/ModelFS.glsl

@@ -133,10 +133,46 @@ void main()
     vec3 a3 = smoothstep(vec3(0.0), d * u_wireframeWidth, v_barycentric);
     float edge = min(min(a3.x, a3.y), a3.z);
 
+    vec3 wireframeColor = u_wireframeColor.rgb;
+    float wireframeAlpha = u_wireframeColor.a;
+
+    #ifdef WIREFRAME_SCANLINE
+    float scanProgress = fract(u_wireframeTime * u_wireframeScanSpeed);
+    float scanCoord;
+    float scanRange;
+    if (u_wireframeScanAxis.z > 0.5) {
+      scanCoord = length(v_wireframeWorldPos);
+      scanRange = u_wireframeScanMax - u_wireframeScanMin;
+    } else if (u_wireframeScanAxis.y > 0.5) {
+      scanCoord = v_wireframeWorldPos.z;
+      scanRange = u_wireframeScanMax - u_wireframeScanMin;
+    } else {
+      scanCoord = v_wireframeWorldPos.x;
+      scanRange = u_wireframeScanMax - u_wireframeScanMin;
+    }
+    float scanPlanePos = u_wireframeScanMin + scanProgress * scanRange;
+    float scanDist = abs(scanCoord - scanPlanePos);
+    float scanWidth = max(scanRange * 0.015, 0.001);
+    float scanGlow = smoothstep(scanWidth, 0.0, scanDist);
+    vec3 scanlineHighlight = mix(wireframeColor, vec3(1.0), 0.6) * 1.5;
+    wireframeColor = mix(wireframeColor, scanlineHighlight, scanGlow);
+    #endif
+
+    float glowFactor = 0.0;
+    if (u_wireframeGlow > 0.0) {
+      vec3 glowA3 = smoothstep(vec3(0.0), d * u_wireframeWidth * (1.0 + u_wireframeGlow * 2.0), v_barycentric);
+      float glowEdge = min(min(glowA3.x, glowA3.y), glowA3.z);
+      glowFactor = (1.0 - glowEdge) * u_wireframeGlow;
+    }
+
     #ifdef WIREFRAME_OVERLAY
-    color.rgb = mix(u_wireframeColor.rgb, color.rgb, edge);
+    color.rgb = mix(wireframeColor, color.rgb, edge);
+    color.rgb += glowFactor * wireframeColor;
+    color.a *= u_wireframeFillAlpha;
     #else
-    color = mix(u_wireframeColor, color, edge);
+    color.rgb = mix(wireframeColor, color.rgb, edge);
+    color.rgb += glowFactor * wireframeColor;
+    color.a = mix(wireframeAlpha, color.a * u_wireframeFillAlpha, edge);
     #endif
     #endif
 

package/Source/Shaders/Model/ModelFS.js

@@ -133,11 +133,47 @@ void main()\n\
     vec3 d = fwidth(v_barycentric);\n\
     vec3 a3 = smoothstep(vec3(0.0), d * u_wireframeWidth, v_barycentric);\n\
     float edge = min(min(a3.x, a3.y), a3.z);\n\
+\n\
+    vec3 wireframeColor = u_wireframeColor.rgb;\n\
+    float wireframeAlpha = u_wireframeColor.a;\n\
+\n\
+    #ifdef WIREFRAME_SCANLINE\n\
+    float scanProgress = fract(u_wireframeTime * u_wireframeScanSpeed);\n\
+    float scanCoord;\n\
+    float scanRange;\n\
+    if (u_wireframeScanAxis.z > 0.5) {\n\
+      scanCoord = length(v_wireframeWorldPos);\n\
+      scanRange = u_wireframeScanMax - u_wireframeScanMin;\n\
+    } else if (u_wireframeScanAxis.y > 0.5) {\n\
+      scanCoord = v_wireframeWorldPos.z;\n\
+      scanRange = u_wireframeScanMax - u_wireframeScanMin;\n\
+    } else {\n\
+      scanCoord = v_wireframeWorldPos.x;\n\
+      scanRange = u_wireframeScanMax - u_wireframeScanMin;\n\
+    }\n\
+    float scanPlanePos = u_wireframeScanMin + scanProgress * scanRange;\n\
+    float scanDist = abs(scanCoord - scanPlanePos);\n\
+    float scanWidth = max(scanRange * 0.015, 0.001);\n\
+    float scanGlow = smoothstep(scanWidth, 0.0, scanDist);\n\
+    vec3 scanlineHighlight = mix(wireframeColor, vec3(1.0), 0.6) * 1.5;\n\
+    wireframeColor = mix(wireframeColor, scanlineHighlight, scanGlow);\n\
+    #endif\n\
+\n\
+    float glowFactor = 0.0;\n\
+    if (u_wireframeGlow > 0.0) {\n\
+      vec3 glowA3 = smoothstep(vec3(0.0), d * u_wireframeWidth * (1.0 + u_wireframeGlow * 2.0), v_barycentric);\n\
+      float glowEdge = min(min(glowA3.x, glowA3.y), glowA3.z);\n\
+      glowFactor = (1.0 - glowEdge) * u_wireframeGlow;\n\
+    }\n\
 \n\
     #ifdef WIREFRAME_OVERLAY\n\
-    color.rgb = mix(u_wireframeColor.rgb, color.rgb, edge);\n\
+    color.rgb = mix(wireframeColor, color.rgb, edge);\n\
+    color.rgb += glowFactor * wireframeColor;\n\
+    color.a *= u_wireframeFillAlpha;\n\
     #else\n\
-    color = mix(u_wireframeColor, color, edge);\n\
+    color.rgb = mix(wireframeColor, color.rgb, edge);\n\
+    color.rgb += glowFactor * wireframeColor;\n\
+    color.a = mix(wireframeAlpha, color.a * u_wireframeFillAlpha, edge);\n\
     #endif\n\
     #endif\n\
 \n\

package/Source/Shaders/Model/ModelVS.glsl

@@ -161,5 +161,8 @@ void main()
 
     #ifdef HAS_BARYCENTRIC_WIREFRAME
     v_barycentric = a_barycentric;
+    vec4 _wireframeWorldPos = czm_model * vec4(attributes.positionMC, 1.0);
+    v_wireframeWorldPos = _wireframeWorldPos.xyz;
+    v_wireframeLocalPos = attributes.positionMC;
     #endif
 }

package/Source/Shaders/Model/ModelVS.js

@@ -162,6 +162,9 @@ void main()\n\
 \n\
     #ifdef HAS_BARYCENTRIC_WIREFRAME\n\
     v_barycentric = a_barycentric;\n\
+    vec4 _wireframeWorldPos = czm_model * vec4(attributes.positionMC, 1.0);\n\
+    v_wireframeWorldPos = _wireframeWorldPos.xyz;\n\
+    v_wireframeLocalPos = attributes.positionMC;\n\
     #endif\n\
 }\n\
 ";