@zephyr3d/scene 0.1.2 → 0.2.0

package/dist/shadow/esm.js

@@ -1,20 +1,22 @@
 import { ShadowImpl } from './shadow_impl.js';
 import '@zephyr3d/base';
 import { Application } from '../app.js';
-import { ShaderFramework } from '../shaders/framework.js';
 import { decodeNormalizedFloatFromRGBA, encodeNormalizedFloatToRGBA } from '../shaders/misc.js';
 import { GaussianBlurBlitter } from '../blitter/gaussianblur.js';
 import { computeShadowMapDepth, filterShadowESM } from '../shaders/shadow.js';
 import '../scene/octree.js';
 import { LIGHT_TYPE_POINT } from '../values.js';
-import '../material/material.js';
-import '@zephyr3d/device';
-import '../render/scatteringlut.js';
+import { ShaderHelper } from '../material/shader/helper.js';
 import '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
-import '../material/lightmodel.js';
-import '../render/forward.js';
+import '../material/material.js';
+import '../material/meshmaterial.js';
+import '../material/grassmaterial.js';
+import '../material/terrainmaterial.js';
+import '../material/pbrmr.js';
+import '../material/pbrsg.js';
+import '../render/renderer.js';
 import '../render/sky.js';
 import '../render/clipmap.js';
 import { TemporalCache } from '../render/temporalcache.js';
