@zephyr3d/scene 0.1.0

package/dist/render/envlight.js

@@ -0,0 +1,282 @@
+import { Vector4 } from '@zephyr3d/base';
+import { Application } from '../app.js';
+
+/**
+ * Base class for any kind of environment light
+ * @public
+ */ class EnvironmentLighting {
+    /**
+   * Whether this is an instance of EnvIBL
+   * @returns true if this is an instance of EnvIBL
+   */ isIBL() {
+        return false;
+    }
+    /**
+   * Whether this is an instance of EnvConstantAmbient
+   * @returns true if this is an instance of EnvConstantAmbient
+   */ isConstant() {
+        return false;
+    }
+    /**
+   * Whether this is an instance of EnvHemisphericAmbient
+   * @returns true if this is an instance of EnvHemisphericAmbient
+   */ isHemispheric() {
+        return false;
+    }
+}
+/**
+ * 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 */ _radianceMap;
+    /** @internal */ _irradianceMap;
+    /**
+   * Creates an instance of EnvIBL
+   * @param radianceMap - The radiance map
+   * @param irradianceMap - The irradiance map
+   */ constructor(radianceMap, irradianceMap){
+        super();
+        this._radianceMap = radianceMap || null;
+        this._irradianceMap = irradianceMap || null;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.getType}
+   * @override
+   */ getType() {
+        return 'ibl';
+    }
+    /** The radiance map */ get radianceMap() {
+        return this._radianceMap;
+    }
+    set radianceMap(tex) {
+        this._radianceMap = tex;
+    }
+    /** The irradiance map */ get irradianceMap() {
+        return this._irradianceMap;
+    }
+    set irradianceMap(tex) {
+        this._irradianceMap = tex;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.initShaderBindings}
+   * @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);
+        }
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.updateBindGroup}
+   * @override
+   */ updateBindGroup(bg) {
+        if (this._radianceMap) {
+            bg.setValue('radianceMaxLod', this._radianceMap.mipLevelCount - 1);
+            bg.setTexture('iblRadianceMap', this._radianceMap);
+        }
+        if (this._irradianceMap) {
+            bg.setTexture('iblIrradianceMap', this._irradianceMap);
+        }
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.getRadiance}
+   * @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;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.getIrradiance}
+   * @override
+   */ getIrradiance(scope, normal) {
+        const pb = scope.$builder;
+        return pb.textureSampleLevel(scope.iblIrradianceMap, normal, 0).rgb;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.hasRadiance}
+   * @override
+   */ hasRadiance() {
+        return !!this._radianceMap;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.hasIrradiance}
+   * @override
+   */ hasIrradiance() {
+        return !!this._irradianceMap;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.isIBL}
+   * @override
+   */ isIBL() {
+        return true;
+    }
+}
+/**
+ * Constant ambient light
+ * @public
+ */ class EnvConstantAmbient extends EnvironmentLighting {
+    /** @internal */ static USAGE_CONSTANT_AMBIENT_LIGHTING = 'usage_env_constant_ambient';
+    /** @internal */ static funcNameGetAmbient = 'lib_getConstantAmbient';
+    /** @internal */ _ambientColor;
+    /**
+   * Creates an instance of EnvConstantAmbient
+   * @param ambientColor - The ambient color
+   */ constructor(ambientColor){
+        super();
+        this._ambientColor = ambientColor ? new Vector4(ambientColor) : new Vector4(0, 0, 0, 1);
+    }
+    /** The ambient color */ get ambientColor() {
+        return this._ambientColor;
+    }
+    set ambientColor(ambientColor) {
+        if (ambientColor) {
+            this._ambientColor.set(ambientColor);
+        }
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.getType}
+   * @override
+   */ getType() {
+        return 'constant';
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.initShaderBindings}
+   * @override
+   */ initShaderBindings(pb) {
+        if (pb.shaderKind === 'fragment') {
+            pb.getGlobalScope().ambientLight = pb.vec4().uniform(0).tag(EnvConstantAmbient.USAGE_CONSTANT_AMBIENT_LIGHTING);
+        }
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.updateBindGroup}
+   * @override
+   */ updateBindGroup(bg) {
+        bg.setValue('ambientLight', this._ambientColor);
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.getRadiance}
+   * @override
+   */ getRadiance(scope, refl, roughness) {
+        return null;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.getIrradiance}
+   * @override
+   */ getIrradiance(scope, normal) {
+        return scope.ambientLight.rgb;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.hasRadiance}
+   * @override
+   */ hasRadiance() {
+        return false;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.hasIrradiance}
+   * @override
+   */ hasIrradiance() {
+        return true;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.isConstant}
+   * @override
+   */ isConstant() {
+        return true;
+    }
+}
+/**
+ * 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 */ _ambientUp;
+    /** @internal */ _ambientDown;
+    /**
+   * Creates an instance of EnvConstantAmbient
+   * @param ambientUp - The upside ambient color
+   * @param ambientDown - The downside ambient color
+   */ constructor(ambientUp, ambientDown){
+        super();
+        this._ambientUp = new Vector4(ambientUp);
+        this._ambientDown = new Vector4(ambientDown);
+    }
+    /** The upside ambient color */ get ambientUp() {
+        return this._ambientUp;
+    }
+    set ambientUp(color) {
+        if (color) {
+            this._ambientUp.set(color);
+        }
+    }
+    /** The downside ambient color */ get ambientDown() {
+        return this._ambientDown;
+    }
+    set ambientDown(color) {
+        if (color) {
+            this._ambientDown.set(color);
+        }
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.getType}
+   * @override
+   */ getType() {
+        return 'hemisphere';
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.initShaderBindings}
+   * @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);
+        }
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.updateBindGroup}
+   * @override
+   */ updateBindGroup(bg) {
+        bg.setValue('ambientUp', this._ambientUp);
+        bg.setValue('ambientDown', this._ambientDown);
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.getRadiance}
+   * @override
+   */ getRadiance(scope, refl, roughness) {
+        return null;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.getIrradiance}
+   * @override
+   */ 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;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.hasRadiance}
+   * @override
+   */ hasRadiance() {
+        return false;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.hasIrradiance}
+   * @override
+   */ hasIrradiance() {
+        return true;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.isHemispheric}
+   * @override
+   */ isHemispheric() {
+        return true;
+    }
+}
+
+export { EnvConstantAmbient, EnvHemisphericAmbient, EnvIBL, EnvironmentLighting };
+//# sourceMappingURL=envlight.js.map

