@zephyr3d/scene 0.1.2 → 0.3.0

package/dist/shaders/misc.js

@@ -1,130 +1,5 @@
 import { PBPrimitiveType, PBInsideFunctionScope } from '@zephyr3d/device';
-import { ShaderFramework } from './framework.js';
 
-/**
- * Calculates the TBN matrix
- *
- * @remarks
- * This function computes the tangent frame for normal mapping without world normal
- *
- * @param scope - Current shader scope
- * @param worldPosition - World position of current fragment
- * @param uv - Texture coordinate for normal map
- * @returns The calculated TBN matrix
- *
- * @public
- */ function calculateTBN(scope, worldPosition, uv, doubleSideLighting) {
-    const funcName = 'lib_calculateTBN';
-    const pb = scope.$builder;
-    pb.func(funcName, [
-        pb.vec3('posW'),
-        pb.vec2('uv')
-    ], function() {
-        this.$l.uv_dx = pb.dpdx(pb.vec3(this.uv, 0));
-        this.$l.uv_dy = pb.dpdy(pb.vec3(this.uv, 0));
-        this.$if(pb.lessThanEqual(pb.add(pb.length(this.uv_dx), pb.length(this.uv_dy)), 0.000001), function() {
-            this.uv_dx = pb.vec3(1, 0, 0);
-            this.uv_dy = pb.vec3(0, 1, 0);
-        });
-        this.$l.t_ = pb.div(pb.sub(pb.mul(pb.dpdx(this.posW), this.uv_dy.y), pb.mul(pb.dpdy(this.posW), this.uv_dx.y)), pb.sub(pb.mul(this.uv_dx.x, this.uv_dy.y), pb.mul(this.uv_dx.y, this.uv_dy.x)));
-        this.$l.ng = pb.normalize(pb.cross(pb.dpdx(this.posW), pb.dpdy(this.posW)));
-        this.$l.t = pb.normalize(pb.sub(this.t_, pb.mul(this.ng, pb.dot(this.ng, this.t_))));
-        this.$l.b = pb.cross(this.ng, this.t);
-        if (doubleSideLighting) {
-            this.$if(pb.not(this.$builtins.frontFacing), function() {
-                this.t = pb.mul(this.t, -1);
-                this.b = pb.mul(this.b, -1);
-                this.ng = pb.mul(this.ng, -1);
-            });
-        }
-        this.$return(pb.mat3(this.t, this.b, this.ng));
-    });
-    return pb.getGlobalScope()[funcName](worldPosition.xyz, uv);
-}
-/**
- * Calculates the TBN matrix
- *
- * @remarks
- * This function computes the tangent frame for normal mapping with world normal
- *
- * @param scope - Current shader scope
- * @param worldPosition - World position of current fragment
- * @param worldNormal - World normal of current fragment
- * @param uv - Texture coordinate for normal map
- * @returns The calculated TBN matrix
- *
- * @public
- */ function calculateTBNWithNormal(scope, worldPosition, worldNormal, uv, doubleSideLighting) {
-    const funcName = 'lib_calculateTBNWithNormal';
-    const pb = scope.$builder;
-    pb.func(funcName, [
-        pb.vec3('posW'),
-        pb.vec3('normalW'),
-        pb.vec2('uv')
-    ], function() {
-        this.$l.uv_dx = pb.dpdx(pb.vec3(this.uv, 0));
-        this.$l.uv_dy = pb.dpdy(pb.vec3(this.uv, 0));
-        this.$if(pb.lessThanEqual(pb.add(pb.length(this.uv_dx), pb.length(this.uv_dy)), 0.000001), function() {
-            this.uv_dx = pb.vec3(1, 0, 0);
-            this.uv_dy = pb.vec3(0, 1, 0);
-        });
-        this.$l.t_ = pb.div(pb.sub(pb.mul(pb.dpdx(this.posW), this.uv_dy.y), pb.mul(pb.dpdy(this.posW), this.uv_dx.y)), pb.sub(pb.mul(this.uv_dx.x, this.uv_dy.y), pb.mul(this.uv_dx.y, this.uv_dy.x)));
-        this.$l.ng = pb.normalize(this.normalW);
-        this.$l.t = pb.normalize(pb.sub(this.t_, pb.mul(this.ng, pb.dot(this.ng, this.t_))));
-        this.$l.b = pb.cross(this.ng, this.t);
-        if (doubleSideLighting) {
-            this.$if(pb.not(this.$builtins.frontFacing), function() {
-                this.t = pb.mul(this.t, -1);
-                this.b = pb.mul(this.b, -1);
-                this.ng = pb.mul(this.ng, -1);
-            });
-        }
-        this.$return(pb.mat3(this.t, this.b, this.ng));
-    });
-    return pb.getGlobalScope()[funcName](worldPosition, worldNormal, uv);
-}
-/**
- * Calculates the non-linear depth from linear depth
- *
- * @param scope - Current shader scope
- * @param depth - The linear depth
- * @param nearFar - A vector that contains the near clip plane in x component and the far clip plane in y component
- * @returns The calculated non-linear depth
- *
- * @public
- */ function linearDepthToNonLinear(scope, depth, nearFar) {
-    const pb = scope.$builder;
-    nearFar = nearFar || ShaderFramework.getCameraParams(scope);
-    return pb.div(pb.sub(nearFar.y, pb.div(pb.mul(nearFar.x, nearFar.y), depth)), pb.sub(nearFar.y, nearFar.x));
-}
-/**
- * Calculates the linear depth from non-linear depth
- *
- * @param scope - Current shader scope
- * @param depth - The non-linear depth
- * @param nearFar - A vector that contains the near clip plane in x component and the far clip plane in y component
- * @returns The calculated linear depth
- *
- * @public
- */ function nonLinearDepthToLinear(scope, depth, nearFar) {
-    const pb = scope.$builder;
-    nearFar = nearFar || ShaderFramework.getCameraParams(scope);
-    return pb.div(pb.mul(nearFar.x, nearFar.y), pb.mix(nearFar.y, nearFar.x, depth));
-}
-/**
- * Calculates the normalized linear depth from non-linear depth
- *
- * @param scope - Current shader scope
- * @param depth - The non-linear depth
- * @param nearFar - A vector that contains the near clip plane in x component and the far clip plane in y component
- * @returns The calculated normalized linear depth
- *
- * @public
- */ function nonLinearDepthToLinearNormalized(scope, depth, nearFar) {
-    const pb = scope.$builder;
-    nearFar = nearFar || ShaderFramework.getCameraParams(scope);
-    return pb.div(nearFar.x, pb.mix(nearFar.y, nearFar.x, depth));
-}
 /**
  * Decodes a float that was encoded into a rgba8unorm
  *
@@ -141,7 +16,7 @@ import { ShaderFramework } from './framework.js';
     if (!scope || !(scope instanceof PBInsideFunctionScope)) {
         throw new Error('decodeFloatFromRGBA() failed: decodeNormalizedFloatFromRGBA() must be called inside a function');
     }
-    const funcName = 'lib_DecodeFloatFromRGBA';
+    const funcName = 'Z_DecodeFloatFromRGBA';
     pb.func(funcName, [
         pb.vec4('value')
     ], function() {
@@ -173,7 +48,7 @@ import { ShaderFramework } from './framework.js';
  * @public
  */ function encodeFloatToRGBA(scope, value) {
     const pb = scope.$builder;
-    const funcName = 'lib_EncodeFloatToRGBA';
+    const funcName = 'Z_EncodeFloatToRGBA';
     pb.func(funcName, [
         pb.float('value')
     ], function() {
@@ -204,8 +79,8 @@ import { ShaderFramework } from './framework.js';
         this.pack.x = pb.add(this.pack.x, pb.floor(pb.div(this.expbias, 2.0)));
         this.expbias = pb.sub(this.expbias, pb.mul(this.pack.x, 2.0));
         this.pack.y = pb.add(this.pack.y, pb.mul(pb.floor(this.expbias), 128.0));
-        this.pack.x = pb.add(this.pack.x, pb.mul(128.0, pb.float(pb.lessThan(this.value, 0.)))); // Sign
-        this.$return(pb.div(pb.floor(pb.add(this.pack, pb.vec4(.5))), 255.0));
+        this.pack.x = pb.add(this.pack.x, pb.mul(128.0, pb.float(pb.lessThan(this.value, 0)))); // Sign
+        this.$return(pb.div(pb.floor(pb.add(this.pack, pb.vec4(0.5))), 255.0));
     });
     return pb.getGlobalScope()[funcName](value);
 }