@@ -181,8 +183,8 @@ class BlurBlitter extends GaussianBlurBlitter {
     getShadowMapDepthFormat(shadowMapParams) {
         return 'd24s8';
     }
-    computeShadowMapDepth(shadowMapParams, scope) {
-        return computeShadowMapDepth(scope, shadowMapParams.shadowMap.format);
+    computeShadowMapDepth(shadowMapParams, scope, worldPos) {
+        return computeShadowMapDepth(scope, worldPos, shadowMapParams.shadowMap.format);
     }
     computeShadowCSM(shadowMapParams, scope, shadowVertex, NdotL, split) {
         const funcNameComputeShadowCSM = 'lib_computeShadowCSM';
@@ -211,7 +213,7 @@ class BlurBlitter extends GaussianBlurBlitter {
             pb.float('NdotL')
         ], function() {
             if (shadowMapParams.lightType === LIGHT_TYPE_POINT) {
-                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderFramework.getLightPositionAndRangeForShadow(this).xyz);
+                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderHelper.getLightPositionAndRangeForShadow(this).xyz);
                 this.$return(filterShadowESM(this, LIGHT_TYPE_POINT, shadowMapParams.shadowMap.format, this.dir));
             } else {
                 this.$l.shadowCoord = pb.div(this.shadowVertex, this.shadowVertex.w);

package/dist/shadow/esm.js.map

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

package/dist/shadow/pcf_opt.js

@@ -1,10 +1,10 @@
 import { ShadowImpl } from './shadow_impl.js';
-import { linearDepthToNonLinear, decodeNormalizedFloatFromRGBA } from '../shaders/misc.js';
+import { decodeNormalizedFloatFromRGBA } from '../shaders/misc.js';
 import { computeShadowMapDepth, computeReceiverPlaneDepthBias, filterShadowPCF } from '../shaders/shadow.js';
 import { ShadowMapper } from './shadowmapper.js';
-import { ShaderFramework } from '../shaders/framework.js';
 import { Application } from '../app.js';
 import { LIGHT_TYPE_POINT } from '../values.js';
+import { ShaderHelper } from '../material/shader/helper.js';
 
 /** @internal */ class PCFOPT extends ShadowImpl {
     _kernelSize;
@@ -55,8 +55,8 @@ import { LIGHT_TYPE_POINT } from '../values.js';
     getShadowMapDepthFormat(shadowMapParams) {
         return Application.instance.device.type === 'webgl' ? 'd24s8' : 'd32f';
     }
-    computeShadowMapDepth(shadowMapParams, scope) {
-        return computeShadowMapDepth(scope, shadowMapParams.shadowMap.format);
+    computeShadowMapDepth(shadowMapParams, scope, worldPos) {
+        return computeShadowMapDepth(scope, worldPos, shadowMapParams.shadowMap.format);
     }
     computeShadowCSM(shadowMapParams, scope, shadowVertex, NdotL, split) {
         const funcNameComputeShadowCSM = 'lib_computeShadowCSM';
@@ -90,15 +90,15 @@ import { LIGHT_TYPE_POINT } from '../values.js';
             pb.float('NdotL')
         ], function() {
             if (shadowMapParams.lightType === LIGHT_TYPE_POINT) {
-                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderFramework.getLightPositionAndRangeForShadow(this).xyz);
+                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderHelper.getLightPositionAndRangeForShadow(this).xyz);
                 if (that.useNativeShadowMap(shadowMapParams)) {
-                    this.$l.nearFar = ShaderFramework.getShadowCameraParams(this).xy;
+                    this.$l.nearFar = ShaderHelper.getShadowCameraParams(this).xy;
                     this.$l.maxZ = pb.max(pb.max(pb.abs(this.dir.x), pb.abs(this.dir.y)), pb.abs(this.dir.z));
-                    this.$l.distance = linearDepthToNonLinear(this, this.maxZ, this.nearFar);
-                    this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, pb.div(this.maxZ, ShaderFramework.getLightPositionAndRangeForShadow(this).w), this.NdotL, true);
+                    this.$l.distance = ShaderHelper.linearDepthToNonLinear(this, this.maxZ, this.nearFar);
+                    this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, pb.div(this.maxZ, ShaderHelper.getLightPositionAndRangeForShadow(this).w), this.NdotL, true);
                     this.$return(that.sampleShadowMap(shadowMapParams, this, this.dir, this.distance, this.shadowBias));
                 } else {
-                    this.$l.distance = pb.div(pb.length(this.dir), ShaderFramework.getLightPositionAndRangeForShadow(this).w);
+                    this.$l.distance = pb.div(pb.length(this.dir), ShaderHelper.getLightPositionAndRangeForShadow(this).w);
                     this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, this.distance, this.NdotL, true);
                     this.$return(that.sampleShadowMap(shadowMapParams, this, this.dir, this.distance, this.shadowBias));
                 }
@@ -132,9 +132,9 @@ import { LIGHT_TYPE_POINT } from '../values.js';
         ], function() {
             const floatDepthTexture = shadowMapParams.shadowMap.format !== 'rgba8unorm';
             if (that.useNativeShadowMap(shadowMapParams)) {
-                this.$return(pb.clamp(pb.textureSampleCompareLevel(this.shadowMap, this.coords, pb.sub(this.z, this.bias)), 0, 1));
+                this.$return(pb.clamp(pb.textureSampleCompareLevel(ShaderHelper.getShadowMap(this), this.coords, pb.sub(this.z, this.bias)), 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 (!floatDepthTexture) {
                     this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
                 }
@@ -158,15 +158,15 @@ import { LIGHT_TYPE_POINT } from '../values.js';
             this.$l.distance = pb.sub(this.z, this.bias);
             if (that.useNativeShadowMap(shadowMapParams)) {
                 if (shadowMapParams.shadowMap.isTexture2DArray()) {
-                    this.$return(pb.clamp(pb.textureArraySampleCompareLevel(this.shadowMap, this.coords.xy, this.split, this.distance), 0, 1));
+                    this.$return(pb.clamp(pb.textureArraySampleCompareLevel(ShaderHelper.getShadowMap(this), this.coords.xy, this.split, this.distance), 0, 1));
                 } else {
-                    this.$return(pb.clamp(pb.textureSampleCompareLevel(this.shadowMap, this.coords.xy, this.distance), 0, 1));
+                    this.$return(pb.clamp(pb.textureSampleCompareLevel(ShaderHelper.getShadowMap(this), this.coords.xy, this.distance), 0, 1));
                 }
             } else {
                 if (shadowMapParams.shadowMap.isTexture2DArray()) {
-                    this.$l.shadowTex = pb.textureArraySampleLevel(this.shadowMap, this.coords.xy, this.split, 0);
+                    this.$l.shadowTex = pb.textureArraySampleLevel(ShaderHelper.getShadowMap(this), this.coords.xy, this.split, 0);
                 } else {
-                    this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.coords.xy, 0);
+                    this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.coords.xy, 0);
                 }
                 if (!floatDepthTexture) {
                     this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);

package/dist/shadow/pcf_pd.js

@@ -1,10 +1,10 @@
 import { ShadowImpl } from './shadow_impl.js';
 import { computeShadowMapDepth, computeReceiverPlaneDepthBias, filterShadowPoissonDisc } from '../shaders/shadow.js';
 import { ShadowMapper } from './shadowmapper.js';
-import { linearDepthToNonLinear, decodeNormalizedFloatFromRGBA } from '../shaders/misc.js';
-import { ShaderFramework } from '../shaders/framework.js';
+import { decodeNormalizedFloatFromRGBA } from '../shaders/misc.js';
 import { Application } from '../app.js';
 import { LIGHT_TYPE_POINT } from '../values.js';
+import { ShaderHelper } from '../material/shader/helper.js';
 
 /** @internal */ class PCFPD extends ShadowImpl {
     _tapCount;
@@ -63,8 +63,8 @@ import { LIGHT_TYPE_POINT } from '../values.js';
     getShadowMapDepthFormat(shadowMapParams) {
         return Application.instance.device.type === 'webgl' ? 'd24s8' : 'd32f';
     }
-    computeShadowMapDepth(shadowMapParams, scope) {
-        return computeShadowMapDepth(scope, shadowMapParams.shadowMap.format);
+    computeShadowMapDepth(shadowMapParams, scope, worldPos) {
+        return computeShadowMapDepth(scope, worldPos, shadowMapParams.shadowMap.format);
     }
     computeShadowCSM(shadowMapParams, scope, shadowVertex, NdotL, split) {
         const funcNameComputeShadowCSM = 'lib_computeShadowCSM';
@@ -98,15 +98,15 @@ import { LIGHT_TYPE_POINT } from '../values.js';
             pb.float('NdotL')
         ], function() {
             if (shadowMapParams.lightType === LIGHT_TYPE_POINT) {
-                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderFramework.getLightPositionAndRangeForShadow(this).xyz);
+                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderHelper.getLightPositionAndRangeForShadow(this).xyz);
                 if (that.useNativeShadowMap(shadowMapParams)) {
-                    this.$l.nearFar = ShaderFramework.getShadowCameraParams(this).xy;
+                    this.$l.nearFar = ShaderHelper.getShadowCameraParams(this).xy;
                     this.$l.maxZ = pb.max(pb.max(pb.abs(this.dir.x), pb.abs(this.dir.y)), pb.abs(this.dir.z));
-                    this.$l.distance = linearDepthToNonLinear(this, this.maxZ, this.nearFar);
-                    this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, pb.div(this.maxZ, ShaderFramework.getLightPositionAndRangeForShadow(this).w), this.NdotL, true);
+                    this.$l.distance = ShaderHelper.linearDepthToNonLinear(this, this.maxZ, this.nearFar);
+                    this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, pb.div(this.maxZ, ShaderHelper.getLightPositionAndRangeForShadow(this).w), this.NdotL, true);
                     this.$return(that.sampleShadowMap(shadowMapParams, this, this.dir, this.distance, this.shadowBias));
                 } else {
-                    this.$l.distance = pb.div(pb.length(this.dir), ShaderFramework.getLightPositionAndRangeForShadow(this).w);
+                    this.$l.distance = pb.div(pb.length(this.dir), ShaderHelper.getLightPositionAndRangeForShadow(this).w);
                     this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, this.distance, this.NdotL, true);
                     this.$return(that.sampleShadowMap(shadowMapParams, this, this.dir, this.distance, this.shadowBias));
                 }
@@ -140,9 +140,9 @@ import { LIGHT_TYPE_POINT } from '../values.js';
         ], function() {
             const floatDepthTexture = shadowMapParams.shadowMap.format !== 'rgba8unorm';
             if (that.useNativeShadowMap(shadowMapParams)) {
-                this.$return(pb.clamp(pb.textureSampleCompareLevel(this.shadowMap, this.coords, pb.sub(this.z, this.bias)), 0, 1));
+                this.$return(pb.clamp(pb.textureSampleCompareLevel(ShaderHelper.getShadowMap(this), this.coords, pb.sub(this.z, this.bias)), 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 (!floatDepthTexture) {
                     this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
                 }
@@ -166,15 +166,15 @@ import { LIGHT_TYPE_POINT } from '../values.js';
             this.$l.distance = pb.sub(this.z, this.bias);
             if (that.useNativeShadowMap(shadowMapParams)) {
                 if (shadowMapParams.shadowMap.isTexture2DArray()) {
-                    this.$return(pb.clamp(pb.textureArraySampleCompareLevel(this.shadowMap, this.coords.xy, this.split, this.distance), 0, 1));
+                    this.$return(pb.clamp(pb.textureArraySampleCompareLevel(ShaderHelper.getShadowMap(this), this.coords.xy, this.split, this.distance), 0, 1));
                 } else {
-                    this.$return(pb.clamp(pb.textureSampleCompareLevel(this.shadowMap, this.coords.xy, this.distance), 0, 1));
+                    this.$return(pb.clamp(pb.textureSampleCompareLevel(ShaderHelper.getShadowMap(this), this.coords.xy, this.distance), 0, 1));
                 }
             } else {
                 if (shadowMapParams.shadowMap.isTexture2DArray()) {
-                    this.$l.shadowTex = pb.textureArraySampleLevel(this.shadowMap, this.coords.xy, this.split, 0);
+                    this.$l.shadowTex = pb.textureArraySampleLevel(ShaderHelper.getShadowMap(this), this.coords.xy, this.split, 0);
                 } else {
-                    this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.coords.xy, 0);
+                    this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.coords.xy, 0);
                 }
                 if (!floatDepthTexture) {
                     this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);

package/dist/shadow/shadowmapper.js

@@ -5,19 +5,20 @@ import { ESM } from './esm.js';
 import { VSM } from './vsm.js';
 import { PCFPD } from './pcf_pd.js';
 import { PCFOPT } from './pcf_opt.js';
-import { nonLinearDepthToLinearNormalized } from '../shaders/misc.js';
-import { ShaderFramework } from '../shaders/framework.js';
 import { Application } from '../app.js';
 import '../scene/octree.js';
 import { LIGHT_TYPE_NONE, LIGHT_TYPE_DIRECTIONAL } from '../values.js';
-import '../material/material.js';
-import '@zephyr3d/device';
-import '../render/scatteringlut.js';
+import { ShaderHelper } from '../material/shader/helper.js';
 import '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
-import '../material/lightmodel.js';
-import '../render/forward.js';
+import '../material/material.js';
+import '../material/meshmaterial.js';
+import '../material/grassmaterial.js';
+import '../material/terrainmaterial.js';
+import '../material/pbrmr.js';
+import '../material/pbrsg.js';
+import '../render/renderer.js';
 import '../render/sky.js';
 import '../render/clipmap.js';
 import { TemporalCache } from '../render/temporalcache.js';
@@ -269,9 +270,6 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
             this.asESM()?.setDepthScale(this._esmDepthScale);
         }
     }
-    /** @internal */ computeShadowMapDepth(shadowMapParams, scope) {
-        return this._impl.computeShadowMapDepth(shadowMapParams, scope);
-    }
     /** @internal */ computeShadow(shadowMapParams, scope, shadowVertex, NdotL) {
         return this._impl.computeShadow(shadowMapParams, scope, shadowVertex, NdotL);
     }
@@ -300,21 +298,21 @@ const tmpFrustum = new Frustum(Matrix4x4.identity());
     }
     /** @internal */ static computeShadowBias(shadowMapParams, scope, z, NdotL, linear) {
         const pb = scope.$builder;
-        const depthBiasParam = ShaderFramework.getDepthBiasValues(scope);
+        const depthBiasParam = ShaderHelper.getDepthBiasValues(scope);
         if (shadowMapParams.lightType === LIGHT_TYPE_DIRECTIONAL) {
             return pb.dot(pb.mul(depthBiasParam.xy, pb.vec2(1, pb.sub(1, NdotL))), pb.vec2(1, 1));
         } else {
-            const nearFar = ShaderFramework.getShadowCameraParams(scope).xy;
-            const linearDepth = linear ? z : nonLinearDepthToLinearNormalized(scope, z, nearFar);
+            const nearFar = ShaderHelper.getShadowCameraParams(scope).xy;
+            const linearDepth = linear ? z : ShaderHelper.nonLinearDepthToLinearNormalized(scope, z, nearFar);
             const biasScaleFactor = pb.mix(1, depthBiasParam.w, linearDepth);
             return pb.dot(pb.mul(depthBiasParam.xy, pb.vec2(1, pb.sub(1, NdotL)), biasScaleFactor), pb.vec2(1, 1));
         }
     }
     /** @internal */ static computeShadowBiasCSM(shadowMapParams, scope, NdotL, split) {
         const pb = scope.$builder;
-        const depthBiasParam = ShaderFramework.getDepthBiasValues(scope);
+        const depthBiasParam = ShaderHelper.getDepthBiasValues(scope);
         const splitFlags = pb.vec4(pb.float(pb.equal(split, 0)), pb.float(pb.equal(split, 1)), pb.float(pb.equal(split, 2)), pb.float(pb.equal(split, 3)));
-        const depthBiasScale = pb.dot(ShaderFramework.getDepthBiasScales(scope), splitFlags);
+        const depthBiasScale = pb.dot(ShaderHelper.getDepthBiasScales(scope), splitFlags);
         return pb.dot(pb.mul(depthBiasParam.xy, pb.vec2(1, pb.sub(1, NdotL)), depthBiasScale), pb.vec2(1, 1));
     }
     /** @internal */ isTextureInvalid(texture, target, format, width, height) {

package/dist/shadow/shadowmapper.js.map

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

package/dist/shadow/ssm.js

@@ -1,10 +1,10 @@
 import { ShadowImpl } from './shadow_impl.js';
-import { ShaderFramework } from '../shaders/framework.js';
-import { decodeNormalizedFloatFromRGBA, linearDepthToNonLinear, nonLinearDepthToLinearNormalized } from '../shaders/misc.js';
-import { Application } from '../app.js';
+import { decodeNormalizedFloatFromRGBA } from '../shaders/misc.js';
 import { ShadowMapper } from './shadowmapper.js';
+import { Application } from '../app.js';
 import { LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT } from '../values.js';
 import { computeShadowMapDepth } from '../shaders/shadow.js';
+import { ShaderHelper } from '../material/shader/helper.js';
 
 /** @internal */ class SSM extends ShadowImpl {
     static instance = new SSM();
@@ -51,43 +51,9 @@ import { computeShadowMapDepth } from '../shaders/shadow.js';
     getShadowMapDepthFormat(shadowMapParams) {
         return Application.instance.device.type === 'webgl' ? 'd24s8' : 'd32f';
     }
-    computeShadowMapDepth(shadowMapParams, scope) {
-        return computeShadowMapDepth(scope, shadowMapParams.shadowMap.format);
-    /*
-    if (this.useNativeShadowMap(shadowMapParams)) {
-      return scope.$builder.vec4(
-        scope.$builder.emulateDepthClamp
-          ? scope.$builder.clamp(scope.$inputs.clamppedDepth, 0, 1)
-          : scope.$builtins.fragCoord.z,
-        0,
-        0,
-        1
-      );
-    } else {
-      const pb = scope.$builder;
-      let depth: PBShaderExp = null;
-      if (shadowMapParams.lightType === LIGHT_TYPE_DIRECTIONAL) {
-        depth = pb.emulateDepthClamp
-          ? pb.clamp(scope.$inputs.clamppedDepth, 0, 1)
-          : scope.$builtins.fragCoord.z;
-      } else if (shadowMapParams.lightType === LIGHT_TYPE_POINT) {
-        const lightSpacePos = pb.mul(
-          ShaderFramework.getLightViewMatrixForShadow(scope),
-          ShaderFramework.getWorldPosition(scope)
-        );
-        depth = pb.div(pb.length(lightSpacePos.xyz), ShaderFramework.getLightPositionAndRangeForShadow(scope).w);
-      } else if (shadowMapParams.lightType === LIGHT_TYPE_SPOT) {
-        const lightSpacePos = pb.mul(
-          ShaderFramework.getLightViewMatrixForShadow(scope),
-          ShaderFramework.getWorldPosition(scope)
-        );
-        depth = pb.min(pb.div(pb.neg(lightSpacePos.z), ShaderFramework.getLightPositionAndRangeForShadow(scope).w), 1);
-      }
-      return shadowMapParams.shadowMap.format === 'rgba8unorm'
-        ? encodeNormalizedFloatToRGBA(scope, depth)
-        : pb.vec4(depth, 0, 0, 1);
-    }
-    */ }
+    computeShadowMapDepth(shadowMapParams, scope, worldPos) {
+        return computeShadowMapDepth(scope, worldPos, shadowMapParams.shadowMap.format);
+    }
     computeShadowCSM(shadowMapParams, scope, shadowVertex, NdotL, split) {
         const funcNameComputeShadowCSM = 'lib_computeShadowCSM';
         const pb = scope.$builder;
@@ -107,15 +73,15 @@ import { computeShadowMapDepth } from '../shaders/shadow.js';
                 this.shadowCoord.z = pb.sub(this.shadowCoord.z, this.shadowBias);
                 if (that.useNativeShadowMap(shadowMapParams)) {
                     if (shadowMapParams.shadowMap.isTexture2DArray()) {
-                        this.shadow = pb.textureArraySampleCompareLevel(this.shadowMap, this.shadowCoord.xy, this.split, this.shadowCoord.z);
+                        this.shadow = pb.textureArraySampleCompareLevel(ShaderHelper.getShadowMap(this), this.shadowCoord.xy, this.split, this.shadowCoord.z);
                     } else {
-                        this.shadow = pb.textureSampleCompareLevel(this.shadowMap, this.shadowCoord.xy, this.shadowCoord.z);
+                        this.shadow = pb.textureSampleCompareLevel(ShaderHelper.getShadowMap(this), this.shadowCoord.xy, this.shadowCoord.z);
                     }
                 } else {
                     if (shadowMapParams.shadowMap.isTexture2DArray()) {
-                        this.$l.shadowTex = pb.textureArraySampleLevel(this.shadowMap, this.shadowCoord.xy, this.split, 0);
+                        this.$l.shadowTex = pb.textureArraySampleLevel(ShaderHelper.getShadowMap(this), this.shadowCoord.xy, this.split, 0);
                     } else {
-                        this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.shadowCoord.xy, 0);
+                        this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.shadowCoord.xy, 0);
                     }
                     if (!floatDepthTexture) {
                         this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
@@ -137,17 +103,17 @@ import { computeShadowMapDepth } from '../shaders/shadow.js';
         ], function() {
             const floatDepthTexture = shadowMapParams.shadowMap.format !== 'rgba8unorm';
             if (shadowMapParams.lightType === LIGHT_TYPE_POINT) {
-                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderFramework.getLightPositionAndRangeForShadow(this).xyz);
+                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderHelper.getLightPositionAndRangeForShadow(this).xyz);
                 if (that.useNativeShadowMap(shadowMapParams)) {
-                    this.$l.nearFar = ShaderFramework.getShadowCameraParams(this).xy;
+                    this.$l.nearFar = ShaderHelper.getShadowCameraParams(this).xy;
                     this.$l.maxZ = pb.max(pb.max(pb.abs(this.dir.x), pb.abs(this.dir.y)), pb.abs(this.dir.z));
-                    this.$l.distance = linearDepthToNonLinear(this, this.maxZ, this.nearFar);
-                    this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, pb.div(this.maxZ, ShaderFramework.getLightPositionAndRangeForShadow(this).w), this.NdotL, true);
-                    this.$return(pb.textureSampleCompareLevel(this.shadowMap, this.dir, pb.sub(this.distance, this.shadowBias)));
+                    this.$l.distance = ShaderHelper.linearDepthToNonLinear(this, this.maxZ, this.nearFar);
+                    this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, pb.div(this.maxZ, ShaderHelper.getLightPositionAndRangeForShadow(this).w), this.NdotL, true);
+                    this.$return(pb.textureSampleCompareLevel(ShaderHelper.getShadowMap(this), this.dir, pb.sub(this.distance, this.shadowBias)));
                 } else {
-                    this.$l.distance = pb.div(pb.length(this.dir), ShaderFramework.getLightPositionAndRangeForShadow(this).w);
+                    this.$l.distance = pb.div(pb.length(this.dir), ShaderHelper.getLightPositionAndRangeForShadow(this).w);
                     this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, this.distance, this.NdotL, true);
-                    this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.dir, 0);
+                    this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.dir, 0);
                     if (!floatDepthTexture) {
                         this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
                     }
