@zephyr3d/scene 0.1.2 → 0.2.0

package/dist/posteffect/water.js

@@ -1,21 +1,23 @@
 import { Application } from '../app.js';
 import { Vector4, Interpolator, Vector2, Plane, Matrix4x4, Vector3 } from '@zephyr3d/base';
 import '../scene/octree.js';
-import '../material/material.js';
-import '@zephyr3d/device';
-import '../shaders/framework.js';
-import { decodeNormalizedFloatFromRGBA, linearToGamma } from '../shaders/misc.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 '../render/sky.js';
 import '../render/clipmap.js';
 import { TemporalCache } from '../render/temporalcache.js';
 import { WaterMesh } from '../render/watermesh.js';
 import { AbstractPostEffect } from './posteffect.js';
+import { decodeNormalizedFloatFromRGBA, linearToGamma } from '../shaders/misc.js';
 import { Camera } from '../camera/camera.js';
 import { CopyBlitter } from '../blitter/copy.js';
 import { fresnelSchlick, distributionGGX, visGGX } from '../shaders/pbr.js';
@@ -105,7 +107,7 @@ import { fresnelSchlick, distributionGGX, visGGX } from '../shaders/pbr.js';
             0.41,
             0.34,
             0.13,
-            0.40,
+            0.4,
             0.45,
             0.21,
             0.5,

package/dist/posteffect/water.js.map

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

package/dist/render/cluster_light.js

@@ -1,6 +1,7 @@
 import { Vector4, Matrix4x4 } from '@zephyr3d/base';
 import { Application } from '../app.js';
 import { MAX_CLUSTERED_LIGHTS } from '../values.js';