package/dist/render/envlight.js.map

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

package/dist/render/forward.js

@@ -0,0 +1,186 @@
+import { ForwardRenderPass } from './forward_pass.js';
+import { ShadowMapPass } from './shadowmap_pass.js';
+import { DepthRenderPass } from './depth_pass.js';
+import { Vector4 } from '@zephyr3d/base';
+import { Application } from '../app.js';
+import '../shaders/framework.js';
+import '@zephyr3d/device';
+import { CopyBlitter } from '../blitter/copy.js';
+import '../scene/octree.js';
+import '../material/material.js';
+import './scatteringlut.js';
+import '../material/lambert.js';
+import '../material/blinn.js';
+import '../material/unlit.js';
+import '../material/lightmodel.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 ForwardRenderScheme {
+    /** @internal */ static _scenePass = new ForwardRenderPass();
+    /** @internal */ static _depthPass = new DepthRenderPass();
+    /** @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,
+            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 { ForwardRenderScheme };
+//# sourceMappingURL=forward.js.map

package/dist/render/forward.js.map

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

package/dist/render/forward_pass.js

@@ -0,0 +1,137 @@
+import { RenderPass } from './renderpass.js';
+import { RENDER_PASS_TYPE_FORWARD } from '../values.js';
+import { ShaderFramework } from '../shaders/framework.js';
+import '@zephyr3d/device';
+import { Application } from '../app.js';
+import { Vector4 } from '@zephyr3d/base';
+
+/**
+ * Forward render pass
+ * @internal
+ */ class ForwardRenderPass extends RenderPass {
+    /** @internal */ _overridenState;
+    /** @internal */ _overridenStateTrans;
+    /** @internal */ _shadowMapHash;
+    /**
+   * Creates an instance of ForwardRenderPass
+   */ constructor(){
+        super(RENDER_PASS_TYPE_FORWARD);
+        this._overridenState = null;
+        this._overridenStateTrans = null;
+        this._shadowMapHash = null;
+    }
+    /** @internal */ applyRenderStates(device, stateSet, ctx) {
+        const overridenStateSet = ctx.userData;
+        if (overridenStateSet) {
+            const depthState = overridenStateSet.depthState;
+            const blendingState = overridenStateSet.blendingState;
+            overridenStateSet.copyFrom(stateSet);
+            overridenStateSet.useBlendingState(blendingState);
+            if (depthState) {
+                overridenStateSet.useDepthState(depthState);
+            }
+            stateSet = overridenStateSet;
+        }
+        device.setRenderStates(stateSet);
+    }
+    /** @internal */ get overridenState() {
+        if (!this._overridenState) {
+            this._overridenState = Application.instance.device.createRenderStateSet();
+            this._overridenState.useBlendingState().enable(true).setBlendFunc('one', 'one');
+        }
+        return this._overridenState;
+    }
+    /** @internal */ get overridenStateTrans() {
+        if (!this._overridenStateTrans) {
+            this._overridenStateTrans = Application.instance.device.createRenderStateSet();
+            this._overridenStateTrans.useBlendingState().enable(true).setBlendFunc('one', 'inv-src-alpha');
+            this._overridenStateTrans.useDepthState().enableTest(true).enableWrite(false);
+        }
+        return this._overridenStateTrans;
+    }
+    /** @internal */ _getGlobalBindGroupHash(ctx) {
+        //return `${ctx.environment?.constructor.name || ''}:${this._shadowMapHash}`;
+        //const envLightHash = ctx.drawEnvLight ? ctx.env.light.type : 'none';
+        //const fogHash = ctx.applyFog ? ctx.env.sky.fogType ?? 'none' : 'none';
+        return `${this._shadowMapHash}:${ctx.env.getHash(ctx)}`;
+    }
+    /** @internal */ renderLightPass(camera, renderQueue, ctx, items, lights, trans, blend) {
+        const device = Application.instance.device;
+        const baseLightPass = !blend;
+        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);
+        ShaderFramework.setCameraUniforms(info.bindGroup, ctx, !!device.getFramebuffer());
+        if (ctx.currentShadowLight) {
+            ShaderFramework.setLightUniformsShadow(info.bindGroup, ctx, lights[0]);
+        } else {
+            ShaderFramework.setLightUniforms(info.bindGroup, ctx, ctx.clusteredLight.clusterParam, ctx.clusteredLight.countParam, ctx.clusteredLight.lightBuffer, ctx.clusteredLight.lightIndexTexture);
+        }
+        if (ctx.applyFog) {
+            ShaderFramework.setFogUniforms(info.bindGroup, ctx.env.sky.mappedFogType, baseLightPass ? ctx.env.sky.fogColor : Vector4.zero(), ctx.env.sky.fogParams, ctx.env.sky.getAerialPerspectiveLUT(ctx));
+        }
+        device.setBindGroup(0, info.bindGroup);
+        if (blend) {
+            ctx.userData = this.overridenState;
+        } else if (trans) {
+            ctx.userData = this.overridenStateTrans;
+        }
+        const reverseWinding = ctx.camera.worldMatrixDet < 0;
+        for (const item of items){
+            // unlit objects should only be drawn once
+            if (!blend || !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';
+            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;
+                        this._shadowMapHash = ctx.shadowMapInfo.get(k).shaderHash;
+                        this.renderLightPass(ctx.camera, renderQueue, ctx, list, [
+                            k
+                        ], i > 0, lightIndex > 0);
+                        lightIndex++;
+                    }
+                }
+                if (lightIndex === 0 || renderQueue.unshadowedLights.length > 0) {
+                    ctx.currentShadowLight = null;
+                    this._shadowMapHash = '';
+                    this.renderLightPass(ctx.camera, renderQueue, ctx, list, renderQueue.unshadowedLights, i > 0, lightIndex > 0);
+                }
+            }
+            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 { ForwardRenderPass };
+//# sourceMappingURL=forward_pass.js.map

package/dist/render/forward_pass.js.map

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

package/dist/render/helper.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=helper.js.map

package/dist/render/helper.js.map

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