@@ -163,17 +129,17 @@ import { computeShadowMapDepth } from '../shaders/shadow.js';
                     if (that.useNativeShadowMap(shadowMapParams)) {
                         this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, this.shadowCoord.z, this.NdotL, false);
                         this.shadowCoord.z = pb.sub(this.shadowCoord.z, this.shadowBias);
-                        this.shadow = pb.textureSampleCompareLevel(this.shadowMap, this.shadowCoord.xy, this.shadowCoord.z);
+                        this.shadow = pb.textureSampleCompareLevel(ShaderHelper.getShadowMap(this), this.shadowCoord.xy, this.shadowCoord.z);
                     } else {
                         if (shadowMapParams.lightType === LIGHT_TYPE_SPOT) {
-                            this.$l.nearFar = ShaderFramework.getShadowCameraParams(this).xy;
-                            this.shadowCoord.z = nonLinearDepthToLinearNormalized(this, this.shadowCoord.z, this.nearFar);
+                            this.$l.nearFar = ShaderHelper.getShadowCameraParams(this).xy;
+                            this.shadowCoord.z = ShaderHelper.nonLinearDepthToLinearNormalized(this, this.shadowCoord.z, this.nearFar);
                             this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, this.shadowCoord.z, this.NdotL, true);
                         } else {
                             this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, this.shadowCoord.z, this.NdotL, false);
                         }
                         this.shadowCoord.z = pb.sub(this.shadowCoord.z, this.shadowBias);