@@ -225,7 +100,7 @@ import { ShaderFramework } from './framework.js';
     if (!scope || !(scope instanceof PBInsideFunctionScope)) {
         throw new Error('decodeNormalizedFloatFromRGBA() failed: decodeNormalizedFloatFromRGBA() must be called inside a function');
     }
-    const funcName = 'lib_DecodeNormalizedFloatFromRGBA';
+    const funcName = 'Z_decodeNormalizedFloatFromRGBA';
     pb.func(funcName, [
         pb.vec4('value')
     ], function() {
@@ -244,7 +119,7 @@ import { ShaderFramework } from './framework.js';
  * @public
  */ function encodeNormalizedFloatToRGBA(scope, value) {
     const pb = scope.$builder;
-    const funcName = 'lib_EncodeNormalizedFloatToRGBA';
+    const funcName = 'Z_encodeNormalizedFloatToRGBA';
     pb.func(funcName, [
         pb.float('value')
     ], function() {
@@ -266,7 +141,7 @@ import { ShaderFramework } from './framework.js';
  * @public
  */ function encode2HalfToRGBA(scope, a, b) {
     const pb = scope.$builder;
-    const funcName = 'lib_Encode2HalfToRGBA';
+    const funcName = 'Z_encode2HalfToRGBA';
     pb.func(funcName, [
         pb.float('a'),
         pb.float('b')
@@ -286,7 +161,7 @@ import { ShaderFramework } from './framework.js';
  * @public
  */ function decode2HalfFromRGBA(scope, value) {
     const pb = scope.$builder;
-    const funcName = 'lib_Decode2HalfFromRGBA';
+    const funcName = 'Z_decode2HalfFromRGBA';
     pb.func(funcName, [
         pb.vec4('value')
     ], function() {
@@ -294,29 +169,6 @@ import { ShaderFramework } from './framework.js';
     });
     return pb.getGlobalScope()[funcName](value);
 }
-/**
- * Transform color to sRGB color space if nessesary
- *
- * @param scope - Current shader scope
- * @param outputColor - The color to be transformed
- * @returns The transformed color
- *
- * @public
- */ function encodeColorOutput(scope, outputColor) {
-    const pb = scope.$builder;
-    const funcName = 'lib_EncodeColorOutput';
-    pb.func(funcName, [
-        pb.vec4('outputColor')
-    ], function() {
-        const params = ShaderFramework.getCameraParams(this);
-        this.$if(pb.notEqual(params.w, 0), function() {
-            this.$return(pb.vec4(linearToGamma(this, this.outputColor.rgb), this.outputColor.w));
-        }).$else(function() {
-            this.$return(this.outputColor);
-        });
-    });
-    return pb.getGlobalScope()[funcName](outputColor);
-}
 /**
  * Encodes a color value into RGBM format
  *
@@ -328,7 +180,7 @@ import { ShaderFramework } from './framework.js';
  * @public
  */ function encodeRGBM(scope, rgb, maxRange) {
     const pb = scope.$builder;
-    const funcName = 'lib_encodeRGBM';
+    const funcName = 'Z_encodeRGBM';
     pb.func(funcName, [
         pb.vec3('rgb'),
         pb.float('range')
@@ -351,7 +203,7 @@ import { ShaderFramework } from './framework.js';
  * @public
  */ function decodeRGBM(scope, rgbm, maxRange) {
     const pb = scope.$builder;
-    const funcName = 'lib_decodeRGBM';
+    const funcName = 'Z_decodeRGBM';
     pb.func(funcName, [
         pb.vec4('rgbm'),
         pb.float('range')
@@ -370,7 +222,7 @@ import { ShaderFramework } from './framework.js';
  * @public
  */ function gammaToLinear(scope, color) {
     const pb = scope.$builder;
-    const funcName = 'lib_gammaToLinear';
+    const funcName = 'Z_gammaToLinear';
     pb.func(funcName, [
         pb.vec3('color')
     ], function() {
@@ -390,7 +242,7 @@ import { ShaderFramework } from './framework.js';
  * @public
  */ function linearToGamma(scope, color) {
     const pb = scope.$builder;
-    const funcName = 'lib_linearToGamma';
+    const funcName = 'Z_linearToGamma';
     pb.func(funcName, [
         pb.vec3('color')
     ], function() {
@@ -401,5 +253,5 @@ import { ShaderFramework } from './framework.js';
     return pb.getGlobalScope()[funcName](color);
 }
 
-export { calculateTBN, calculateTBNWithNormal, decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, encode2HalfToRGBA, encodeColorOutput, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, gammaToLinear, linearDepthToNonLinear, linearToGamma, nonLinearDepthToLinear, nonLinearDepthToLinearNormalized };
+export { decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, gammaToLinear, linearToGamma };
 //# sourceMappingURL=misc.js.map

package/dist/shaders/misc.js.map

@@ -1 +1 @@
-{"version":3,"file":"misc.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"misc.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/shaders/noise.js

@@ -8,8 +8,8 @@
  * @public
  */ function noisef(scope, p) {
     const pb = scope.$builder;
-    const funcNameHash = 'lib_hashf';
-    const funcNameNoise = 'lib_noisef';
+    const funcNameHash = 'Z_hashf';
+    const funcNameNoise = 'Z_noisef';
     pb.func(funcNameHash, [
         pb.vec2('p')
     ], function() {
@@ -42,7 +42,7 @@
  * @public
  */ function worleyNoise(scope, uv, freq) {
     const pb = scope.$builder;
-    const funcNameHash = 'lib_worleyHash';
+    const funcNameHash = 'Z_worleyHash';
     // https://www.shadertoy.com/view/4sc3z2
     pb.func(funcNameHash, [
         pb.vec3('p')
@@ -54,7 +54,7 @@
             this.$return(pb.sub(pb.mul(pb.fract(pb.vec3(pb.mul(pb.add(this.p3.x, this.p3.y), this.p3.z), pb.mul(pb.add(this.p3.x, this.p3.z), this.p3.y), pb.mul(pb.add(this.p3.y, this.p3.z), this.p3.x))), 2), 1));
         }
     });
-    const funcNameNoise = 'lib_worleyNoise';
+    const funcNameNoise = 'Z_worleyNoise';
     pb.func(funcNameNoise, [
         pb.vec3('uv'),
         pb.float('freq')
@@ -90,7 +90,7 @@
  * @public
  */ function worleyFBM(scope, p, freq) {
     const pb = scope.$builder;
-    const funcName = 'lib_worleyFBM';
+    const funcName = 'Z_worleyFBM';
     pb.func(funcName, [
         pb.vec3('p'),
         pb.float('freq')
@@ -113,7 +113,7 @@
  * @public
  */ function noise3D(scope, p) {
     const pb = scope.$builder;
-    const funcName = 'lib_noise3d';
+    const funcName = 'Z_noise3d';
     pb.func(funcName, [
         pb.vec3('p')
     ], function() {
@@ -133,7 +133,7 @@
  * @public
  */ function smoothNoise3D(scope, p) {
     const pb = scope.$builder;
-    const funcName = 'lib_smoothNoise3D';
+    const funcName = 'Z_smoothNoise3D';
     pb.func(funcName, [
         pb.vec3('p')
     ], function() {

package/dist/shaders/pbr.js

@@ -46,87 +46,6 @@
     });
     return pb.getGlobalScope()[funcName](NdotV, NdotL, alphaRoughness);
 }
-/** @internal */ function D_Charlie(scope, NdotH, sheenRoughness) {
-    const funcNameDCharlie = 'lib_DCharlie';
-    const pb = scope.$builder;
-    pb.func(funcNameDCharlie, [
-        pb.float('NdotH'),
-        pb.float('sheenRoughness')
-    ], function() {
-        this.$l.alphaG = pb.mul(this.sheenRoughness, this.sheenRoughness);
-        this.$l.invR = pb.div(1, this.alphaG);
-        this.$l.cos2h = pb.mul(this.NdotH, this.NdotH);
-        this.$l.sin2h = pb.max(pb.sub(1, this.cos2h), 0.0078125);
-        this.$return(pb.div(pb.mul(pb.add(this.invR, 2), pb.pow(this.sin2h, pb.mul(this.invR, 0.5))), 2 * Math.PI));
-    });
-    return pb.getGlobalScope()[funcNameDCharlie](NdotH, sheenRoughness);
-}
-/** @internal */ function V_Ashikhmin(scope, NdotL, NdotV) {
-    const funcNameVAshikhmin = 'lib_VAshikhmin';
-    const pb = scope.$builder;
-    pb.func(funcNameVAshikhmin, [
-        pb.float('NdotL'),
-        pb.float('NdotV')
-    ], function() {
-        this.$return(pb.clamp(pb.div(1, pb.mul(pb.sub(pb.add(this.NdotL, this.NdotV), pb.mul(this.NdotL, this.NdotV)), 4)), 0, 1));
-    });
-    return pb.getGlobalScope()[funcNameVAshikhmin](NdotL, NdotV);
-}
-/** @internal */ function directClearcoatLighting(scope, NdotV, NdotH, NdotL, F, clearcoatRoughness) {
-    const pb = scope.$builder;
-    const funcName = 'pbrDirectClearcoatLighting';
-    pb.func(funcName, [
-        pb.float('NdotV'),
-        pb.float('NdotH'),
-        pb.float('NdotL'),
-        pb.vec3('F'),
-        pb.float('clearcoatRoughness')
-    ], function() {
-        this.$l.ccRoughness = pb.mul(this.clearcoatRoughness, this.clearcoatRoughness);
-        this.$l.ccD = distributionGGX(this, this.NdotH, this.ccRoughness);
-        this.$l.ccV = visGGX(this, this.NdotV, this.NdotL, this.ccRoughness);
-        this.$return(pb.mul(this.ccD, this.ccV, this.F));
-    });
-    return pb.getGlobalScope()[funcName](NdotV, NdotH, NdotL, F, clearcoatRoughness);
-}
-/** @internal */ function directSheenLighting(scope, NdotV, NdotL, NdotH, sheenColor, sheenRoughness) {
-    const pb = scope.$builder;
-    const funcName = 'pbrDirectSheenLighting';
-    pb.func(funcName, [
-        pb.float('NdotV'),
-        pb.float('NdotL'),
-        pb.float('NdotH'),
-        pb.vec3('sheenColor'),
-        pb.float('sheenRoughness')
-    ], function() {
-        this.$l.D = D_Charlie(this, this.NdotH, this.sheenRoughness);
-        this.$l.V = V_Ashikhmin(this, this.NdotL, this.NdotV);
-        this.$return(pb.mul(this.sheenColor, this.D, this.V));
-    });
-    return pb.getGlobalScope()[funcName](NdotV, NdotL, NdotH, sheenColor, sheenRoughness);
-}
-/** @internal */ function directLighting(scope, diffuse, NdotV, NdotH, NdotL, F, roughness, specularWeight, outSpecular, outDiffuse) {
-    const pb = scope.$builder;
-    const funcName = 'pbrDirectLighting';
-    pb.func(funcName, [
-        pb.vec3('diffuse'),
-        pb.float('NdotV'),
-        pb.float('NdotH'),
-        pb.float('NdotL'),
-        pb.vec3('F'),
-        pb.float('roughness'),
-        pb.float('specularWeight'),
-        pb.vec3('outSpecular').out(),
-        pb.vec3('outDiffuse').out()
-    ], function() {
-        this.$l.alphaRoughness = pb.mul(this.roughness, this.roughness);
-        this.$l.D = distributionGGX(this, this.NdotH, this.alphaRoughness);
-        this.$l.V = visGGX(this, this.NdotV, this.NdotL, this.alphaRoughness);
-        this.outSpecular = pb.mul(this.D, this.V, this.F, this.specularWeight);
-        this.outDiffuse = pb.mul(pb.sub(pb.vec3(1), pb.mul(this.F, this.specularWeight)), pb.div(this.diffuse, Math.PI));
-    });
-    pb.getGlobalScope()[funcName](diffuse, NdotV, NdotH, NdotL, F, roughness, specularWeight, outSpecular, outDiffuse);
-}
 
-export { D_Charlie, V_Ashikhmin, directClearcoatLighting, directLighting, directSheenLighting, distributionGGX, fresnelSchlick, visGGX };
+export { distributionGGX, fresnelSchlick, visGGX };
 //# sourceMappingURL=pbr.js.map

package/dist/shaders/pbr.js.map

@@ -1 +1 @@
-{"version":3,"file":"pbr.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"pbr.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/shaders/shadow.js

@@ -1,8 +1,8 @@
 import { hasDepthChannel } from '@zephyr3d/device';
 import { Application } from '../app.js';
 import { LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT } from '../values.js';
-import { ShaderFramework } from './framework.js';
-import { encodeNormalizedFloatToRGBA, decode2HalfFromRGBA, decodeNormalizedFloatFromRGBA, nonLinearDepthToLinearNormalized } from './misc.js';
+import { encodeNormalizedFloatToRGBA, decode2HalfFromRGBA, decodeNormalizedFloatFromRGBA } from './misc.js';
+import { ShaderHelper } from '../material/shader/helper.js';
 
 /*
   const PCF_KERNEL_3x3 = [
@@ -303,34 +303,36 @@ import { encodeNormalizedFloatToRGBA, decode2HalfFromRGBA, decodeNormalizedFloat
     ]
 ];
 function getShadowMapTexelSize(scope) {
-    return scope.$builder.div(1, ShaderFramework.getShadowCameraParams(scope).z);
+    return scope.$builder.div(1, ShaderHelper.getShadowCameraParams(scope).z);
 }
 function getShadowMapSize(scope) {
-    return ShaderFramework.getShadowCameraParams(scope).z;
+    return ShaderHelper.getShadowCameraParams(scope).z;
 }
-/** @internal */ function computeShadowMapDepth(scope, targetFormat) {
-    const funcNameComputeShadowMapDepth = 'lib_computeShadowMapDepth';
+/** @internal */ function computeShadowMapDepth(scope, worldPos, targetFormat) {
+    const funcNameComputeShadowMapDepth = 'Z_computeShadowMapDepth';
     const pb = scope.$builder;
-    pb.func(funcNameComputeShadowMapDepth, [], function() {
+    pb.func(funcNameComputeShadowMapDepth, [
+        pb.vec3('worldPos')
+    ], function() {
         if (hasDepthChannel(targetFormat)) {
             // use native shadowmap
             this.$return(pb.vec4(pb.emulateDepthClamp ? pb.clamp(scope.$inputs.clamppedDepth, 0, 1) : scope.$builtins.fragCoord.z, 0, 0, 1));
         } else {
             this.$l.depth = pb.float();
-            this.$l.lightType = ShaderFramework.getLightTypeForShadow(this);
+            this.$l.lightType = ShaderHelper.getLightTypeForShadow(this);
             this.$if(pb.equal(this.lightType, LIGHT_TYPE_DIRECTIONAL), function() {
                 this.depth = pb.emulateDepthClamp ? pb.clamp(this.$inputs.clamppedDepth, 0, 1) : this.$builtins.fragCoord.z;
             }).$elseif(pb.equal(this.lightType, LIGHT_TYPE_POINT), function() {
-                this.$l.lightSpacePos = pb.mul(ShaderFramework.getLightViewMatrixForShadow(this), ShaderFramework.getWorldPosition(this));
-                this.depth = pb.clamp(pb.div(pb.length(this.lightSpacePos.xyz), ShaderFramework.getLightPositionAndRangeForShadow(this).w), 0, 1);
+                this.$l.lightSpacePos = pb.mul(ShaderHelper.getLightViewMatrixForShadow(this), pb.vec4(this.worldPos, 1));
+                this.depth = pb.clamp(pb.div(pb.length(this.lightSpacePos.xyz), ShaderHelper.getLightPositionAndRangeForShadow(this).w), 0, 1);
             }).$else(function() {
-                this.$l.lightSpacePos = pb.mul(ShaderFramework.getLightViewMatrixForShadow(this), ShaderFramework.getWorldPosition(this));
-                this.depth = pb.clamp(pb.div(pb.neg(this.lightSpacePos.z), ShaderFramework.getLightPositionAndRangeForShadow(this).w), 0, 1);
+                this.$l.lightSpacePos = pb.mul(ShaderHelper.getLightViewMatrixForShadow(this), pb.vec4(this.worldPos, 1));
+                this.depth = pb.clamp(pb.div(pb.neg(this.lightSpacePos.z), ShaderHelper.getLightPositionAndRangeForShadow(this).w), 0, 1);
             });
             this.$return(targetFormat === 'rgba8unorm' ? encodeNormalizedFloatToRGBA(this, this.depth) : pb.vec4(this.depth, 0, 0, 1));
         }
     });
-    return pb.getGlobalScope()[funcNameComputeShadowMapDepth]();
+    return pb.getGlobalScope()[funcNameComputeShadowMapDepth](worldPos);
 }
 /** @internal */ function computeReceiverPlaneDepthBias(scope, texCoord) {
     const funcNameComputeReceiverPlaneDepthBias = 'lib_computeReceiverPlaneDepthBias';
@@ -374,7 +376,7 @@ function getRandomRotationMatrix(scope, fragCoord) {
     return pb.getGlobalScope()[funcNameGetRandomRotationMatrix](fragCoord);
 }
 function getPoissonDiscSampleRadius(scope) {
-    return ShaderFramework.getDepthBiasValues(scope).z;
+    return ShaderHelper.getDepthBiasValues(scope).z;
 }
 function sampleShadowMapPCF(scope, shadowMapFormat, pos, offset, depth, cascade) {
     const funcName = cascade ? 'lib_sampleShadowMapCascadePCF' : 'lib_sampleShadowMapPCF';
@@ -391,9 +393,9 @@ function sampleShadowMapPCF(scope, shadowMapFormat, pos, offset, depth, cascade)
         const sampleDepth = this.z;
         const uv = pb.add(this.coords, this.offset);
         if (nativeShadowMap) {
-            this.$return(cascade && Application.instance.device.type !== 'webgl' ? pb.textureArraySampleCompareLevel(this.shadowMap, uv, this.cascade, sampleDepth) : pb.textureSampleCompareLevel(this.shadowMap, uv, sampleDepth));
+            this.$return(cascade && Application.instance.device.type !== 'webgl' ? pb.textureArraySampleCompareLevel(ShaderHelper.getShadowMap(this), uv, this.cascade, sampleDepth) : pb.textureSampleCompareLevel(ShaderHelper.getShadowMap(this), uv, sampleDepth));
         } else {
-            this.$l.shadowTex = cascade && Application.instance.device.type !== 'webgl' ? pb.textureArraySampleLevel(this.shadowMap, uv, this.cascade, 0) : pb.textureSampleLevel(this.shadowMap, uv, 0);
+            this.$l.shadowTex = cascade && Application.instance.device.type !== 'webgl' ? pb.textureArraySampleLevel(ShaderHelper.getShadowMap(this), uv, this.cascade, 0) : pb.textureSampleLevel(ShaderHelper.getShadowMap(this), uv, 0);
             if (shadowMapFormat === 'rgba8unorm') {
                 this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
             }
@@ -417,9 +419,9 @@ function sampleShadowMap(scope, lightType, shadowMapFormat, pos, depth, cascade)
     ], function() {
         if (lightType === LIGHT_TYPE_POINT) {
             if (nativeShadowMap) {
-                this.$return(pb.clamp(pb.textureSampleCompareLevel(this.shadowMap, this.coords, this.z), 0, 1));
+                this.$return(pb.clamp(pb.textureSampleCompareLevel(ShaderHelper.getShadowMap(this), this.coords, this.z), 0, 1));
             } else {
-                this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.coords, 0);
+                this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.coords, 0);
                 if (shadowMapFormat === 'rgba8unorm') {
                     this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
                 }
@@ -427,9 +429,9 @@ function sampleShadowMap(scope, lightType, shadowMapFormat, pos, depth, cascade)
             }
         } else {
             if (nativeShadowMap) {
-                this.$return(cascade && Application.instance.device.type !== 'webgl' ? pb.textureArraySampleCompareLevel(this.shadowMap, this.coords, this.cascade, this.z) : pb.textureSampleCompareLevel(this.shadowMap, this.coords, this.z));
+                this.$return(cascade && Application.instance.device.type !== 'webgl' ? pb.textureArraySampleCompareLevel(ShaderHelper.getShadowMap(this), this.coords, this.cascade, this.z) : pb.textureSampleCompareLevel(ShaderHelper.getShadowMap(this), this.coords, this.z));
             } else {
-                this.$l.shadowTex = cascade && Application.instance.device.type !== 'webgl' ? pb.textureArraySampleLevel(this.shadowMap, this.coords, this.cascade, 0) : pb.textureSampleLevel(this.shadowMap, this.coords, 0);
+                this.$l.shadowTex = cascade && Application.instance.device.type !== 'webgl' ? pb.textureArraySampleLevel(ShaderHelper.getShadowMap(this), this.coords, this.cascade, 0) : pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.coords, 0);
                 if (shadowMapFormat === 'rgba8unorm') {
                     this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
                 }
@@ -451,7 +453,7 @@ function chebyshevUpperBound(scope, distance, occluder) {
         this.$if(pb.notEqual(this.test, 1), function() {
             this.$l.d = pb.sub(this.distance, this.occluder.x);
             this.$l.variance = pb.max(pb.mul(this.occluder.y, this.occluder.y), 0);
-            const darkness = ShaderFramework.getDepthBiasValues(this).z;
+            const darkness = ShaderHelper.getDepthBiasValues(this).z;
             this.shadow = pb.div(this.variance, pb.add(this.variance, pb.mul(this.d, this.d)));
             this.shadow = pb.clamp(pb.div(pb.sub(this.shadow, darkness), pb.sub(1, darkness)), 0, 1);
         });
@@ -469,13 +471,13 @@ function chebyshevUpperBound(scope, distance, occluder) {
         ] : []
     ], function() {
         if (lightType === LIGHT_TYPE_POINT) {
-            this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.texCoord.xyz, 0);
+            this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.texCoord.xyz, 0);
             this.$return(chebyshevUpperBound(this, this.texCoord.w, shadowMapFormat === 'rgba8unorm' ? decode2HalfFromRGBA(this, this.shadowTex) : this.shadowTex.rg));
         } else {
             if (Application.instance.device.type !== 'webgl' && cascade) {
-                this.$l.shadowTex = pb.textureArraySampleLevel(this.shadowMap, this.texCoord.xy, this.cascade, 0);
+                this.$l.shadowTex = pb.textureArraySampleLevel(ShaderHelper.getShadowMap(this), this.texCoord.xy, this.cascade, 0);
             } else {
-                this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.texCoord.xy, 0);
+                this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.texCoord.xy, 0);
             }
             this.$return(chebyshevUpperBound(this, this.texCoord.z, shadowMapFormat === 'rgba8unorm' ? decode2HalfFromRGBA(this, this.shadowTex) : this.shadowTex.rg));
         }
@@ -494,28 +496,28 @@ function chebyshevUpperBound(scope, distance, occluder) {
         ] : []
     ], function() {
         if (lightType === LIGHT_TYPE_POINT) {
-            this.$l.depth = pb.div(pb.length(this.shadowVertex.xyz), ShaderFramework.getLightPositionAndRangeForShadow(this).w);
-            this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.shadowVertex.xyz, 0);
+            this.$l.depth = pb.div(pb.length(this.shadowVertex.xyz), ShaderHelper.getLightPositionAndRangeForShadow(this).w);
+            this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.shadowVertex.xyz, 0);
             if (shadowMapFormat === 'rgba8unorm') {
                 this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
             }
         } else {
             if (cascade && Application.instance.device.type !== 'webgl') {
-                this.$l.shadowTex = pb.textureArraySampleLevel(this.shadowMap, this.shadowVertex.xy, this.cascade, 0);
+                this.$l.shadowTex = pb.textureArraySampleLevel(ShaderHelper.getShadowMap(this), this.shadowVertex.xy, this.cascade, 0);
             } else {
-                this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.shadowVertex.xy, 0);
+                this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.shadowVertex.xy, 0);
             }
             if (shadowMapFormat === 'rgba8unorm') {
                 this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
             }
             if (lightType === LIGHT_TYPE_SPOT) {
-                this.$l.nearFar = ShaderFramework.getShadowCameraParams(this).xy;
-                this.$l.depth = nonLinearDepthToLinearNormalized(this, this.shadowVertex.z, this.nearFar);
+                this.$l.nearFar = ShaderHelper.getShadowCameraParams(this).xy;
+                this.$l.depth = ShaderHelper.nonLinearDepthToLinearNormalized(this, this.shadowVertex.z, this.nearFar);
             } else {
                 this.$l.depth = this.shadowVertex.z;
             }
         }
-        const depthScale = ShaderFramework.getDepthBiasValues(this).z;
+        const depthScale = ShaderHelper.getDepthBiasValues(this).z;
         this.$return(pb.clamp(pb.exp(pb.min(87, pb.mul(depthScale, pb.sub(this.shadowTex.x, this.depth)))), 0, 1));
     });
     return pb.getGlobalScope()[funcNameFilterShadowESM](shadowVertex, ...cascade ? [

package/dist/shaders/shadow.js.map

@@ -1 +1 @@
-{"version":3,"file":"shadow.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"shadow.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/shaders/water.js

@@ -31,15 +31,9 @@ import { Application } from '../app.js';
                 this.$outputs.uv0 = pb.div(this.xz, this.sizes.x);
                 this.$outputs.uv1 = pb.div(this.xz, this.sizes.y);
                 this.$outputs.uv2 = pb.div(this.xz, this.sizes.z);
-                if (pb.getDevice().type === 'webgl') {
-                    this.$l.a = pb.mul(pb.textureSample(this.dx_hy_dz_dxdz0, this.$outputs.uv0).rgb, pb.vec3(this.croppinesses.x, 1, this.croppinesses.x));
-                    this.$l.b = pb.mul(pb.textureSample(this.dx_hy_dz_dxdz1, this.$outputs.uv1).rgb, pb.vec3(this.croppinesses.y, 1, this.croppinesses.y));
-                    this.$l.c = pb.mul(pb.textureSample(this.dx_hy_dz_dxdz2, this.$outputs.uv2).rgb, pb.vec3(this.croppinesses.z, 1, this.croppinesses.z));
-                } else {
-                    this.$l.a = pb.mul(pb.textureSampleLevel(this.dx_hy_dz_dxdz0, this.$outputs.uv0, 0).rgb, pb.vec3(this.croppinesses.x, 1, this.croppinesses.x));
-                    this.$l.b = pb.mul(pb.textureSampleLevel(this.dx_hy_dz_dxdz1, this.$outputs.uv1, 0).rgb, pb.vec3(this.croppinesses.y, 1, this.croppinesses.y));
-                    this.$l.c = pb.mul(pb.textureSampleLevel(this.dx_hy_dz_dxdz2, this.$outputs.uv2, 0).rgb, pb.vec3(this.croppinesses.z, 1, this.croppinesses.z));
-                }
+                this.$l.a = pb.mul(pb.textureSampleLevel(this.dx_hy_dz_dxdz0, this.$outputs.uv0, 0).rgb, pb.vec3(this.croppinesses.x, 1, this.croppinesses.x));
+                this.$l.b = pb.mul(pb.textureSampleLevel(this.dx_hy_dz_dxdz1, this.$outputs.uv1, 0).rgb, pb.vec3(this.croppinesses.y, 1, this.croppinesses.y));
+                this.$l.c = pb.mul(pb.textureSampleLevel(this.dx_hy_dz_dxdz2, this.$outputs.uv2, 0).rgb, pb.vec3(this.croppinesses.z, 1, this.croppinesses.z));
                 this.$l.displacement = pb.add(this.a, this.b, this.c);
                 this.$outputs.outPos = pb.add(pb.vec3(this.xz.x, this.level, this.xz.y), this.displacement);
                 this.$outputs.outXZ = this.xz;

package/dist/shaders/water.js.map

@@ -1 +1 @@
-{"version":3,"file":"water.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"water.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}