@zephyr3d/scene 0.5.0 → 0.6.1

package/dist/render/forward.js

@@ -1,186 +0,0 @@
-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

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

package/dist/render/forward_pass.js

@@ -1,137 +0,0 @@
-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

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

package/dist/render/helper.js

@@ -1,38 +0,0 @@
-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

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

package/dist/render/objectpool.js

@@ -1,295 +0,0 @@
-import { Application } from '../app.js';
-
-/**
- * ObjectPool class is responsible for managing and reusing textures and framebuffers.
- * @public
- */ class ObjectPool {
-    /** @internal */ static _freeTextures = {};
-    /** @internal */ static _allocatedTextures = new WeakMap();
-    /** @internal */ static _autoReleaseTextures = new Set();
-    /** @internal */ static _freeFramebuffers = {};
-    /** @internal */ static _allocatedFramebuffers = new WeakMap();
-    /** @internal */ static _autoReleaseFramebuffers = new Set();
-    /** @internal */ static _lastFrameId = -1;
-    /**
-   * Fetch a temporal 2D texture from the object pool.
-   * @param autoRelease - Whether the texture should be automatically released at the next frame.
-   * @param format - The format of the texture.
-   * @param width - The width of the texture.
-   * @param height - The height of the texture.
-   * @param mipmapping - Whether this texture supports mipmapping
-   * @returns The fetched Texture2D object.
-   */ static fetchTemporalTexture2D(autoRelease, format, width, height, mipmapping) {
-        return this.fetchTemporalTexture(autoRelease, '2d', format, width, height, 0, mipmapping);
-    }
-    /**
-   * Fetch a temporal Cube texture from the object pool.
-   * @param autoRelease - Whether the texture should be automatically released at the next frame.
-   * @param format - The format of the texture.
-   * @param size - Size of the texture.
-   * @param mipmapping - Whether this texture supports mipmapping
-   * @returns The fetched TextureCube object.
-   */ static fetchTemporalTextureCube(autoRelease, format, size, mipmapping) {
-        return this.fetchTemporalTexture(autoRelease, 'cube', format, size, size, 0, mipmapping);
-    }
-    /**
-   * Fetch a temporal 3D texture from the object pool.
-   * @param autoRelease - Whether the texture should be automatically released at the next frame.
-   * @param format - The format of the texture.
-   * @param width - Width of the texture.
-   * @param height - Height of the texture.
-   * @param depth - Depth of the texture.
-   * @param mipmapping - Whether this texture supports mipmapping
-   * @returns The fetched Texture3D object.
-   */ static fetchTemporalTexture3D(autoRelease, format, width, height, depth, mipmapping) {
-        return this.fetchTemporalTexture(autoRelease, '3d', format, width, height, depth, mipmapping);
-    }
-    /**
-   * Fetch a temporal 2D array texture from the object pool.
-   * @param autoRelease - Whether the texture should be automatically released at the next frame.
-   * @param format - The format of the texture.
-   * @param width - Width of the texture.
-   * @param height - Height of the texture.
-   * @param layers - Layers of the texture
-   * @param mipmapping - Whether this texture supports mipmapping
-   * @returns The fetched Texture2DArray object.
-   */ static fetchTemporalTexture2DArray(autoRelease, format, width, height, layers, mipmapping) {
-        return this.fetchTemporalTexture(autoRelease, '2darray', format, width, height, layers, mipmapping);
-    }
-    /**
-   * Fetch a temporal framebuffer from the object pool.
-   * @param autoRelease - Whether the framebuffer should be automatically released at the next frame.
-   * @param colorAttachments - Array of color attachments for the framebuffer.
-   * @param depthAttachment - Depth attachment for the framebuffer.
-   * @param sampleCount - The sample count for the framebuffer.
-   * @param ignoreDepthStencil - Whether to ignore depth stencil.
-   * @returns The fetched FrameBuffer object.
-   */ static fetchTemporalFramebuffer(autoRelease, colorAttachments, depthAttachment, sampleCount, ignoreDepthStencil) {
-        const device = Application.instance.device;
-        this.checkAutoRelease(device);
-        let hash = `${depthAttachment?.uid ?? 0}:${sampleCount ?? 1}:${ignoreDepthStencil ? 1 : 0}`;
-        for (const tex of colorAttachments){
-            hash += `:${tex.uid}`;
-        }
-        let fb = null;
-        const list = this._freeFramebuffers[hash];
-        if (!list) {
-            // Mark referenced textures
-            const info = this._allocatedTextures.get(depthAttachment);
-            if (info) {
-                info.refcount++;
-            }
-            for (const tex of colorAttachments){
-                const info = this._allocatedTextures.get(tex);
-                if (info) {
-                    info.refcount++;
-                }
-            }
-            fb = device.createFrameBuffer(colorAttachments, depthAttachment, {
-                ignoreDepthStencil,
-                sampleCount
-            });
-        } else {
-            fb = list.pop();
-            if (list.length === 0) {
-                delete this._freeFramebuffers[hash];
-            }
-        }
-        this._allocatedFramebuffers.set(fb, hash);
-        if (autoRelease) {
-            this._autoReleaseFramebuffers.add(fb);
-        }
-        return fb;
-    }
-    /**
-   * Dispose a texture that is allocated from the object pool.
-   * @param texture - The texture to dispose.
-   */ static disposeTexture(texture) {
-        this.safeReleaseTexture(texture, true);
-    }
-    /**
-   * Release a texture back to the object pool.
-   * @param texture - The texture to release.
-   */ static releaseTexture(texture) {
-        const info = this._allocatedTextures.get(texture);
-        if (!info) {
-            console.error(`ObjectPool.releaseTexture(): texture is not allocated from pool`);
-        } else {
-            this.safeReleaseTexture(texture);
-        }
-    }
-    /**
-   * Dispose a framebuffer that is allocated from the object pool.
-   * @param fb - The framebuffer to dispose.
-   */ static disposeFrameBuffer(fb) {
-        const hash = this._allocatedFramebuffers.get(fb);
-        if (!hash) {
-            console.error(`ObjectPool.disposeFrameBuffer(): framebuffer is not allocated from pool`);
-        } else {
-            this.internalDisposeFrameBuffer(fb);
-        }
-    }
-    /**
-   * Release a framebuffer back to the object pool.
-   * @param fb - The framebuffer to release.
-   */ static releaseFrameBuffer(fb) {
-        const hash = this._allocatedFramebuffers.get(fb);
-        if (!hash) {
-            console.error(`ObjectPool.releaseFrameBuffer(): framebuffer is not allocated from pool`);
-        } else {
-            this._allocatedFramebuffers.delete(fb);
-            this._autoReleaseFramebuffers.delete(fb);
-            const list = this._freeFramebuffers[hash];
-            if (list) {
-                list.push(fb);
-            } else {
-                this._freeFramebuffers[hash] = [
-                    fb
-                ];
-            }
-        }
-    }
-    /**
-   * Purge the object pool by disposing all free framebuffers and textures.
-   */ static purge() {
-        for(const k in this._freeFramebuffers){
-            const list = this._freeFramebuffers[k];
-            if (list) {
-                for (const fb of this._freeFramebuffers[k]){
-                    this.internalDisposeFrameBuffer(fb);
-                }
-            }
-        }
-        this._freeFramebuffers = {};
-        for(const k in this._freeTextures){
-            const list = this._freeTextures[k];
-            for (const tex of list){
-                tex.dispose();
-            }
-        }
-        this._freeTextures = {};
-    }
-    /**
-   * Fetch a temporal 2D texture from the object pool.
-   * @param autoRelease - Whether the texture should be automatically released at the next frame.
-   * @param format - The format of the texture.
-   * @param width - The width of the texture.
-   * @param height - The height of the texture.
-   * @returns The fetched Texture2D object.
-   */ static fetchTemporalTexture(autoRelease, type, format, width, height, depth, mipmapping) {
-        const device = Application.instance.device;
-        this.checkAutoRelease(device);
-        const hash = `${type}:${format}:${width}:${height}:${depth}:${mipmapping ? 1 : 0}`;
-        let texture = null;
-        const list = this._freeTextures[hash];
-        if (!list) {
-            switch(type){
-                case '2d':
-                    texture = device.createTexture2D(format, width, height, mipmapping ? {} : {
-                        samplerOptions: {
-                            mipFilter: 'none'
-                        }
-                    });
-                    break;
-                case '3d':
-                    texture = device.createTexture3D(format, width, height, depth, mipmapping ? {} : {
-                        samplerOptions: {
-                            mipFilter: 'none'
-                        }
-                    });
-                    break;
-                case '2darray':
-                    texture = device.createTexture2DArray(format, width, height, depth, mipmapping ? {} : {
-                        samplerOptions: {
-                            mipFilter: 'none'
-                        }
-                    });
-                    break;
-                case 'cube':
-                    texture = device.createCubeTexture(format, width, mipmapping ? {} : {
-                        samplerOptions: {
-                            mipFilter: 'none'
-                        }
-                    });
-                    break;
-                default:
-                    throw new Error(`ObjectPool.fetchTemporalTexture(): invalid texture type: ${type}`);
-            }
-        } else {
-            texture = list.pop();
-            if (list.length === 0) {
-                delete this._freeTextures[hash];
-            }
-        }
-        this._allocatedTextures.set(texture, {
-            hash,
-            refcount: 1,
-            dispose: false
-        });
-        if (autoRelease) {
-            this._autoReleaseTextures.add(texture);
-        }
-        return texture;
-    }
-    /** @internal */ static internalDisposeFrameBuffer(fb) {
-        if (fb) {
-            // Release attachment textures
-            const colorAttachments = fb.getColorAttachments();
-            if (colorAttachments) {
-                for (const tex of colorAttachments){
-                    this.safeReleaseTexture(tex);
-                }
-            }
-            const depthAttachment = fb.getDepthAttachment();
-            if (depthAttachment) {
-                this.safeReleaseTexture(depthAttachment);
-            }
-            this._allocatedFramebuffers.delete(fb);
-            this._autoReleaseFramebuffers.delete(fb);
-            fb.dispose();
-        }
-    }
-    /** @internal */ static checkAutoRelease(device) {
-        const frame = device.frameInfo.frameCounter;
-        if (frame !== this._lastFrameId) {
-            // frame changed
-            this._lastFrameId = frame;
-            // auto release objects
-            for (const tex of this._autoReleaseTextures){
-                this.releaseTexture(tex);
-            }
-            this._autoReleaseTextures.clear();
-            for (const fb of this._autoReleaseFramebuffers){
-                this.releaseFrameBuffer(fb);
-            }
-            this._autoReleaseFramebuffers.clear();
-        }
-    }
-    /** @internal */ static safeReleaseTexture(texture, purge = false) {
-        const info = this._allocatedTextures.get(texture);
-        if (info) {
-            info.refcount--;
-            if (info.refcount === 0) {
-                this._allocatedTextures.delete(texture);
-                this._autoReleaseTextures.delete(texture);
-                if (purge || info.dispose) {
-                    texture.dispose();
-                } else {
-                    const list = this._freeTextures[info.hash];
-                    if (list) {
-                        list.push(texture);
-                    } else {
-                        this._freeTextures[info.hash] = [
-                            texture
-                        ];
-                    }
-                }
-            } else if (purge) {
-                info.dispose = true;
-            }
-        }
-    }
-}
-
-export { ObjectPool };
-//# sourceMappingURL=objectpool.js.map

package/dist/render/objectpool.js.map

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