@zephyr3d/scene 0.1.1 → 0.2.0

package/dist/render/renderer.js.map

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

package/dist/render/renderpass.js

@@ -1,14 +1,16 @@
 import { Vector4 } from '@zephyr3d/base';
 import { CullVisitor } from './cull_visitor.js';
-import { Material } from '../material/material.js';
-import '@zephyr3d/device';
-import { ShaderFramework } from '../shaders/framework.js';
-import { Application } from '../app.js';
-import './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 { Material } from '../material/material.js';
+import '../material/meshmaterial.js';
+import '../material/grassmaterial.js';
+import '../material/terrainmaterial.js';
+import '../material/pbrmr.js';
+import '../material/pbrsg.js';
+import { Application } from '../app.js';
 import { RenderQueue } from './render_queue.js';
 
 /**
@@ -73,11 +75,11 @@ import { RenderQueue } from './render_queue.js';
             //const programBuilder = new ProgramBuilder(Application.instance.device);
             const ret = Application.instance.device.programBuilder.buildRender({
                 vertex (pb) {
-                    ShaderFramework.prepareVertexShader(pb, ctx);
+                    ShaderHelper.prepareVertexShader(pb, ctx);
                     pb.main(function() {});
                 },
                 fragment (pb) {
-                    ShaderFramework.prepareFragmentShader(pb, ctx);
+                    ShaderHelper.prepareFragmentShader(pb, ctx);
                     pb.main(function() {});
                 }
             });

package/dist/render/renderpass.js.map

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

package/dist/render/shadowmap_pass.js

@@ -1,8 +1,7 @@
 import { RenderPass } from './renderpass.js';
 import { RENDER_PASS_TYPE_SHADOWMAP } from '../values.js';
-import { ShaderFramework } from '../shaders/framework.js';
-import '@zephyr3d/device';
 import { Application } from '../app.js';
+import { ShaderHelper } from '../material/shader/helper.js';
 
 /**
  * Shadow map render pass
@@ -51,8 +50,8 @@ import { Application } from '../app.js';
         const device = Application.instance.device;
         const bindGroup = this.getGlobalBindGroupInfo(ctx).bindGroup;
         device.setBindGroup(0, bindGroup);
-        ShaderFramework.setLightUniformsShadowMap(bindGroup, ctx, this._currentLight);
-        ShaderFramework.setCameraUniforms(bindGroup, ctx, true);
+        ShaderHelper.setLightUniformsShadowMap(bindGroup, ctx, this._currentLight);
+        ShaderHelper.setCameraUniforms(bindGroup, ctx, true);
         ctx.renderPassHash = this.getGlobalBindGroupHash(ctx);
         const reverseWinding = ctx.camera.worldMatrixDet < 0;
         for (const order of Object.keys(renderQueue.items).map((val)=>Number(val)).sort((a, b)=>a - b)){

package/dist/render/shadowmap_pass.js.map

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

package/dist/render/sky.js

@@ -1,28 +1,27 @@
 import { Application } from '../app.js';
 import { decodeNormalizedFloatFromRGBA, linearToGamma } from '../shaders/misc.js';
-import { ShaderFramework } from '../shaders/framework.js';
 import { smoothNoise3D } from '../shaders/noise.js';
-import { Matrix4x4, Vector3, Vector4, Vector2, CubeFace } from '@zephyr3d/base';
+import { Matrix4x4, Vector4, Vector2, Vector3, CubeFace } from '@zephyr3d/base';
 import { BoxShape } from '../shapes/box.js';
 import { ScatteringLut } from './scatteringlut.js';
 import { Camera } from '../camera/camera.js';
 import { prefilterCubemap } from '../utility/pmrem.js';
 import '../utility/panorama.js';
 import '../utility/shprojection.js';
+import { ShaderHelper } from '../material/shader/helper.js';
 
 const fogTypeMap = {
-    linear: ShaderFramework.FOG_TYPE_LINEAR,
-    exp: ShaderFramework.FOG_TYPE_EXP,
-    exp2: ShaderFramework.FOG_TYPE_EXP2,
-    scatter: ShaderFramework.FOG_TYPE_SCATTER,
-    none: ShaderFramework.FOG_TYPE_NONE
+    linear: ShaderHelper.FOG_TYPE_LINEAR,
+    exp: ShaderHelper.FOG_TYPE_EXP,
+    exp2: ShaderHelper.FOG_TYPE_EXP2,
+    scatter: ShaderHelper.FOG_TYPE_SCATTER,
+    none: ShaderHelper.FOG_TYPE_NONE
 };
 const defaultSkyWorldMatrix = Matrix4x4.identity();
 /**
  * The sky renderer
  * @public
  */ class SkyRenderer {
-    static _defaultSunDir = Vector3.one().inplaceNormalize();
     _skyType;
     _skyColor;
     _skyboxTexture;
@@ -30,6 +29,7 @@ const defaultSkyWorldMatrix = Matrix4x4.identity();
     _radianceMapDirty;
     _scatterSkyboxFramebuffer;
     _scatterSkyboxTextureWidth;
+    _aerialPerspectiveDensity;
     _radianceMap;
     _radianceMapWidth;
     _irradianceMap;
@@ -54,6 +54,7 @@ const defaultSkyWorldMatrix = Matrix4x4.identity();
     _renderStatesSkyNoDepthTest;
     _renderStatesFog;
     _renderStatesFogScatter;
+    _drawGround;
     _lastSunDir;
     /**
    * Creates an instance of SkyRenderer
@@ -65,6 +66,7 @@ const defaultSkyWorldMatrix = Matrix4x4.identity();
         this._skyboxTexture = null;
         this._scatterSkyboxFramebuffer = null;
         this._scatterSkyboxTextureWidth = 256;
+        this._aerialPerspectiveDensity = 1;
         this._radianceMap = null;
         this._radianceMapWidth = 128;
         this._irradianceMap = null;
@@ -75,6 +77,7 @@ const defaultSkyWorldMatrix = Matrix4x4.identity();
         this._cloudy = 0.6;
         this._cloudIntensity = 40;
         this._wind = Vector2.zero();
+        this._drawGround = false;
         this._nearestSampler = null;
         this._programSky = {};
         this._bindgroupSky = {};
@@ -103,6 +106,12 @@ const defaultSkyWorldMatrix = Matrix4x4.identity();
             this.invalidateIBLMaps();
         }
     }
+    /** Whether ground should be rendered */ get drawGround() {
+        return this._drawGround;
+    }
+    set drawGround(val) {
+        this._drawGround = !!val;
+    }
     /**
    * Wether the IBL maps should be updated automatically.
    *
@@ -131,6 +140,12 @@ const defaultSkyWorldMatrix = Matrix4x4.identity();
             this.invalidateIBLMaps();
         }
     }
+    /** Aerial perspective density */ get aerialPerspectiveDensity() {
+        return this._aerialPerspectiveDensity;
+    }
+    set aerialPerspectiveDensity(val) {
+        this._aerialPerspectiveDensity = val;
+    }
     /**
    * Light density of the sky.
    *
@@ -270,7 +285,7 @@ const defaultSkyWorldMatrix = Matrix4x4.identity();
         if (this.drawScatteredFog(ctx)) {
             const sunDir = SkyRenderer._getSunDir(ctx.sunLight);
             const alpha = Math.PI / 2 - Math.acos(Math.max(-1, Math.min(1, sunDir.y)));
-            const farPlane = ctx.camera.getFarPlane() * ctx.scene.worldUnit;
+            const farPlane = ctx.camera.getFarPlane() * this._aerialPerspectiveDensity * this._aerialPerspectiveDensity;
             return ScatteringLut.getAerialPerspectiveLut(alpha, farPlane);
         } else {
             return null;
@@ -342,13 +357,14 @@ const defaultSkyWorldMatrix = Matrix4x4.identity();
             bindgroup.setValue('cameraPosition', camera.getWorldPosition());
             bindgroup.setValue('srgbOut', device.getFramebuffer() ? 0 : 1);
             if (this._fogType === 'scatter') {
-                const sunDir = sunLight ? sunLight.directionAndCutoff.xyz().scaleBy(-1) : SkyRenderer._defaultSunDir;
+                const sunDir = sunLight ? sunLight.directionAndCutoff.xyz().scaleBy(-1) : ShaderHelper.defaultSunDir;
                 const alpha = Math.PI / 2 - Math.acos(Math.max(-1, Math.min(1, sunDir.y)));
-                const farPlane = ctx.camera.getFarPlane() * ctx.scene.worldUnit;
+                const scale = this._aerialPerspectiveDensity * this._aerialPerspectiveDensity;
+                const farPlane = ctx.camera.getFarPlane() * scale;
                 bindgroup.setTexture('apLut', ScatteringLut.getAerialPerspectiveLut(alpha, farPlane));
                 bindgroup.setValue('sliceDist', farPlane / ScatteringLut.aerialPerspectiveSliceZ);
                 bindgroup.setValue('sunDir', sunDir);
-                bindgroup.setValue('worldScale', ctx.scene.worldUnit);
+                bindgroup.setValue('worldScale', scale);
             } else {
                 bindgroup.setValue('fogType', this.mappedFogType);
                 bindgroup.setValue('fogColor', this._fogColor);
@@ -367,7 +383,7 @@ const defaultSkyWorldMatrix = Matrix4x4.identity();
         if (!sunDir.equalsTo(this._lastSunDir)) {
             this._radianceMapDirty = true;
         }
-        this._renderSky(ctx.camera, true, sunDir, false, this._skyType === 'scatter' && this._cloudy > 0);
+        this._renderSky(ctx.camera, true, sunDir, this._drawGround, this._skyType === 'scatter' && this._cloudy > 0);
         if (this._radianceMapDirty && ctx.env.light.type === 'ibl') {
             if (ctx.env.light.radianceMap && (ctx.env.light.radianceMap === this._radianceMap || ctx.env.light.irradianceMap === this._irradianceMap)) {
                 this._radianceMapDirty = false;
@@ -548,7 +564,7 @@ const defaultSkyWorldMatrix = Matrix4x4.identity();
                         this.$l.hPos = pb.mul(this.invProjViewMatrix, this.clipSpacePos);
                         this.$l.hPos = pb.div(this.$l.hPos, this.$l.hPos.w);
                         this.$l.viewDir = pb.sub(this.hPos.xyz, this.cameraPosition);
-                        this.$l.fogFactor = ShaderFramework.computeFogFactor(this, this.viewDir, this.fogType, this.fogParams);
+                        this.$l.fogFactor = ShaderHelper.computeFogFactor(this, this.viewDir, this.fogType, this.fogParams);
                         this.$l.color = pb.mul(this.fogColor.rgb, this.fogFactor);
                         this.$if(pb.equal(this.srgbOut, 0), function() {
                             this.$outputs.outColor = pb.vec4(this.color, this.fogFactor);
@@ -691,7 +707,7 @@ const defaultSkyWorldMatrix = Matrix4x4.identity();
     }
     /** @internal */ static _getSunDir(sunLight) {
         // TODO: reduce GC
-        return sunLight?.directionAndCutoff.xyz().scaleBy(-1) ?? SkyRenderer._defaultSunDir;
+        return sunLight?.directionAndCutoff.xyz().scaleBy(-1) ?? ShaderHelper.defaultSunDir;
     }
     static _createScatterProgram(device, cloud) {
         return device.buildRenderProgram({

package/dist/render/sky.js.map

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

package/dist/scene/environment.js

@@ -1,15 +1,17 @@
 import { Vector4 } from '@zephyr3d/base';
 import '../app.js';
 import './octree.js';
-import '../material/material.js';
-import '@zephyr3d/device';
-import '../shaders/framework.js';
-import '../render/scatteringlut.js';
+import '../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 { SkyRenderer } from '../render/sky.js';
 import '../render/clipmap.js';
 import { EnvIBL, EnvHemisphericAmbient, EnvConstantAmbient } from '../render/envlight.js';

package/dist/scene/environment.js.map

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

package/dist/scene/graph_node.js

@@ -63,6 +63,9 @@ import { SceneNode } from './scene_node.js';
    */ isBatchable() {
         return false;
     }
+    /** @internal */ _visibleChanged() {
+        this._scene?.invalidateNodePlacement(this);
+    }
 }
 
 export { GraphNode };

package/dist/scene/graph_node.js.map

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

package/dist/scene/mesh.js

@@ -2,15 +2,17 @@ import { Vector4 } from '@zephyr3d/base';
 import { GraphNode } from './graph_node.js';
 import { Application } from '../app.js';
 import { BoxFrameShape } from '../shapes/box.js';
-import { StandardMaterial } from '../material/standard.js';
-import '../material/lambert.js';
+import '../material/shader/helper.js';
+import { LambertMaterial } from '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
-import { LambertLightModel } from '../material/lightmodel.js';
 import '../material/material.js';
-import '@zephyr3d/device';
-import '../shaders/framework.js';
-import '../render/scatteringlut.js';
+import '../material/meshmaterial.js';
+import '../material/grassmaterial.js';
+import '../material/terrainmaterial.js';
+import '../material/pbrmr.js';
+import '../material/pbrsg.js';
+import { QUEUE_OPAQUE } from '../values.js';
 
 /**
  * Mesh node
@@ -145,7 +147,7 @@ import '../render/scatteringlut.js';
     /**
    * {@inheritDoc Drawable.isBatchable}
    */ isBatchable() {
-        return this._batchable && !this._boneMatrices;
+        return this._batchable && !this._boneMatrices && this._material?.isBatchable();
     }
     /** Disposes the mesh node */ dispose() {
         this._primitive = null;
@@ -153,9 +155,9 @@ import '../render/scatteringlut.js';
         super.dispose();
     }
     /**
-   * {@inheritDoc Drawable.isTransparency}
-   */ isTransparency() {
-        return !!this.material?.isTransparent();
+   * {@inheritDoc Drawable.getQueueType}
+   */ getQueueType() {
+        return this.material?.getQueueType() ?? QUEUE_OPAQUE;
     }
     /**
    * {@inheritDoc Drawable.isUnlit}
@@ -204,8 +206,7 @@ import '../render/scatteringlut.js';
     /** @internal */ static _defaultBoxFrame = null;
     /** @internal */ static _getDefaultMaterial() {
         if (!this._defaultMaterial) {
-            this._defaultMaterial = new StandardMaterial();
-            this._defaultMaterial.lightModel = new LambertLightModel();
+            this._defaultMaterial = new LambertMaterial();
         }
         return this._defaultMaterial;
     }

package/dist/scene/mesh.js.map

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

package/dist/scene/scene.js

@@ -2,15 +2,17 @@ import { makeEventTarget, Vector4, Vector3, Ray, nextPowerOf2 } from '@zephyr3d/
 import { SceneNode } from './scene_node.js';
 import { Octree } from './octree.js';
 import { OctreeUpdateVisitor } from './octree_update_visitor.js';
-import { Material } from '../material/material.js';
-import '@zephyr3d/device';
-import '../shaders/framework.js';
-import { Application } from '../app.js';
-import '../render/scatteringlut.js';
+import '../material/shader/helper.js';
 import '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
-import '../material/lightmodel.js';
+import { Material } from '../material/material.js';
+import '../material/meshmaterial.js';
+import '../material/grassmaterial.js';
+import '../material/terrainmaterial.js';
+import '../material/pbrmr.js';
+import '../material/pbrsg.js';
+import { Application } from '../app.js';
 import { RaycastVisitor } from './raycast_visitor.js';
 import { Environment } from './environment.js';
 
@@ -36,7 +38,6 @@ import { Environment } from './environment.js';
     /** @internal */ _env;
     /** @internal */ _updateEvent;
     /** @internal */ _updateFrame;
-    /** @internal */ _worldUnit;
     /** @internal */ _animationSet;
     /** @internal */ _id;
     /**
@@ -49,7 +50,6 @@ import { Environment } from './environment.js';
         this._env = new Environment();
         this._updateEvent = new SceneUpdateEvent(this);
         this._updateFrame = -1;
-        this._worldUnit = 1;
         this._animationSet = [];
         this._rootNode = new SceneNode(this);
     }
@@ -61,12 +61,6 @@ import { Environment } from './environment.js';
    */ get id() {
         return this._id;
     }
-    /** How many meters a unit corresponds to. */ get worldUnit() {
-        return this._worldUnit;
-    }
-    set worldUnit(val) {
-        this._worldUnit = val;
-    }
     /**
    * Gets the root scene node of the scene
    */ get rootNode() {
@@ -136,7 +130,9 @@ import { Environment } from './environment.js';
         return new Ray(vEye, vDir);
     }
     /** @internal */ invalidateNodePlacement(node) {
-        this._nodePlaceList.add(node);
+        if (node.isGraphNode() || node.children.length > 0) {
+            this._nodePlaceList.add(node);
+        }
     }
     /** @internal */ _xformChanged(node) {
         this._nodePlaceList.add(node);

package/dist/scene/scene.js.map

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

package/dist/scene/scene_node.js

@@ -47,7 +47,7 @@ import { XForm } from './xform.js';
         this._bvDirty = true;
         this._clipMode = SceneNode.CLIP_ENABLED;
         this._boxDrawMode = SceneNode.BBOXDRAW_DISABLED;
-        this._visible = SceneNode.SHOW_DEFAULT;
+        this._visible = SceneNode.SHOW_INHERITED;
         this._pickMode = SceneNode.PICK_DISABLED;
         if (scene && this !== scene.rootNode) {
             this.reparent(scene.rootNode);
@@ -210,14 +210,11 @@ import { XForm } from './xform.js';
         this._clipMode = val;
     }
     /** Computed value of show state */ get hidden() {
-        if (this._visible === SceneNode.SHOW_INHERITED) {
-            let parent = this.parent;
-            while(parent && !parent.isGraphNode()){
-                parent = parent.parent;
-            }
-            return parent?.hidden ?? false;
+        let node = this;
+        while(node && node._visible === SceneNode.SHOW_INHERITED){
+            node = node.parent;
         }
-        return this._visible === SceneNode.SHOW_HIDE;
+        return node ? node._visible === SceneNode.SHOW_HIDE : false;
     }
     /** Show state */ get showState() {
         return this._visible;
@@ -232,14 +229,11 @@ import { XForm } from './xform.js';
         }
     }
     /** Computed value of pick mode */ get pickable() {
-        if (this._pickMode === SceneNode.PICK_INHERITED) {
-            let parent = this.parent;
-            while(parent && !parent.isGraphNode()){
-                parent = parent.parent;
-            }
-            return parent?.pickable ?? false;
+        let node = this;
+        while(node && node._pickMode === SceneNode.PICK_INHERITED){
+            node = node.parent;
         }
-        return this._pickMode !== SceneNode.PICK_DISABLED;
+        return node ? node._pickMode === SceneNode.PICK_ENABLED : false;
     }
     /** Pick mode */ get pickMode() {
         return this._pickMode;
@@ -287,7 +281,7 @@ import { XForm } from './xform.js';
     /** @internal */ notifyHiddenChanged() {
         this._visibleChanged();
         for (const child of this._children){
-            if (child.isGraphNode() && child.showState === SceneNode.SHOW_INHERITED) {
+            if (child.showState === SceneNode.SHOW_INHERITED) {
                 child.notifyHiddenChanged();
             }
         }

package/dist/scene/scene_node.js.map

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

package/dist/scene/terrain/grass.js

@@ -1,14 +1,6 @@
 import { nextPowerOf2, Vector2 } from '@zephyr3d/base';
 import { Primitive } from '../../render/primitive.js';
-import '../../material/material.js';
-import '@zephyr3d/device';
-import '../../shaders/framework.js';
 import { Application } from '../../app.js';
-import '../../render/scatteringlut.js';
-import '../../material/lambert.js';
-import '../../material/blinn.js';
-import '../../material/unlit.js';
-import '../../material/lightmodel.js';
 import { GrassMaterial } from '../../material/grassmaterial.js';
 
 class GrassCluster {
@@ -49,8 +41,8 @@ class GrassCluster {
     getSortDistance(camera) {
         return this._terrain.getSortDistance(camera);
     }
-    isTransparency() {
-        return this._terrain.grassMaterial.isTransparent();
+    getQueueType() {
+        return this._terrain.grassMaterial.getQueueType();
     }
     isUnlit() {
         return !this._terrain.grassMaterial.supportLighting();
@@ -60,10 +52,8 @@ class GrassCluster {
     }
     draw(ctx) {
         this._material.alphaToCoverage = Application.instance.device.getFrameBufferSampleCount() > 1;
-        if (this._material.beginDraw(ctx)) {
-            this._primitive.drawInstanced(this._numInstances);
-            this._terrain.grassMaterial.endDraw();
-        }
+        this._material.alphaCutoff = this._material.alphaToCoverage ? 1 : 0.8;
+        this._material.draw(this._primitive, ctx, this._numInstances);
     }
 }
 class GrassManager {

package/dist/scene/terrain/grass.js.map

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

package/dist/scene/terrain/patch.js

@@ -2,7 +2,7 @@ import { Vector4, Vector3 } from '@zephyr3d/base';
 import { BoundingBox } from '../../utility/bounding_volume.js';
 import { Primitive } from '../../render/primitive.js';
 import { Application } from '../../app.js';
-import { RENDER_PASS_TYPE_SHADOWMAP } from '../../values.js';
+import { RENDER_PASS_TYPE_SHADOWMAP, QUEUE_OPAQUE } from '../../values.js';
 
 /** @internal */ class TerrainPatch {
     _terrain;
@@ -108,8 +108,8 @@ import { RENDER_PASS_TYPE_SHADOWMAP } from '../../values.js';
     getSortDistance(camera) {
         return this._quadtree.getTerrain().getSortDistance(camera);
     }
-    isTransparency() {
-        return false;
+    getQueueType() {
+        return QUEUE_OPAQUE;
     }
     isUnlit() {
         return false;

package/dist/scene/terrain/terrain.js

@@ -1,9 +1,9 @@
 import { Vector3, Vector4, Vector2 } from '@zephyr3d/base';
 import { Quadtree } from './quadtree.js';
-import { MAX_DETAIL_TEXTURE_LEVELS, TerrainMaterial } from '../../material/terrainmaterial.js';
 import { GraphNode } from '../graph_node.js';
 import { Application } from '../../app.js';
 import { GrassManager } from './grass.js';
+import { TerrainMaterial } from '../../material/terrainmaterial.js';
 import { GrassMaterial } from '../../material/grassmaterial.js';
 
 /**
@@ -22,7 +22,6 @@ import { GrassMaterial } from '../../material/grassmaterial.js';
     /** @internal */ _height;
     /** @internal */ _material;
     /** @internal */ _grassMaterial;
-    /** @internal */ _maxDetailTextureLevels;
     /** @internal */ _wireframe;
     /** @internal */ _viewPoint;
     /** @internal */ _castShadow;
@@ -45,7 +44,6 @@ import { GrassMaterial } from '../../material/grassmaterial.js';
         this._height = 0;
         this._material = null;
         this._grassMaterial = null;
-        this._maxDetailTextureLevels = MAX_DETAIL_TEXTURE_LEVELS;
         this._wireframe = false;
         this._viewPoint = null;
         this._castShadow = true;
@@ -71,9 +69,6 @@ import { GrassMaterial } from '../../material/grassmaterial.js';
     set castShadow(val) {
         this._castShadow = !!val;
     }
-    /** The maximum value of detail texture levels */ get maxDetailTextureLevels() {
-        return this._maxDetailTextureLevels;
-    }
     /** The maximum pixel error for terrain LOD */ get maxPixelError() {
         return this._maxPixelError;
     }
@@ -148,7 +143,8 @@ import { GrassMaterial } from '../../material/grassmaterial.js';
         this._heightFieldScale.set(scale);
         this._width = sizeX;
         this._height = sizeZ;
-        this._material.lightModel.setNormalMap(this._quadtree.normalMap, null, -1);
+        this._material.normalTexture = this._quadtree.normalMap;
+        this._material.normalTexCoordIndex = -1;
         this._material.terrainInfo = new Vector4(this.scaledWidth, this.scaledHeight, 0, 0);
         this._overridenStateSet = Application.instance.device.createRenderStateSet();
         this._overridenStateSet.useRasterizerState().setCullMode('front');
@@ -196,9 +192,8 @@ import { GrassMaterial } from '../../material/grassmaterial.js';
             this._grassManager = new GrassManager(64, density);
         }
         if (!this._grassMaterial) {
-            this._grassMaterial = new GrassMaterial(new Vector2(this.scaledWidth, this.scaledHeight), this._quadtree.normalMap);
+            this._grassMaterial = new GrassMaterial(new Vector2(this.scaledWidth, this.scaledHeight), this._quadtree.normalMap, grassTexture);
         }
-        this._grassMaterial = new GrassMaterial(new Vector2(this.scaledWidth, this.scaledHeight), this._quadtree.normalMap, grassTexture);
         this._grassMaterial.stateSet.useRasterizerState().setCullMode('none');
         this._grassManager.addGrassLayer(Application.instance.device, this, density, bladeWidth, bladeHeight, offset, grassTexture);
     }

package/dist/scene/terrain/terrain.js.map

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

package/dist/shaders/framework.js

@@ -1,5 +1,5 @@
 import { Vector4 } from '@zephyr3d/base';
-import { RENDER_PASS_TYPE_SHADOWMAP, RENDER_PASS_TYPE_DEPTH_ONLY, RENDER_PASS_TYPE_FORWARD, MAX_CLUSTERED_LIGHTS } from '../values.js';
+import { RENDER_PASS_TYPE_SHADOWMAP, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, MAX_CLUSTERED_LIGHTS } from '../values.js';
 import { Application } from '../app.js';
 import { ScatteringLut } from '../render/scatteringlut.js';
 
@@ -108,12 +108,12 @@ import { ScatteringLut } from '../render/scatteringlut.js';
                 lightStruct('light')
             ]);
             scope.global = globalStruct().uniform(0);
-        } else if (ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH_ONLY) {
+        } else if (ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH) {
             const globalStruct = pb.defineStruct([
                 cameraStruct('camera')
             ]);
             scope.global = globalStruct().uniform(0);
-        } else if (ctx.renderPass.type === RENDER_PASS_TYPE_FORWARD) {
+        } else if (ctx.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
             const useClusteredLighting = !ctx.currentShadowLight;
             const fogStruct = pb.defineStruct([
                 pb.int('fogType'),
@@ -431,6 +431,20 @@ import { ScatteringLut } from '../render/scatteringlut.js';
         return scope.global.camera.viewProjectionMatrix;
     }
     /**
+   * Gets the uniform variable of type mat4 which holds the view matrix of current camera
+   * @param scope - Current shader scope
+   * @returns The view matrix of current camera
+   */ static getViewMatrix(scope) {
+        return scope.global.camera.viewMatrix;
+    }
+    /**
+   * Gets the uniform variable of type mat4 which holds the projection matrix of current camera
+   * @param scope - Current shader scope
+   * @returns The projection matrix of current camera
+   */ static getProjectionMatrix(scope) {
+        return scope.global.camera.projectionMatrix;
+    }
+    /**
    * Gets the uniform variable of type mat4 which holds the view projection matrix of current camera
    * @param scope - Current shader scope
    * @returns The view projection matrix of current camera

package/dist/shaders/framework.js.map

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