-                        this.$l.shadowTex = pb.textureSampleLevel(this.shadowMap, this.shadowCoord.xy, 0);
+                        this.$l.shadowTex = pb.textureSampleLevel(ShaderHelper.getShadowMap(this), this.shadowCoord.xy, 0);
                         if (!floatDepthTexture) {
                             this.shadowTex.x = decodeNormalizedFloatFromRGBA(this, this.shadowTex);
                         }

package/dist/shadow/ssm.js.map

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

package/dist/shadow/vsm.js

@@ -1,21 +1,23 @@
 import { ShadowImpl } from './shadow_impl.js';
 import { Blitter } from '../blitter/blitter.js';
-import { ShaderFramework } from '../shaders/framework.js';
-import { nonLinearDepthToLinearNormalized, decodeNormalizedFloatFromRGBA, decode2HalfFromRGBA, encode2HalfToRGBA } from '../shaders/misc.js';
+import { decodeNormalizedFloatFromRGBA, decode2HalfFromRGBA, encode2HalfToRGBA } from '../shaders/misc.js';
 import { Application } from '../app.js';
 import { computeShadowMapDepth, filterShadowVSM } from '../shaders/shadow.js';
 import { ShadowMapper } from './shadowmapper.js';
 import '@zephyr3d/base';
 import '../scene/octree.js';
 import { LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT } from '../values.js';
