rename vHeight to vExcavateHeight and improve params of getWorldHeight/getCoordinateTexcoord

Author: fuzhenn

packages/reshader.gl/src/pbr/glsl/standard.vert

@@ -279,8 +279,8 @@ void main() {
         #endif
 
         #ifdef HAS_EXCAVATE_ANALYSIS
-          vCoordinateTexcoord = getCoordinateTexcoord();
-          vHeight = getWorldHeight();
+          vCoordinateTexcoord = getCoordinateTexcoord(position);
+          vExcavateHeight = getWorldHeight(position);
         #endif
     //#ifdef PICKING_MODE的endif
     #endif

packages/reshader.gl/src/pbr/wgsl/standard_frag.wgsl

@@ -185,10 +185,6 @@ struct VertexOutput {
         @location($i) vTangentFragPos: vec3f,
     #endif
 
-    #ifdef HAS_EXCAVATE_ANALYSIS
-        @location($i) vCoordinateTexcoord: vec2f,
-        @location($i) vHeight: f32,
-    #endif
 };
 
 fn getMaterialAlbedo() -> vec3f {

packages/reshader.gl/src/pbr/wgsl/standard_vert.wgsl

@@ -98,11 +98,6 @@ struct VertexOutput {
         @location($o) vTangentViewPos: vec3f,
         @location($o) vTangentFragPos: vec3f,
     #endif
-
-    #ifdef HAS_EXCAVATE_ANALYSIS
-        @location($o) vCoordinateTexcoord: vec2f,
-        @location($o) vHeight: f32,
-    #endif
 };
 
 struct ShaderUniforms {
@@ -195,7 +190,7 @@ fn transposeMat3(inMat: mat3x3f) -> mat3x3f {
 fn main(input: VertexInput) -> VertexOutput {
     var output: VertexOutput;
 
-    let localPositionMatrix = getPositionMatrix(output, uniforms.positionMatrix);
+    let localPositionMatrix = getPositionMatrix(input, output, uniforms.positionMatrix);
 
     #ifdef IS_LINE_EXTRUSION
         let linePosition = getLineExtrudePosition(vec3f(input.aPosition.xyz), input);
@@ -309,8 +304,8 @@ fn main(input: VertexInput) -> VertexOutput {
         #endif
 
         #ifdef HAS_EXCAVATE_ANALYSIS
-            output.vCoordinateTexcoord = getCoordinateTexcoord();
-            output.vHeight = getWorldHeight();
+            output.vCoordinateTexcoord = getCoordinateTexcoord(position, uniforms.modelMatrix);
+            output.vExcavateHeight = getWorldHeight(position, uniforms.modelMatrix);
         #endif
     #endif
 

packages/reshader.gl/src/shader/wgsl/phong_vert.wgsl

@@ -121,7 +121,7 @@ fn main(vertexInput: VertexInput) -> VertexOutput {
 #else
     let localPosition = getPosition(vec3f(vertexInput.aPosition.xyz), vertexInput);
 #endif
-    let localPositionMatrix = getPositionMatrix(vertexOutput, modelUniforms.positionMatrix);
+    let localPositionMatrix = getPositionMatrix(vertexInput, vertexOutput, modelUniforms.positionMatrix);
 
     vertexOutput.vFragPos = (modelUniforms.modelMatrix * localPositionMatrix * localPosition).xyz;
 

packages/reshader.gl/src/shaderlib/glsl/excavate.frag

@@ -2,7 +2,7 @@
   uniform sampler2D heightmap;
   uniform float excavateHeight;
   varying vec2 vCoordinateTexcoord;
-  varying float vHeight;
+  varying float vExcavateHeight;
   const vec2 range = vec2(-100.0, 1000.0);
   float decodeHeight(const in vec4 pack) {
       return pack.r + pack.g / 255.0;
@@ -14,7 +14,7 @@
       if(realHeight < range.x || realHeight > range.y) {
           realHeight = 0.0;
       }
-      if(vHeight > realHeight) {
+      if(vExcavateHeight > realHeight) {
           discard;
       }
       return fragColor;

packages/reshader.gl/src/shaderlib/glsl/excavate.vert

@@ -1,16 +1,15 @@
 #ifdef HAS_EXCAVATE_ANALYSIS
   uniform vec4 excavateExtent;
   varying vec2 vCoordinateTexcoord;
-  varying float vHeight;
+  varying float vExcavateHeight;
 
-  float getWorldHeight() {
-    vec4 wPosition = modelMatrix * getPosition(aPosition);
+  float getWorldHeight(vec4 localPosition) {
+    vec4 wPosition = modelMatrix * localPosition;
     return wPosition.z;
   }
 
-  vec2 getCoordinateTexcoord() {
-    mat4 localPositionMatrix = getPositionMatrix();
-    vec4 wPosition = modelMatrix * localPositionMatrix * getPosition(aPosition);
+  vec2 getCoordinateTexcoord(vec4 localPosition) {
+    vec4 wPosition = modelMatrix * localPosition;
     float x = (wPosition.x - excavateExtent.x) / (excavateExtent.z - excavateExtent.x);
     float y = (wPosition.y - excavateExtent.y) / (excavateExtent.w - excavateExtent.y);
     return vec2(x, y);

packages/reshader.gl/src/shaderlib/glsl/output.vert

@@ -38,13 +38,13 @@
 attribute float aTerrainAltitude;
 #endif
 
-mat4 getPositionMatrix() {
+mat4 getPositionMatrix(input: VertexInput) {
     mat4 worldMatrix;
     #ifdef HAS_INSTANCE
         #ifdef HAS_INSTANCE_COLOR
             vInstanceColor = instance_getInstanceColor();
         #endif
-        mat4 attributeMatrix = instance_getAttributeMatrix();
+        mat4 attributeMatrix = instance_getAttributeMatrix(input);
         #ifdef HAS_SKIN
             if (skinAnimation == 1) {
                 worldMatrix = attributeMatrix * positionMatrix * skin_getSkinMatrix();

packages/reshader.gl/src/shaderlib/wgsl/excavate.ts

@@ -6,24 +6,13 @@ struct ExcavateUniforms {
 
 @group(0) @binding($b) var<uniform> excavateUniforms: ExcavateUniforms;
 
-struct VertexAttributes {
-    @location(0) aPosition: vec3f
-};
-
-struct VertexOutput {
-    @builtin(position) position: vec4f,
-    vCoordinateTexcoord: vec2f,
-    vHeight: f32
-};
-
-fn getWorldHeight(vertex: VertexInput) -> f32 {
-    let wPosition = uniforms.modelMatrix * getPosition(vertex.aPosition);
+fn getWorldHeight(localPosition: vec4f, modelMatrix: mat4x4f) -> f32 {
+    let wPosition = uniforms.modelMatrix * localPosition;
     return wPosition.z;
 }
 
-fn getCoordinateTexcoord(vertex: VertexInput) -> vec2f {
-    let localPositionMatrix = getPositionMatrix();
-    let wPosition = uniforms.modelMatrix * localPositionMatrix * getPosition(vertex.aPosition);
+fn getCoordinateTexcoord(localPosition: vec4f, modelMatrix: mat4x4f) -> vec2f {
+    let wPosition = modelMatrix * localPositionMatrix;
     let x = (wPosition.x - excavateUniforms.excavateExtent.x) /
            (excavateUniforms.excavateExtent.z - excavateUniforms.excavateExtent.x);
     let y = (wPosition.y - excavateUniforms.excavateExtent.y) /
@@ -60,7 +49,7 @@ fn excavateColor(fragColor: vec4f, vertexOutput: VertexOutput) -> vec4f {
         realHeight >= excavateUniforms.heightRange.x && realHeight <= excavateUniforms.heightRange.y
     );
 
-    if (vertexOutput.vHeight > validHeight) {
+    if (vertexOutput.vExcavateHeight > validHeight) {
         discard;
     }
     return fragColor;
@@ -78,7 +67,7 @@ export default {
             type: 'vec2f'
         },
         {
-            name: 'vHeight',
+            name: 'vExcavateHeight',
             type: 'f32'
         }
     ]

packages/reshader.gl/src/shaderlib/wgsl/instance.ts

@@ -2,12 +2,17 @@ const vert = /* wgsl */`
 @group(0) @binding($b) var<uniform> terrainAltitudeScale: f32;
 
 // 获取实例属性矩阵函数
-fn instance_getAttributeMatrix(instance_vectorA: vec4f, instance_vectorB: vec4f, instance_vectorC: vec4f) -> mat4x4f {
+fn instance_getAttributeMatrix(
+    input: VertexInput
+) -> mat4x4f {
+    let vectorA = input.instance_vectorA;
+    let vectorB = input.instance_vectorB;
+    let vectorC = input.instance_vectorC;
     var mat = mat4x4f(
-        instance_vectorA.x, instance_vectorB.x, instance_vectorC.x, 0.0,
-        instance_vectorA.y, instance_vectorB.y, instance_vectorC.y, 0.0,
-        instance_vectorA.z, instance_vectorB.z, instance_vectorC.z, 0.0,
-        instance_vectorA.w, instance_vectorB.w, instance_vectorC.w, 1.0
+        vectorA.x, vectorB.x, vectorC.x, 0.0,
+        vectorA.y, vectorB.y, vectorC.y, 0.0,
+        vectorA.z, vectorB.z, vectorC.z, 0.0,
+        vectorA.w, vectorB.w, vectorC.w, 1.0
     );
 
 #ifdef HAS_INSTANCE_TERRAIN_ALTITUDE

packages/reshader.gl/src/shaderlib/wgsl/output.ts

@@ -31,10 +31,10 @@ const vert = /* wgsl */`
     @group(0) @binding($b) var<uniform> altitudeUniforms: AltitudeUniforms;
 #endif
 
-fn getPositionMatrix(vertexOutput: VertexOutput, positionMatrix: mat4x4f) -> mat4x4f {
+fn getPositionMatrix(input: VertexInput, vertexOutput: VertexOutput, positionMatrix: mat4x4f) -> mat4x4f {
     var worldMatrix: mat4x4f;
 #ifdef HAS_INSTANCE
-    let attributeMatrix = instance_getAttributeMatrix();
+    let attributeMatrix = instance_getAttributeMatrix(input);
     #ifdef HAS_INSTANCE_COLOR
         vertexOutput.vInstanceColor = instance_getInstanceColor();
     #endif