+import { ShaderHelper } from '../material/shader/helper.js';
 
 class ClusteredLight {
     _tileCountX;
@@ -90,7 +91,7 @@ class ClusteredLight {
                 this.viewMatrix = pb.mat4().uniform(0);
                 this.sizeParam = pb.vec4().uniform(0);
                 this.countParam = pb.ivec4().uniform(0);
-                this.lightBuffer = pb.vec4[(MAX_CLUSTERED_LIGHTS + 1) * 3]().uniformBuffer(0);
+                this[ShaderHelper.getLightBufferUniformName()] = pb.vec4[(MAX_CLUSTERED_LIGHTS + 1) * 3]().uniformBuffer(0);
                 pb.func('lineIntersectionToZPlane', [
                     pb.vec3('a'),
                     pb.vec3('b'),
@@ -173,7 +174,7 @@ class ClusteredLight {
                             this.$if(pb.equal(this.i, this.countParam.w), function() {
                                 this.$break();
                             });
-                            this.$l.light = this.lightBuffer.at(pb.mul(this.i, 3));
+                            this.$l.light = this[ShaderHelper.getLightBufferUniformName()].at(pb.mul(this.i, 3));
                             this.$l.lightPos = pb.mul(this.viewMatrix, pb.vec4(this.light.xyz, 1));
                             this.$l.lightPos.w = this.light.w;
                             this.$if(this.sphereIntersectsAABB(this.lightPos, this.aabbMin, this.aabbMax), function() {
@@ -213,7 +214,7 @@ class ClusteredLight {
                             pb.uint(0)
                         ];
                         this.$for(pb.uint('i'), 1, pb.uint(this.countParam.w), function() {
-                            this.$l.light = this.lightBuffer.at(pb.mul(this.i, 3));
+                            this.$l.light = this[ShaderHelper.getLightBufferUniformName()].at(pb.mul(this.i, 3));
                             this.$l.lightPos = pb.mul(this.viewMatrix, pb.vec4(this.light.xyz, 1));
                             this.$l.lightPos.w = this.light.w;
                             this.$if(this.sphereIntersectsAABB(this.lightPos, this.aabbMin, this.aabbMax), function() {
@@ -241,7 +242,7 @@ class ClusteredLight {
         });
         this._bindGroup = device.createBindGroup(this._lightIndexProgram.bindGroupLayouts[0]);
         this._lightBuffer?.dispose();
-        const lightBufferType = this._lightIndexProgram.getBindingInfo('lightBuffer').type;
+        const lightBufferType = this._lightIndexProgram.getBindingInfo(ShaderHelper.getLightBufferUniformName()).type;
         this._lightBuffer = device.createStructuredBuffer(lightBufferType, {
             usage: 'uniform'
         });
@@ -300,7 +301,7 @@ class ClusteredLight {
             this._bindGroup.setValue('viewMatrix', camera.viewMatrix);
             this._bindGroup.setValue('sizeParam', this._sizeParam);
             this._bindGroup.setValue('countParam', this._countParam);
-            this._bindGroup.setBuffer('lightBuffer', this._lightBuffer);
+            this._bindGroup.setBuffer(ShaderHelper.getLightBufferUniformName(), this._lightBuffer);
             device.setProgram(this._lightIndexProgram);
             device.setVertexLayout(this._lightIndexVertexLayout);
             device.setBindGroup(0, this._bindGroup);

package/dist/render/cluster_light.js.map

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

package/dist/render/depthpass.js

@@ -0,0 +1,46 @@
+import { RenderPass } from './renderpass.js';
+import { RENDER_PASS_TYPE_DEPTH } from '../values.js';
+import { Application } from '../app.js';
+import { ShaderHelper } from '../material/shader/helper.js';
+
+/**
+ * Depth render pass
+ *
+ * Scene depth render pass
+ *
+ * @public
+ */ class DepthPass extends RenderPass {
+    /**
+   * Creates an instance of DepthRenderPass
+   */ constructor(){
+        super(RENDER_PASS_TYPE_DEPTH);
+    }
+    /** @internal */ _getGlobalBindGroupHash(ctx) {
+        return '';
+    }
+    /** @internal */ renderItems(ctx, renderQueue) {
+        ctx.target = null;
+        ctx.applyFog = false;
+        ctx.drawEnvLight = false;
+        ctx.env = null;
+        ctx.renderPassHash = null;
+        ctx.flip = this.isAutoFlip();
+        const device = Application.instance.device;
+        const bindGroup = this.getGlobalBindGroupInfo(ctx).bindGroup;
+        device.setBindGroup(0, bindGroup);
+        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)){
+            const renderItems = renderQueue.items[order];
+            for (const item of renderItems.opaqueList){
+                ctx.instanceData = item.instanceData;
+                ctx.target = item.drawable;
+                this.drawItem(device, item, ctx, reverseWinding);
+            }
+        }
+    }
+}
+
+export { DepthPass };
+//# sourceMappingURL=depthpass.js.map

package/dist/render/depthpass.js.map

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

package/dist/render/envlight.js

@@ -28,9 +28,9 @@ import { Application } from '../app.js';
  * IBL based environment lighting
  * @public
  */ class EnvIBL extends EnvironmentLighting {
-    /** @internal */ static USAGE_IBL_RADIANCE_MAP = 'usage_ibl_radiance_map';
-    /** @internal */ static USAGE_IBL_RADIANCE_MAP_MAX_LOD = 'usage_ibl_radiance_map_maxlod';
-    /** @internal */ static USAGE_IBL_IRRADIANCE_MAP = 'usage_ibl_irradiance_map';
+    /** @internal */ static UNIFORM_NAME_IBL_RADIANCE_MAP = 'zIBLRadianceMap';
+    /** @internal */ static UNIFORM_NAME_IBL_RADIANCE_MAP_MAX_LOD = 'zIBLRadianceMapMaxLOD';
+    /** @internal */ static UNIFORM_NAME_IBL_IRRADIANCE_MAP = 'zIBLIrradianceMap';
     /** @internal */ _radianceMap;
     /** @internal */ _irradianceMap;
     /**
@@ -65,9 +65,13 @@ import { Application } from '../app.js';
    * @override
    */ initShaderBindings(pb) {
         if (pb.shaderKind === 'fragment') {
-            pb.getGlobalScope().iblRadianceMap = pb.texCube().uniform(0).tag(EnvIBL.USAGE_IBL_RADIANCE_MAP);
-            pb.getGlobalScope().iblIrradianceMap = pb.texCube().uniform(0).tag(EnvIBL.USAGE_IBL_IRRADIANCE_MAP);
-            pb.getGlobalScope().radianceMaxLod = pb.float('radianceMaxLod').uniform(0).tag(EnvIBL.USAGE_IBL_RADIANCE_MAP_MAX_LOD);
+            if (this._radianceMap) {
+                pb.getGlobalScope()[EnvIBL.UNIFORM_NAME_IBL_RADIANCE_MAP] = pb.texCube().uniform(0);
+                pb.getGlobalScope()[EnvIBL.UNIFORM_NAME_IBL_RADIANCE_MAP_MAX_LOD] = pb.float().uniform(0);
+            }
+            if (this._irradianceMap) {
+                pb.getGlobalScope()[EnvIBL.UNIFORM_NAME_IBL_IRRADIANCE_MAP] = pb.texCube().uniform(0);
+            }
         }
     }
     /**
@@ -75,11 +79,11 @@ import { Application } from '../app.js';
    * @override
    */ updateBindGroup(bg) {
         if (this._radianceMap) {
-            bg.setValue('radianceMaxLod', this._radianceMap.mipLevelCount - 1);
-            bg.setTexture('iblRadianceMap', this._radianceMap);
+            bg.setValue(EnvIBL.UNIFORM_NAME_IBL_RADIANCE_MAP_MAX_LOD, this._radianceMap.mipLevelCount - 1);
+            bg.setTexture(EnvIBL.UNIFORM_NAME_IBL_RADIANCE_MAP, this._radianceMap);
         }
         if (this._irradianceMap) {
-            bg.setTexture('iblIrradianceMap', this._irradianceMap);
+            bg.setTexture(EnvIBL.UNIFORM_NAME_IBL_IRRADIANCE_MAP, this._irradianceMap);
         }
     }
     /**
@@ -87,14 +91,14 @@ import { Application } from '../app.js';
    * @override
    */ getRadiance(scope, refl, roughness) {
         const pb = scope.$builder;
-        return Application.instance.device.getDeviceCaps().shaderCaps.supportShaderTextureLod ? pb.textureSampleLevel(scope.iblRadianceMap, refl, pb.mul(roughness, scope.radianceMaxLod)).rgb : pb.textureSample(scope.iblRadianceMap, refl).rgb;
+        return Application.instance.device.getDeviceCaps().shaderCaps.supportShaderTextureLod ? pb.textureSampleLevel(scope[EnvIBL.UNIFORM_NAME_IBL_RADIANCE_MAP], refl, pb.mul(roughness, scope[EnvIBL.UNIFORM_NAME_IBL_RADIANCE_MAP_MAX_LOD])).rgb : pb.textureSample(scope[EnvIBL.UNIFORM_NAME_IBL_RADIANCE_MAP], refl).rgb;
     }
     /**
    * {@inheritDoc EnvironmentLighting.getIrradiance}
    * @override
    */ getIrradiance(scope, normal) {
         const pb = scope.$builder;
-        return pb.textureSampleLevel(scope.iblIrradianceMap, normal, 0).rgb;
+        return pb.textureSampleLevel(scope[EnvIBL.UNIFORM_NAME_IBL_IRRADIANCE_MAP], normal, 0).rgb;
     }
     /**
    * {@inheritDoc EnvironmentLighting.hasRadiance}
@@ -119,8 +123,7 @@ import { Application } from '../app.js';
  * Constant ambient light
  * @public
  */ class EnvConstantAmbient extends EnvironmentLighting {
-    /** @internal */ static USAGE_CONSTANT_AMBIENT_LIGHTING = 'usage_env_constant_ambient';
-    /** @internal */ static funcNameGetAmbient = 'lib_getConstantAmbient';
+    /** @internal */ static UNIFORM_NAME_CONSTANT_AMBIENT = 'zConstantAmbient';
     /** @internal */ _ambientColor;
     /**
    * Creates an instance of EnvConstantAmbient
@@ -148,14 +151,14 @@ import { Application } from '../app.js';
    * @override
    */ initShaderBindings(pb) {
         if (pb.shaderKind === 'fragment') {
-            pb.getGlobalScope().ambientLight = pb.vec4().uniform(0).tag(EnvConstantAmbient.USAGE_CONSTANT_AMBIENT_LIGHTING);
+            pb.getGlobalScope()[EnvConstantAmbient.UNIFORM_NAME_CONSTANT_AMBIENT] = pb.vec4().uniform(0);
         }
     }
     /**
    * {@inheritDoc EnvironmentLighting.updateBindGroup}
    * @override
    */ updateBindGroup(bg) {
-        bg.setValue('ambientLight', this._ambientColor);
+        bg.setValue(EnvConstantAmbient.UNIFORM_NAME_CONSTANT_AMBIENT, this._ambientColor);
     }
     /**
    * {@inheritDoc EnvironmentLighting.getRadiance}
@@ -167,7 +170,7 @@ import { Application } from '../app.js';
    * {@inheritDoc EnvironmentLighting.getIrradiance}
    * @override
    */ getIrradiance(scope, normal) {
-        return scope.ambientLight.rgb;
+        return scope[EnvConstantAmbient.UNIFORM_NAME_CONSTANT_AMBIENT].rgb;
     }
     /**
    * {@inheritDoc EnvironmentLighting.hasRadiance}
@@ -192,9 +195,8 @@ import { Application } from '../app.js';
  * Hemispheric ambient light
  * @public
  */ class EnvHemisphericAmbient extends EnvironmentLighting {
-    /** @internal */ static USAGE_CONSTANT_AMBIENT_UP = 'usage_env_ambient_up';
-    /** @internal */ static USAGE_CONSTANT_AMBIENT_DOWN = 'usage_env_ambient_down';
-    /** @internal */ static funcNameGetAmbient = 'lib_getConstantAmbient';
+    /** @internal */ static UNIFORM_NAME_AMBIENT_UP = 'zHemisphericAmbientUp';
+    /** @internal */ static UNIFORM_NAME_AMBIENT_DOWN = 'zHemisphericAmbientDown';
     /** @internal */ _ambientUp;
     /** @internal */ _ambientDown;
     /**
@@ -233,16 +235,16 @@ import { Application } from '../app.js';
    * @override
    */ initShaderBindings(pb) {
         if (pb.shaderKind === 'fragment') {
-            pb.getGlobalScope().ambientUp = pb.vec4().uniform(0).tag(EnvHemisphericAmbient.USAGE_CONSTANT_AMBIENT_UP);
-            pb.getGlobalScope().ambientDown = pb.vec4().uniform(0).tag(EnvHemisphericAmbient.USAGE_CONSTANT_AMBIENT_DOWN);
+            pb.getGlobalScope()[EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_UP] = pb.vec4().uniform(0);
+            pb.getGlobalScope()[EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_DOWN] = pb.vec4().uniform(0);
         }
     }
     /**
    * {@inheritDoc EnvironmentLighting.updateBindGroup}
    * @override
    */ updateBindGroup(bg) {
-        bg.setValue('ambientUp', this._ambientUp);
-        bg.setValue('ambientDown', this._ambientDown);
+        bg.setValue(EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_UP, this._ambientUp);
+        bg.setValue(EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_DOWN, this._ambientDown);
     }
     /**
    * {@inheritDoc EnvironmentLighting.getRadiance}
@@ -256,7 +258,7 @@ import { Application } from '../app.js';
    */ getIrradiance(scope, normal) {
         const pb = scope.$builder;
         const factor = pb.add(pb.mul(normal.y, 0.5), 0.5);
-        return pb.mix(scope.ambientDown, scope.ambientUp, factor).rgb;
+        return pb.mix(scope[EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_DOWN], scope[EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_UP], factor).rgb;
     }
     /**
    * {@inheritDoc EnvironmentLighting.hasRadiance}

package/dist/render/envlight.js.map

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

package/dist/render/fullscreenquad.js

@@ -0,0 +1,38 @@
+import { Application } from '../app.js';
+
+let quadVertexLayout = null;
+let quadRenderStateSet = null;
+function drawFullscreenQuad(renderStates) {
+    const device = Application.instance.device;
+    if (!quadVertexLayout) {
+        quadVertexLayout = device.createVertexLayout({
+            vertexBuffers: [
+                {
+                    buffer: device.createVertexBuffer('position_f32x2', new Float32Array([
+                        -1,
+                        -1,
+                        1,
+                        -1,
+                        -1,
+                        1,
+                        1,
+                        1
+                    ]))
+                }
+            ]
+        });
+    }
+    if (!quadRenderStateSet) {
+        quadRenderStateSet = device.createRenderStateSet();
+        quadRenderStateSet.useRasterizerState().setCullMode('none');
+        quadRenderStateSet.useDepthState().enableTest(false).enableWrite(false);
+    }
+    const saveRenderStateSet = device.getRenderStates();
+    device.setRenderStates(renderStates ?? quadRenderStateSet);
+    device.setVertexLayout(quadVertexLayout);
+    device.draw('triangle-strip', 0, 4);
+    device.setRenderStates(saveRenderStateSet);
+}
+
+export { drawFullscreenQuad };
+//# sourceMappingURL=fullscreenquad.js.map

package/dist/render/fullscreenquad.js.map

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

package/dist/render/lightpass.js

@@ -0,0 +1,98 @@
+import { RenderPass } from './renderpass.js';
+import { RENDER_PASS_TYPE_LIGHT, QUEUE_OPAQUE, QUEUE_TRANSPARENT } from '../values.js';
+import { Application } from '../app.js';
+import { Vector4 } from '@zephyr3d/base';
+import { ShaderHelper } from '../material/shader/helper.js';
+
+/**
+ * Forward render pass
+ * @internal
+ */ class LightPass extends RenderPass {
+    /** @internal */ _shadowMapHash;
+    /**
+   * Creates an instance of ForwardRenderPass
+   */ constructor(){
+        super(RENDER_PASS_TYPE_LIGHT);
+        this._shadowMapHash = null;
+    }
+    /** @internal */ _getGlobalBindGroupHash(ctx) {
+        return `${this._shadowMapHash}:${ctx.env.getHash(ctx)}`;
+    }
+    /** @internal */ renderLightPass(ctx, items, lights) {
+        const device = Application.instance.device;
+        const baseLightPass = !ctx.lightBlending;
+        ctx.drawEnvLight = baseLightPass && ctx.env.light.type !== 'none' && (ctx.env.light.envLight.hasRadiance() || ctx.env.light.envLight.hasIrradiance());
+        ctx.renderPassHash = this.getGlobalBindGroupHash(ctx);
+        const info = this.getGlobalBindGroupInfo(ctx);
+        ShaderHelper.setCameraUniforms(info.bindGroup, ctx, !!device.getFramebuffer());
+        if (ctx.currentShadowLight) {
+            ShaderHelper.setLightUniformsShadow(info.bindGroup, ctx, lights[0]);
+        } else {
+            ShaderHelper.setLightUniforms(info.bindGroup, ctx, ctx.clusteredLight.clusterParam, ctx.clusteredLight.countParam, ctx.clusteredLight.lightBuffer, ctx.clusteredLight.lightIndexTexture);
+        }
+        if (ctx.applyFog) {
+            ShaderHelper.setFogUniforms(info.bindGroup, ctx.env.sky.mappedFogType, baseLightPass ? ctx.env.sky.fogColor : Vector4.zero(), ctx.env.sky.fogParams, ctx.env.sky.aerialPerspectiveDensity * ctx.env.sky.aerialPerspectiveDensity, ctx.env.sky.getAerialPerspectiveLUT(ctx));
+        }
+        device.setBindGroup(0, info.bindGroup);
+        const reverseWinding = ctx.camera.worldMatrixDet < 0;
+        for (const item of items){
+            // unlit objects should only be drawn once
+            if (!ctx.lightBlending || !item.drawable.isUnlit()) {
+                ctx.instanceData = item.instanceData;
+                ctx.target = item.drawable;
+                this.drawItem(device, item, ctx, reverseWinding);
+            }
+        }
+    }
+    /** @internal */ renderItems(ctx, renderQueue) {
+        ctx.applyFog = false;
+        ctx.target = null;
+        ctx.renderPassHash = null;
+        ctx.env = ctx.scene.env;
+        ctx.drawEnvLight = false;
+        ctx.flip = this.isAutoFlip();
+        renderQueue.sortItems();
+        const orders = Object.keys(renderQueue.items).map((val)=>Number(val)).sort((a, b)=>a - b);
+        for(let i = 0; i < 2; i++){
+            ctx.applyFog = i === 1 && ctx.env.sky.fogType !== 'none';
+            ctx.queue = i === 0 ? QUEUE_OPAQUE : QUEUE_TRANSPARENT;
+            for (const order of orders){
+                const items = renderQueue.items[order];
+                const lists = [
+                    items.opaqueList,
+                    items.transList
+                ];
+                const list = lists[i];
+                let lightIndex = 0;
+                if (ctx.shadowMapInfo) {
+                    for (const k of ctx.shadowMapInfo.keys()){
+                        ctx.currentShadowLight = k;
+                        ctx.lightBlending = lightIndex > 0;
+                        this._shadowMapHash = ctx.shadowMapInfo.get(k).shaderHash;
+                        this.renderLightPass(ctx, list, [
+                            k
+                        ]);
+                        lightIndex++;
+                    }
+                }
+                if (lightIndex === 0 || renderQueue.unshadowedLights.length > 0) {
+                    ctx.currentShadowLight = null;
+                    ctx.lightBlending = lightIndex > 0;
+                    this._shadowMapHash = '';
+                    this.renderLightPass(ctx, list, renderQueue.unshadowedLights);
+                }
+            }
+            if (i === 0) {
+                ctx.env.sky.skyWorldMatrix = ctx.scene.rootNode.worldMatrix;
+                ctx.env.sky.renderSky(ctx);
+            }
+            ctx.compositor?.drawPostEffects(ctx, i === 0, ctx.linearDepthTexture);
+            if (i === 0) {
+                ctx.env.sky.renderFog(ctx);
+            }
+        }
+    }
+}
+
+export { LightPass };
+//# sourceMappingURL=lightpass.js.map

package/dist/render/lightpass.js.map

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

package/dist/render/render_queue.js

@@ -1,4 +1,5 @@
 import { Application } from '../app.js';
+import { QUEUE_TRANSPARENT } from '../values.js';
 
 /**
  * A queue that contains the items to be rendered
@@ -81,7 +82,7 @@ import { Application } from '../app.js';
                 };
                 this._itemLists[renderOrder] = itemList;
             }
-            const trans = drawable.isTransparency();
+            const trans = drawable.getQueueType() === QUEUE_TRANSPARENT;
             const list = trans ? itemList.transList : itemList.opaqueList;
             if (drawable.isBatchable()) {
                 const instanceList = trans ? itemList.transInstanceList : itemList.opaqueInstanceList;

package/dist/render/render_queue.js.map

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

package/dist/render/renderer.js

@@ -0,0 +1,191 @@
+import { LightPass } from './lightpass.js';
+import { ShadowMapPass } from './shadowmap_pass.js';
+import { DepthPass } from './depthpass.js';
+import { Vector4 } from '@zephyr3d/base';
+import { Application } from '../app.js';
+import '@zephyr3d/device';
+import { CopyBlitter } from '../blitter/copy.js';
+import '../scene/octree.js';
+import '../material/shader/helper.js';
+import '../material/lambert.js';
+import '../material/blinn.js';
+import '../material/unlit.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 './sky.js';
+import './clipmap.js';
+import { TemporalCache } from './temporalcache.js';
+import './watermesh.js';
+import { ShadowMapper } from '../shadow/shadowmapper.js';
+import { ClusteredLight } from './cluster_light.js';
+
+/**
+ * Forward render scheme
+ * @internal
+ */ class SceneRenderer {
+    /** @internal */ static _scenePass = new LightPass();
+    /** @internal */ static _depthPass = new DepthPass();
+    /** @internal */ static _shadowMapPass = new ShadowMapPass();
+    /** @internal */ static _enableDepthPass = false;
+    /** @internal */ static _clusters = [];
+    /** @internal */ static setClearColor(color) {
+        this._scenePass.clearColor = color;
+    }
+    /** @internal */ static getClusteredLight() {
+        if (this._clusters.length > 0) {
+            return this._clusters.pop();
+        }
+        return new ClusteredLight();
+    }
+    /** @internal */ static freeClusteredLight(clusteredLight) {
+        this._clusters.push(clusteredLight);
+    }
+    /**
+   * Renders a scene by given camera
+   * @param scene - The scene to be rendered
+   * @param camera - The camera that will be used to render the scene
+   * @param compositor - The compositor that will be used to apply postprocess effects
+   */ static renderScene(scene, camera, compositor, logger) {
+        const device = Application.instance.device;
+        const ctx = {
+            scene,
+            primaryCamera: camera,
+            camera,
+            compositor: compositor?.needDrawPostEffects() ? compositor : null,
+            timestamp: device.frameInfo.frameTimestamp,
+            logger,
+            queue: 0,
+            lightBlending: false,
+            target: null,
+            renderPass: null,
+            renderPassHash: null,
+            applyFog: false,
+            flip: false,
+            drawEnvLight: false,
+            env: null
+        };
+        scene.frameUpdate();
+        if (camera && !device.isContextLost()) {
+            this._renderScene(ctx);
+        }
+    }
+    /** @internal */ static _renderSceneDepth(ctx, renderQueue, depthFramebuffer) {
+        const device = Application.instance.device;
+        device.pushDeviceStates();
+        device.setFramebuffer(depthFramebuffer);
+        this._depthPass.clearColor = device.type === 'webgl' ? new Vector4(0, 0, 0, 1) : new Vector4(1, 1, 1, 1);
+        this._depthPass.render(ctx, null, renderQueue);
+        device.popDeviceStates();
+    }
+    /** @internal */ static _renderScene(ctx) {
+        const device = Application.instance.device;
+        const vp = ctx.camera.viewport;
+        const scissor = ctx.camera.scissor;
+        const finalFramebuffer = device.getFramebuffer();
+        const drawingBufferWidth = device.getDrawingBufferWidth();
+        const drawingBufferHeight = device.getDrawingBufferHeight();
+        ctx.depthFormat = 'd24s8';
+        ctx.viewportX = finalFramebuffer ? vp?.[0] ?? 0 : device.screenToDevice(vp?.[0] ?? 0);
+        ctx.viewportY = finalFramebuffer ? vp?.[1] ?? 0 : device.screenToDevice(vp?.[1] ?? 0);
+        ctx.viewportWidth = finalFramebuffer ? vp?.[2] ?? finalFramebuffer.getWidth() : vp ? device.screenToDevice(vp[2]) : device.getDrawingBufferWidth();
+        ctx.viewportHeight = finalFramebuffer ? vp?.[3] ?? finalFramebuffer.getHeight() : vp ? device.screenToDevice(vp[3]) : device.getDrawingBufferHeight();
+        ctx.defaultViewport = !finalFramebuffer && !vp;
+        const oversizedViewport = vp && !device.getDeviceCaps().miscCaps.supportOversizedViewport && (ctx.viewportX < 0 || ctx.viewportY < 0 || ctx.viewportX + ctx.viewportWidth > drawingBufferWidth || ctx.viewportY + ctx.viewportHeight > drawingBufferHeight);
+        // TODO: determin the color buffer format
+        const colorFmt = device.getDeviceCaps().textureCaps.supportHalfFloatColorBuffer ? 'rgba16f' : 'rgba8unorm';
+        let tempFramebuffer = null;
+        let depthFramebuffer = null;
+        const renderQueue = this._scenePass.cullScene(ctx, ctx.camera);
+        ctx.sunLight = renderQueue.sunLight;
+        ctx.clusteredLight = this.getClusteredLight();
+        ctx.clusteredLight.calculateLightIndex(ctx.camera, renderQueue);
+        this.renderShadowMaps(ctx, renderQueue.shadowedLights);
+        const sampleCount = ctx.compositor ? 1 : ctx.primaryCamera.sampleCount;
+        if (this._enableDepthPass || oversizedViewport || ctx.scene.env.needSceneDepthTexture() || ctx.compositor?.requireLinearDepth()) {
+            const format = device.type === 'webgl' ? 'rgba8unorm' : 'r32f';
+            if (!finalFramebuffer && !vp) {
+                depthFramebuffer = TemporalCache.getFramebufferVariantSize(drawingBufferWidth, drawingBufferHeight, 1, format, ctx.depthFormat, '2d', '2d', false);
+            } else {
+                const originDepth = finalFramebuffer?.getDepthAttachment();
+                depthFramebuffer = originDepth?.isTexture2D() ? TemporalCache.getFramebufferFixedSizeWithDepth(originDepth, 1, format, '2d', false) : TemporalCache.getFramebufferFixedSize(ctx.viewportWidth, ctx.viewportHeight, 1, format, ctx.depthFormat, '2d', '2d', false);
+            }
+            this._renderSceneDepth(ctx, renderQueue, depthFramebuffer);
+            ctx.linearDepthTexture = depthFramebuffer.getColorAttachments()[0];
+            ctx.depthTexture = depthFramebuffer.getDepthAttachment();
+            if (ctx.depthTexture === finalFramebuffer?.getDepthAttachment()) {
+                tempFramebuffer = finalFramebuffer;
+            } else {
+                if (ctx.defaultViewport) {
+                    tempFramebuffer = TemporalCache.getFramebufferVariantSize(ctx.depthTexture.width, ctx.depthTexture.height, 1, colorFmt, ctx.depthFormat, '2d', '2d', false, sampleCount);
+                } else {
+                    tempFramebuffer = TemporalCache.getFramebufferFixedSize(ctx.depthTexture.width, ctx.depthTexture.height, 1, colorFmt, ctx.depthFormat, '2d', '2d', false, sampleCount);
+                }
+            }
+        } else {
+            ctx.linearDepthTexture = null;
+            ctx.depthTexture = null;
+            if (!vp) {
+                tempFramebuffer = finalFramebuffer;
+            } else {
+                tempFramebuffer = TemporalCache.getFramebufferFixedSize(ctx.viewportWidth, ctx.viewportHeight, 1, colorFmt, ctx.depthFormat, '2d', '2d', false, sampleCount);
+            }
+        }
+        if (tempFramebuffer && tempFramebuffer !== finalFramebuffer) {
+            device.pushDeviceStates();
+            device.setFramebuffer(tempFramebuffer);
+        } else {
+            device.setViewport(vp);
+            device.setScissor(scissor);
+        }
+        this._scenePass.clearDepth = 1; //ctx.depthTexture ? null : 1;
+        this._scenePass.clearStencil = 0; //ctx.depthTexture ? null : 0;
+        ctx.compositor?.begin(ctx);
+        this._scenePass.render(ctx, null, renderQueue);
+        ctx.compositor?.end(ctx);
+        if (tempFramebuffer && tempFramebuffer !== finalFramebuffer) {
+            const blitter = new CopyBlitter();
+            if (oversizedViewport) {
+                blitter.destRect = [
+                    ctx.viewportX,
+                    ctx.viewportY,
+                    ctx.viewportWidth,
+                    ctx.viewportHeight
+                ];
+            } else {
+                blitter.viewport = vp;
+            }
+            blitter.scissor = scissor;
+            blitter.srgbOut = !finalFramebuffer;
+            const srcTex = tempFramebuffer.getColorAttachments()[0];
+            blitter.blit(srcTex, finalFramebuffer ?? null, device.createSampler({
+                magFilter: 'nearest',
+                minFilter: 'nearest',
+                mipFilter: 'none'
+            }));
+            device.popDeviceStates();
+        }
+        if (depthFramebuffer) {
+            TemporalCache.releaseFramebuffer(depthFramebuffer);
+        }
+        if (tempFramebuffer && tempFramebuffer !== finalFramebuffer) {
+            TemporalCache.releaseFramebuffer(tempFramebuffer);
+        }
+        ShadowMapper.releaseTemporalResources(ctx);
+        this.freeClusteredLight(ctx.clusteredLight);
+    }
+    /** @internal */ static renderShadowMaps(ctx, lights) {
+        ctx.renderPass = this._shadowMapPass;
+        Application.instance.device.pushDeviceStates();
+        for (const light of lights){
+            light.shadow.render(ctx, this._shadowMapPass);
+        }
+        Application.instance.device.popDeviceStates();
+    }
+}
+
+export { SceneRenderer };
+//# sourceMappingURL=renderer.js.map