-import '../material/material.js';
-import '@zephyr3d/device';
-import '../render/scatteringlut.js';
+import { ShaderHelper } from '../material/shader/helper.js';
 import '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
-import '../material/lightmodel.js';
-import '../render/forward.js';
+import '../material/material.js';
+import '../material/meshmaterial.js';
+import '../material/grassmaterial.js';
+import '../material/terrainmaterial.js';
+import '../material/pbrmr.js';
+import '../material/pbrsg.js';
+import '../render/renderer.js';
 import '../render/sky.js';
 import '../render/clipmap.js';
 import { TemporalCache } from '../render/temporalcache.js';
@@ -231,8 +233,8 @@ class VSMBlitter extends Blitter {
     getShadowMapDepthFormat(shadowMapParams) {
         return 'd24s8';
     }
-    computeShadowMapDepth(shadowMapParams, scope) {
-        return computeShadowMapDepth(scope, shadowMapParams.shadowMap.format);
+    computeShadowMapDepth(shadowMapParams, scope, worldPos) {
+        return computeShadowMapDepth(scope, worldPos, shadowMapParams.shadowMap.format);
     }
     computeShadowCSM(shadowMapParams, scope, shadowVertex, NdotL, split) {
         const funcNameComputeShadowCSM = 'lib_computeShadowCSM';
@@ -263,8 +265,8 @@ class VSMBlitter extends Blitter {
             pb.float('NdotL')
         ], function() {
             if (shadowMapParams.lightType === LIGHT_TYPE_POINT) {
-                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderFramework.getLightPositionAndRangeForShadow(this).xyz);
-                this.$l.distance = pb.div(pb.length(this.dir), ShaderFramework.getLightPositionAndRangeForShadow(this).w);
+                this.$l.dir = pb.sub(this.shadowVertex.xyz, ShaderHelper.getLightPositionAndRangeForShadow(this).xyz);
+                this.$l.distance = pb.div(pb.length(this.dir), ShaderHelper.getLightPositionAndRangeForShadow(this).w);
                 this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, this.distance, this.NdotL, true);
                 this.$l.coord = pb.vec4(this.dir, pb.sub(this.distance, this.shadowBias));
                 this.$return(filterShadowVSM(this, shadowMapParams.lightType, shadowMapParams.shadowMap.format, this.coord));
@@ -275,8 +277,8 @@ class VSMBlitter extends Blitter {
                 this.$l.shadow = pb.float(1);
                 this.$if(this.inShadow, function() {
                     if (shadowMapParams.lightType === LIGHT_TYPE_SPOT) {
-                        this.$l.nearFar = ShaderFramework.getShadowCameraParams(this).xy;
-                        this.shadowCoord.z = nonLinearDepthToLinearNormalized(this, this.shadowCoord.z, this.nearFar);
+                        this.$l.nearFar = ShaderHelper.getShadowCameraParams(this).xy;
+                        this.shadowCoord.z = ShaderHelper.nonLinearDepthToLinearNormalized(this, this.shadowCoord.z, this.nearFar);
                         this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, this.shadowCoord.z, this.NdotL, true);
                     } else {
                         this.$l.shadowBias = ShadowMapper.computeShadowBias(shadowMapParams, this, this.shadowCoord.z, this.NdotL, false);

package/dist/shadow/vsm.js.map

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

package/dist/shapes/torus.js

@@ -17,9 +17,9 @@ TC(n, m) = (m / M, n / N)
 
 VIndex(n, m) = n * (M + 1) + m
 Triangle(n, m) = (VIndex(n, m), VIndex(n+1, m), VIndex(n+1, m+1), VIndex(n, m), VIndex(n+1, m+1), VIndex(n, m+1))*/ /**
- * 
+ *
  * Torus shape
- * 
+ *
  * @public
  */ class TorusShape extends Shape {
     /**

package/dist/utility/bounding_volume.js

@@ -1,9 +1,9 @@
 import { AABB, Frustum, ClipState } from '@zephyr3d/base';
 import { AABBTree } from './aabbtree.js';
 
-/**
- * The bounding box class
- * @public
+/**
+ * The bounding box class
+ * @public
  */ class BoundingBox extends AABB {
     constructor(arg0, arg1){
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -25,9 +25,9 @@ import { AABBTree } from './aabbtree.js';
         return this;
     }
 }
-/**
- * Bounding box tree
- * @public
+/**
+ * Bounding box tree
+ * @public
  */ class BoundingBoxTree extends AABBTree {
     constructor(arg){
         super(arg);
@@ -54,27 +54,27 @@ import { AABBTree } from './aabbtree.js';
     /** {@inheritDoc BoundingVolume.toAABB} */ toAABB() {
         return this.getTopLevelAABB();
     }
-} /*
-export class BoundingFrustum implements BoundingVolume {
-    protected _frustum: Frustum;
-    constructor ();
-    constructor (other: BoundingFrustum|Frustum|Matrix4x4);
-    constructor (arg0?: BoundingFrustum|Frustum|Matrix4x4) {
-        if (arg0 instanceof BoundingFrustum) {
-            this._frustum = arg0._frustum ? new Frustum (arg0._frustum) : null;
-        } else if (arg0 instanceof Frustum) {
-            this._frustum = new Frustum (arg0);
-        } else if (arg0 instanceof Matrix4x4) {
-            this._frustum = new Frustum (arg0);
-        } else {
-            this._frustum = null;
-        }
-    }
-    clone (): BoundingVolume {
-        return new BoundingFrustum (this);
-    }
-    transform (matrix: Matrix4x4)
-}
+} /*
+export class BoundingFrustum implements BoundingVolume {
+    protected _frustum: Frustum;
+    constructor ();
+    constructor (other: BoundingFrustum|Frustum|Matrix4x4);
+    constructor (arg0?: BoundingFrustum|Frustum|Matrix4x4) {
+        if (arg0 instanceof BoundingFrustum) {
+            this._frustum = arg0._frustum ? new Frustum (arg0._frustum) : null;
+        } else if (arg0 instanceof Frustum) {
+            this._frustum = new Frustum (arg0);
+        } else if (arg0 instanceof Matrix4x4) {
+            this._frustum = new Frustum (arg0);
+        } else {
+            this._frustum = null;
+        }
+    }
+    clone (): BoundingVolume {
+        return new BoundingFrustum (this);
+    }
+    transform (matrix: Matrix4x4)
+}
 */
 
 export { BoundingBox, BoundingBoxTree };

package/dist/utility/pmrem.js

@@ -140,10 +140,10 @@ function createPMREMProgram(type, numSamples) {
                 ], function() {
                     this.$l.n = this.bits;
                     this.n = pb.compOr(pb.sal(this.n, 16), pb.sar(this.n, 16));
-                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x55555555), 1), pb.sar(pb.compAnd(this.n, 0xAAAAAAAA), 1));
-                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x33333333), 2), pb.sar(pb.compAnd(this.n, 0xCCCCCCCC), 2));
-                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x0F0F0F0F), 4), pb.sar(pb.compAnd(this.n, 0xF0F0F0F0), 4));
-                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x00FF00FF), 8), pb.sar(pb.compAnd(this.n, 0xFF00FF00), 8));
+                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x55555555), 1), pb.sar(pb.compAnd(this.n, 0xaaaaaaaa), 1));
+                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x33333333), 2), pb.sar(pb.compAnd(this.n, 0xcccccccc), 2));
+                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x0f0f0f0f), 4), pb.sar(pb.compAnd(this.n, 0xf0f0f0f0), 4));
+                    this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x00ff00ff), 8), pb.sar(pb.compAnd(this.n, 0xff00ff00), 8));
                     this.$return(pb.mul(pb.float(this.n), 2.3283064365386963e-10));
                 });
                 pb.func('hammersley2d', [