@zephyr3d/scene 0.4.0 → 0.6.0

package/dist/render/lightpass.js

@@ -1,5 +1,5 @@
 import { RenderPass } from './renderpass.js';
-import { RENDER_PASS_TYPE_LIGHT, QUEUE_OPAQUE, QUEUE_TRANSPARENT } from '../values.js';
+import { RENDER_PASS_TYPE_LIGHT, MaterialVaryingFlags, QUEUE_OPAQUE, QUEUE_TRANSPARENT } from '../values.js';
 import { Vector4 } from '@zephyr3d/base';
 import { ShaderHelper } from '../material/shader/helper.js';
 
@@ -8,14 +8,21 @@ import { ShaderHelper } from '../material/shader/helper.js';
  * @internal
  */ class LightPass extends RenderPass {
     /** @internal */ _shadowMapHash;
+    /** @internal */ _transmission;
     /**
    * Creates an instance of ForwardRenderPass
    */ constructor(){
         super(RENDER_PASS_TYPE_LIGHT);
         this._shadowMapHash = null;
     }
+    /** @internal */ get transmission() {
+        return this._transmission;
+    }
+    set transmission(val) {
+        this._transmission = val;
+    }
     /** @internal */ _getGlobalBindGroupHash(ctx) {
-        return `lp:${this._shadowMapHash}:${ctx.linearDepthTexture?.uid ?? ''}:${ctx.oit?.calculateHash() ?? ''}:${ctx.env.getHash(ctx)}`;
+        return `lp:${this._shadowMapHash}:${ctx.oit?.calculateHash() ?? ''}:${ctx.env.getHash(ctx)}`;
     }
     /** @internal */ renderLightPass(ctx, itemList, lights, flags) {
         const baseLightPass = !ctx.lightBlending;
@@ -55,8 +62,10 @@ import { ShaderHelper } from '../material/shader/helper.js';
         ctx.env = ctx.scene.env;
         ctx.drawEnvLight = false;
         ctx.flip = this.isAutoFlip(ctx);
-        const oit = ctx.primaryCamera.oit && ctx.primaryCamera.oit.supportDevice(ctx.device.type) ? ctx.primaryCamera.oit : null;
-        if (!oit) {
+        const ssr = !!(ctx.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS);
+        const tmpFramebuffer = ssr ? ctx.device.pool.fetchTemporalFramebuffer(false, ctx.device.getDrawingBufferWidth(), ctx.device.getDrawingBufferHeight(), ctx.device.getFramebuffer().getColorAttachments()[0], ctx.device.getFramebuffer().getDepthAttachment()) : null;
+        const oit = renderQueue.drawTransparent && ctx.primaryCamera.oit && ctx.primaryCamera.oit.supportDevice(ctx.device.type) ? ctx.primaryCamera.oit : null;
+        if (!oit && renderQueue.drawTransparent) {
             renderQueue.sortTransparentItems(ctx.primaryCamera.getWorldPosition());
         }
         const flags = {
@@ -64,24 +73,27 @@ import { ShaderHelper } from '../material/shader/helper.js';
             cameraSet: {},
             fogSet: {}
         };
-        const orders = Object.keys(renderQueue.items).map((val)=>Number(val)).sort((a, b)=>a - b);
+        const items = renderQueue.itemList;
+        const lists = this._transmission ? [
+            items?.transmission,
+            items?.transmission_trans,
+            items?.transparent
+        ] : [
+            items?.opaque,
+            items?.transparent
+        ];
         for(let i = 0; i < 2; i++){
-            ctx.applyFog = i === 1 && ctx.env.sky.fogType !== 'none' ? ctx.env.sky.fogType : null;
-            ctx.queue = i === 0 ? QUEUE_OPAQUE : QUEUE_TRANSPARENT;
-            ctx.oit = i === 0 ? null : oit;
-            const numOitPasses = ctx.oit ? ctx.oit.begin(ctx) : 1;
-            for(let p = 0; p < numOitPasses; p++){
-                if (ctx.oit) {
-                    if (!ctx.oit.beginPass(ctx, p)) {
-                        continue;
+            if (lists[i]) {
+                ctx.applyFog = i === 1 && ctx.env.sky.fogType !== 'none' ? ctx.env.sky.fogType : null;
+                ctx.queue = i === 0 ? QUEUE_OPAQUE : QUEUE_TRANSPARENT;
+                ctx.oit = i === 0 || !items ? null : oit;
+                const numOitPasses = ctx.oit ? ctx.oit.begin(ctx) : 1;
+                for(let p = 0; p < numOitPasses; p++){
+                    if (ctx.oit) {
+                        if (!ctx.oit.beginPass(ctx, p)) {
+                            continue;
+                        }
                     }
-                }
-                for (const order of orders){
-                    const items = renderQueue.items[order];
-                    const lists = [
-                        items.opaque,
-                        items.transparent
-                    ];
                     let lightIndex = 0;
                     if (ctx.shadowMapInfo) {
                         for (const k of ctx.shadowMapInfo.keys()){
@@ -98,25 +110,53 @@ import { ShaderHelper } from '../material/shader/helper.js';
                         ctx.currentShadowLight = null;
                         ctx.lightBlending = lightIndex > 0;
                         this._shadowMapHash = '';
+                        if (ctx.lightBlending && tmpFramebuffer) {
+                            ctx.materialFlags &= ~MaterialVaryingFlags.SSR_STORE_ROUGHNESS;
+                            ctx.device.pushDeviceStates();
+                            ctx.device.setFramebuffer(tmpFramebuffer);
+                        }
                         this.renderLightPass(ctx, lists[i], renderQueue.unshadowedLights, flags);
+                        if (ctx.lightBlending && tmpFramebuffer) {
+                            ctx.materialFlags |= MaterialVaryingFlags.SSR_STORE_ROUGHNESS;
+                            ctx.device.popDeviceStates();
+                        }
+                    }
+                    if (ctx.oit) {
+                        ctx.oit.endPass(ctx, p);
                     }
                 }
                 if (ctx.oit) {
-                    ctx.oit.endPass(ctx, p);
+                    ctx.oit.end(ctx);
                 }
             }
-            if (ctx.oit) {
-                ctx.oit.end(ctx);
-            }
-            if (i === 0) {
+            if (i === 0 && !ctx.sceneColorTexture) {
+                if (tmpFramebuffer) {
+                    ctx.device.pushDeviceStates();
+                    ctx.device.setFramebuffer(tmpFramebuffer);
+                }
                 ctx.env.sky.skyWorldMatrix = ctx.scene.rootNode.worldMatrix;
                 ctx.env.sky.renderSky(ctx);
+                if (tmpFramebuffer) {
+                    ctx.device.popDeviceStates();
+                }
             }
-            ctx.compositor?.drawPostEffects(ctx, i === 0, ctx.linearDepthTexture);
-            if (i === 0) {
-                ctx.env.sky.renderFog(ctx);
+            if (!renderQueue.needSceneColor || ctx.sceneColorTexture) {
+                if (i === 0) {
+                    if (tmpFramebuffer) {
+                        ctx.device.pushDeviceStates();
+                        ctx.device.setFramebuffer(tmpFramebuffer);
+                    }
+                    ctx.env.sky.renderFog(ctx);
+                    if (tmpFramebuffer) {
+                        ctx.device.popDeviceStates();
+                    }
+                }
+                ctx.compositor?.drawPostEffects(ctx, i === 0, ctx.linearDepthTexture);
             }
         }
+        if (tmpFramebuffer) {
+            ctx.device.pool.releaseFrameBuffer(tmpFramebuffer);
+        }
     }
 }
 

package/dist/render/lightpass.js.map

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

package/dist/render/objectcolorpass.js

@@ -0,0 +1,51 @@
+import { RenderPass } from './renderpass.js';
+import { RENDER_PASS_TYPE_OBJECT_COLOR } from '../values.js';
+import { ShaderHelper } from '../material/shader/helper.js';
+
+/**
+ * Object color render pass
+ * @internal
+ */ class ObjectColorPass extends RenderPass {
+    /**
+   * Creates an instance of ForwardRenderPass
+   */ constructor(){
+        super(RENDER_PASS_TYPE_OBJECT_COLOR);
+    }
+    /** @internal */ _getGlobalBindGroupHash(ctx) {
+        return 'ocp';
+    }
+    /** @internal */ renderItems(ctx, renderQueue) {
+        const items = renderQueue.itemList;
+        if (items) {
+            ctx.applyFog = null;
+            ctx.drawEnvLight = false;
+            ctx.env = null;
+            ctx.picking = true;
+            ctx.flip = this.isAutoFlip(ctx);
+            ctx.renderPassHash = this.getGlobalBindGroupHash(ctx);
+            const bindGroup = ctx.globalBindGroupAllocator.getGlobalBindGroup(ctx);
+            ctx.device.setBindGroup(0, bindGroup);
+            ShaderHelper.setCameraUniforms(bindGroup, ctx.camera, ctx.flip, true);
+            const reverseWinding = ctx.camera.worldMatrixDet < 0;
+            for (const list of [
+                items.opaque,
+                items.transmission,
+                items.transparent,
+                items.transmission_trans
+            ]){
+                if (list) {
+                    for (const lit of list.lit){
+                        this.drawItemList(lit, ctx, reverseWinding);
+                    }
+                    for (const unlit of list.unlit){
+                        this.drawItemList(unlit, ctx, reverseWinding);
+                    }
+                }
+            }
+            ctx.picking = false;
+        }
+    }
+}
+
+export { ObjectColorPass };
+//# sourceMappingURL=objectcolorpass.js.map

package/dist/render/objectcolorpass.js.map

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