@zephyr3d/scene 0.1.0

package/dist/posteffect/posteffect.js

@@ -0,0 +1,165 @@
+import { Application } from '../app.js';
+import { drawFullscreenQuad } from '../render/helper.js';
+
+/**
+ * Base class for any type of post effect
+ * @public
+ */ class AbstractPostEffect {
+    _outputTexture;
+    _quadVertexLayout;
+    _quadRenderStateSet;
+    _enabled;
+    _opaque;
+    _intermediateFramebuffers;
+    /**
+   * Creates an instance of a post effect
+   * @param name - Name of the post effect
+   */ constructor(){
+        this._outputTexture = null;
+        this._quadVertexLayout = null;
+        this._quadRenderStateSet = null;
+        this._enabled = true;
+        this._opaque = false;
+        this._intermediateFramebuffers = {};
+    }
+    /** Whether this post effect is enabled */ get enabled() {
+        return this._enabled;
+    }
+    set enabled(val) {
+        this._enabled = !!val;
+    }
+    /** Whether this post effect will be rendered at opaque phase */ get opaque() {
+        return this._opaque;
+    }
+    /**
+   * Check if the post effect should be rendered upside down.
+   * @param device - The device object
+   * @returns true if the post effect should be rendered upside down
+   */ needFlip(device) {
+        return device.type === 'webgpu' && !!device.getFramebuffer();
+    }
+    /**
+   * Adds an intermediate frame buffer
+   * @param name - Name of the frame buffer
+   * @param format - Render target texture format
+   * @param useDepth - Whether the scene depth buffer should be attached to the frame buffer
+   */ addIntermediateFramebuffer(name, depth) {
+        if (this._intermediateFramebuffers[name]) {
+            throw new Error(`Intermediate framebuffer already exists: ${name}`);
+        }
+        this._intermediateFramebuffers[name] = {
+            depth,
+            framebuffer: null
+        };
+    }
+    /**
+   * Gets the intermediate frame buffer by name
+   * @param name - Name of the intermediate frame buffer
+   * @param width - Width of the frame buffer
+   * @param height - Height of the frame buffer
+   * @returns The intermediate frame buffer or null if not exists
+   *
+   * @remarks
+   * The intemediate buffer will be resized to fit the given size if needed
+   */ getIntermediateFramebuffer(name, format, width, height) {
+        const fb = this._intermediateFramebuffers[name];
+        if (!fb) {
+            return null;
+        }
+        const device = Application.instance.device;
+        const currentDepthBuffer = device.getFramebuffer().getDepthAttachment();
+        if (fb.framebuffer) {
+            const colorTex = fb.framebuffer.getColorAttachments()[0];
+            const depthTex = fb.framebuffer.getDepthAttachment();
+            if (colorTex.width !== width || colorTex.height !== height || colorTex.format !== format) {
+                fb.framebuffer.dispose();
+                colorTex.dispose();
+                if (depthTex && depthTex !== currentDepthBuffer) {
+                    depthTex.dispose();
+                }
+                fb.framebuffer = null;
+            }
+        }
+        if (!fb.framebuffer) {
+            const colorTex = device.createTexture2D(format, width, height, {
+                samplerOptions: {
+                    mipFilter: 'none'
+                }
+            });
+            colorTex.name = `Intermediate-<${name}>`;
+            let depthTex = null;
+            if (fb.depth === 'current') {
+                depthTex = currentDepthBuffer;
+            } else if (fb.depth === 'temporal') {
+                depthTex = device.createTexture2D('d24s8', width, height);
+                depthTex.name = `Intermediate-<${name}>-depth`;
+            }
+            fb.framebuffer = device.createFrameBuffer([
+                colorTex
+            ], depthTex);
+        }
+        return fb.framebuffer;
+    }
+    /**
+   * Disposes the post effect.
+   */ dispose() {
+        this._quadVertexLayout?.dispose();
+        this._quadVertexLayout = null;
+        this._quadRenderStateSet = null;
+        for(const k in this._intermediateFramebuffers){
+            const fb = this._intermediateFramebuffers[k];
+            if (fb) {
+                const colorAttachment = fb.framebuffer.getColorAttachments()[0];
+                fb.framebuffer.dispose();
+                colorAttachment.dispose();
+            }
+        }
+        this._intermediateFramebuffers = {};
+    }
+    /**
+   * Draws a fullscreen quad
+   * @param renderStateSet - Render states that will be used when drawing the fullscreen quad.
+   */ drawFullscreenQuad(renderStateSet) {
+        drawFullscreenQuad(renderStateSet);
+    /*
+    const device = Application.instance.device;
+    if (!this._quadVertexLayout) {
+      this._quadVertexLayout = this.createVertexLayout(device);
+    }
+    if (!this._quadRenderStateSet) {
+      this._quadRenderStateSet = this.createRenderStates(device);
+    }
+    const lastRenderState = device.getRenderStates();
+    device.setVertexLayout(this._quadVertexLayout);
+    device.setRenderStates(renderStateSet ?? this._quadRenderStateSet);
+    device.draw('triangle-strip', 0, 4);
+    device.setRenderStates(lastRenderState);
+    */ }
+    /** @internal */ createVertexLayout(device) {
+        return device.createVertexLayout({
+            vertexBuffers: [
+                {
+                    buffer: device.createVertexBuffer('position_f32x2', new Float32Array([
+                        -1,
+                        -1,
+                        1,
+                        -1,
+                        -1,
+                        1,
+                        1,
+                        1
+                    ]))
+                }
+            ]
+        });
+    }
+    /** @internal */ createRenderStates(device) {
+        const renderStates = device.createRenderStateSet();
+        renderStates.useRasterizerState().setCullMode('none');
+        renderStates.useDepthState().enableTest(false).enableWrite(false);
+        return renderStates;
+    }
+}
+
+export { AbstractPostEffect };
+//# sourceMappingURL=posteffect.js.map

package/dist/posteffect/posteffect.js.map

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

package/dist/posteffect/sao.js

@@ -0,0 +1,327 @@
+import { isFloatTextureFormat } from '@zephyr3d/device';
+import { Application } from '../app.js';
+import { AbstractPostEffect } from './posteffect.js';
+import { decodeNormalizedFloatFromRGBA, encodeNormalizedFloatToRGBA } from '../shaders/misc.js';
+import { Vector2, Vector4, Matrix4x4 } from '@zephyr3d/base';
+import { AOBilateralBlurBlitter } from '../blitter/depthlimitedgaussion.js';
+import '../shaders/framework.js';
+import { CopyBlitter } from '../blitter/copy.js';
+import '../scene/octree.js';
+import '../material/material.js';
+import '../render/scatteringlut.js';
+import '../material/lambert.js';
+import '../material/blinn.js';
+import '../material/unlit.js';
+import '../material/lightmodel.js';
+import '../render/forward.js';
+import '../render/sky.js';
+import '../render/clipmap.js';
+import { TemporalCache } from '../render/temporalcache.js';
+import '../render/watermesh.js';
+
+const NUM_SAMPLES = 7;
+const NUM_RINGS = 4;
+/**
+ * The Scalable Ambient Obscurance (SAO) post effect
+ * @public
+ */ class SAO extends AbstractPostEffect {
+    static _nearestSampler = null;
+    static _program = null;
+    static _programPacked = null;
+    static _renderState = null;
+    static _renderStateBlend = null;
+    _bindgroup;
+    _bindgroupPacked;
+    _saoScale;
+    _saoBias;
+    _saoIntensity;
+    _saoRadius;
+    _saoMinResolution;
+    _saoRandomSeed;
+    _saoBlurDepthCutoff;
+    _blitterH;
+    _blitterV;
+    _copyBlitter;
+    _supported;
+    /**
+   * Creates an instance of SAO post effect
+   */ constructor(){
+        super();
+        this._bindgroup = null;
+        this._bindgroupPacked = null;
+        this._supported = true;
+        this._opaque = true;
+        this._saoScale = 10;
+        this._saoBias = 1;
+        this._saoIntensity = 0.05;
+        this._saoRadius = 100;
+        this._saoMinResolution = 0;
+        this._saoRandomSeed = 0;
+        this._saoBlurDepthCutoff = 1;
+        this._blitterH = new AOBilateralBlurBlitter(false);
+        this._blitterH.kernelRadius = 8;
+        this._blitterH.stdDev = 10;
+        this._blitterV = new AOBilateralBlurBlitter(true);
+        this._blitterV.kernelRadius = 8;
+        this._blitterV.stdDev = 10;
+        this._copyBlitter = new CopyBlitter();
+        this.addIntermediateFramebuffer('ao', 'current');
+        this.addIntermediateFramebuffer('blur', 'current');
+    }
+    /** Scale value */ get scale() {
+        return this._saoScale;
+    }
+    set scale(val) {
+        this._saoScale = val;
+    }
+    /** Bias value */ get bias() {
+        return this._saoBias;
+    }
+    set bias(val) {
+        this._saoBias = val;
+    }
+    /** Radius value */ get radius() {
+        return this._saoRadius;
+    }
+    set radius(val) {
+        this._saoRadius = val;
+    }
+    /** SAO intensity */ get intensity() {
+        return this._saoIntensity;
+    }
+    set intensity(val) {
+        this._saoIntensity = val;
+    }
+    /** Minimum resolution */ get minResolution() {
+        return this._saoMinResolution;
+    }
+    set minResolution(val) {
+        this._saoMinResolution = val;
+    }
+    /** Blur kernel size */ get blurKernelSize() {
+        return this._blitterH.kernelRadius;
+    }
+    set blurKernelSize(val) {
+        val = Math.min(64, Math.max(0, val >> 0));
+        this._blitterH.kernelRadius = val;
+        this._blitterV.kernelRadius = val;
+    }
+    /** Gaussian blur stddev value */ get blurStdDev() {
+        return this._blitterH.stdDev;
+    }
+    set blurStdDev(val) {
+        this._blitterH.stdDev = val;
+        this._blitterV.stdDev = val;
+    }
+    /** Cutoff of depth limited blur */ get blurDepthCutoff() {
+        return this._saoBlurDepthCutoff;
+    }
+    set blurDepthCutoff(val) {
+        this._saoBlurDepthCutoff = val;
+    }
+    /** {@inheritDoc AbstractPostEffect.requireLinearDepthTexture} */ requireLinearDepthTexture() {
+        return true;
+    }
+    /** {@inheritDoc AbstractPostEffect.requireDepthAttachment} */ requireDepthAttachment() {
+        return true;
+    }
+    /** {@inheritDoc AbstractPostEffect.apply} */ apply(ctx, inputColorTexture, sceneDepthTexture, srgbOutput) {
+        const device = Application.instance.device;
+        const viewport = device.getViewport();
+        this._prepare(device, inputColorTexture);
+        this._copyBlitter.srgbOut = srgbOutput;
+        this._copyBlitter.blit(inputColorTexture, device.getFramebuffer(), SAO._nearestSampler);
+        if (!this._supported) {
+            return;
+        }
+        const fmt = this._getIntermediateTextureFormat(device);
+        const depth = device.getFramebuffer().getDepthAttachment();
+        const fbao = ctx.defaultViewport ? TemporalCache.getFramebufferVariantSizeWithDepth(depth, 1, fmt, '2d', false) : TemporalCache.getFramebufferFixedSizeWithDepth(depth, 1, fmt, '2d', false);
+        const fbblur = ctx.defaultViewport ? TemporalCache.getFramebufferVariantSizeWithDepth(depth, 1, fmt, '2d', false) : TemporalCache.getFramebufferFixedSizeWithDepth(depth, 1, fmt, '2d', false);
+        const packed = fbao.getColorAttachments()[0].format === 'rgba8unorm';
+        const cameraNearFar = new Vector2(ctx.camera.getNearPlane(), ctx.camera.getFarPlane());
+        device.pushDeviceStates();
+        device.setFramebuffer(fbao);
+        device.clearFrameBuffer(packed ? new Vector4(0, 0, 0, 1) : new Vector4(1, 0, 0, 1), null, null);
+        const bindgroup = packed ? this._bindgroupPacked : this._bindgroup;
+        bindgroup.setValue('flip', this.needFlip(device) ? 1 : 0);
+        bindgroup.setTexture('depthTex', sceneDepthTexture);
+        bindgroup.setValue('scale', this._saoScale);
+        bindgroup.setValue('invProj', Matrix4x4.invert(ctx.camera.getProjectionMatrix()));
+        bindgroup.setValue('bias', this._saoBias);
+        bindgroup.setValue('cameraNearFar', cameraNearFar);
+        bindgroup.setValue('intensity', this._saoIntensity);
+        bindgroup.setValue('kernelRadius', this._saoRadius);
+        bindgroup.setValue('minResolution', this._saoMinResolution);
+        bindgroup.setValue('size', new Vector2(viewport.width, viewport.height));
+        bindgroup.setValue('randomSeed', this._saoRandomSeed);
+        device.setRenderStates(SAO._renderState);
+        device.setProgram(packed ? SAO._programPacked : SAO._program);
+        device.setBindGroup(0, bindgroup);
+        this.drawFullscreenQuad(SAO._renderState);
+        this._blitterH.size = new Vector2(inputColorTexture.width, inputColorTexture.height);
+        this._blitterH.depthTex = sceneDepthTexture;
+        this._blitterH.depthCutoff = this._saoBlurDepthCutoff / ctx.camera.getFarPlane();
+        this._blitterH.nearestSampler = SAO._nearestSampler;
+        this._blitterH.cameraNearFar = cameraNearFar;
+        this._blitterH.packed = packed;
+        this._blitterH.renderStates = SAO._renderState;
+        this._blitterV.size = new Vector2(inputColorTexture.width, inputColorTexture.height);
+        this._blitterV.depthTex = sceneDepthTexture;
+        this._blitterV.depthCutoff = this._saoBlurDepthCutoff / ctx.camera.getFarPlane();
+        this._blitterV.nearestSampler = SAO._nearestSampler;
+        this._blitterV.cameraNearFar = cameraNearFar;
+        this._blitterV.packed = packed;
+        this._blitterV.srgbOut = srgbOutput;
+        this._blitterV.renderStates = SAO._renderStateBlend;
+        this._blitterH.blit(fbao.getColorAttachments()[0], fbblur);
+        device.popDeviceStates();
+        this._blitterV.blit(fbblur.getColorAttachments()[0], device.getFramebuffer());
+        TemporalCache.releaseFramebuffer(fbao);
+        TemporalCache.releaseFramebuffer(fbblur);
+    }
+    _getIntermediateTextureFormat(device) {
+        const texCaps = device.getDeviceCaps().textureCaps;
+        return device.type === 'webgl' || !texCaps.supportHalfFloatColorBuffer && !texCaps.supportFloatColorBuffer ? 'rgba8unorm' : texCaps.supportHalfFloatColorBuffer ? 'r16f' : 'r32f';
+    }
+    /** @internal */ _prepare(device, srcTexture) {
+        const fb = device.getFramebuffer();
+        const isFloatFramebuffer = fb && isFloatTextureFormat(fb.getColorAttachments()[0].format);
+        this._supported = !isFloatFramebuffer || device.getDeviceCaps().framebufferCaps.supportFloatBlending;
+        if (this._supported) {
+            if (!SAO._nearestSampler) {
+                SAO._nearestSampler = device.createSampler({
+                    magFilter: 'nearest',
+                    minFilter: 'nearest',
+                    mipFilter: 'none',
+                    addressU: 'clamp',
+                    addressV: 'clamp'
+                });
+            }
+            if (!SAO._renderState) {
+                SAO._renderState = device.createRenderStateSet();
+                SAO._renderState.useDepthState().enableTest(true).enableWrite(false).setCompareFunc('gt');
+                SAO._renderState.useRasterizerState().setCullMode('none');
+                SAO._renderStateBlend = device.createRenderStateSet();
+                SAO._renderStateBlend.useDepthState().enableTest(true).enableWrite(false).setCompareFunc('gt');
+                SAO._renderStateBlend.useRasterizerState().setCullMode('none');
+                SAO._renderStateBlend.useBlendingState().enable(true).setBlendFuncRGB('zero', 'src-color').setBlendFuncAlpha('zero', 'one');
+            }
+            function createProgram(packed) {
+                return device.buildRenderProgram({
+                    vertex (pb) {
+                        this.flip = pb.int().uniform(0);
+                        this.$inputs.pos = pb.vec2().attrib('position');
+                        this.$outputs.uv = pb.vec2();
+                        pb.main(function() {
+                            this.$builtins.position = pb.vec4(this.$inputs.pos, 1, 1);
+                            this.$outputs.uv = pb.add(pb.mul(this.$inputs.pos.xy, 0.5), pb.vec2(0.5));
+                            this.$if(pb.notEqual(this.flip, 0), function() {
+                                this.$builtins.position.y = pb.neg(this.$builtins.position.y);
+                            });
+                        });
+                    },
+                    fragment (pb) {
+                        this.depthTex = pb.tex2D().sampleType('unfilterable-float').uniform(0);
+                        this.scale = pb.float().uniform(0);
+                        this.invProj = pb.mat4().uniform(0);
+                        this.cameraNearFar = pb.vec2().uniform(0);
+                        this.intensity = pb.float().uniform(0);
+                        this.bias = pb.float().uniform(0);
+                        this.kernelRadius = pb.float().uniform(0);
+                        this.minResolution = pb.float().uniform(0);
+                        this.size = pb.vec2().uniform(0);
+                        this.randomSeed = pb.float().uniform(0);
+                        this.$l.scaleDividedByCameraFar = pb.float();
+                        this.$l.minResolutionMultipliedByCameraFar = pb.float();
+                        pb.func('rand', [
+                            pb.vec2('uv')
+                        ], function() {
+                            this.$l.a = 12.9898;
+                            this.$l.b = 78.233;
+                            this.$l.c = 43758.5453;
+                            this.$l.dt = pb.dot(this.uv, pb.vec2(this.a, this.b));
+                            this.$l.sn = pb.mod(this.dt, Math.PI);
+                            this.$return(pb.fract(pb.mul(pb.sin(this.sn), this.c)));
+                        });
+                        pb.func('getPositionVS', [
+                            pb.vec2('uv')
+                        ], function() {
+                            this.$l.depthValue = pb.textureSample(this.depthTex, this.uv);
+                            if (device.type === 'webgl') {
+                                this.$l.linearDepth = decodeNormalizedFloatFromRGBA(this, this.depthValue);
+                            } else {
+                                this.$l.linearDepth = this.depthValue.r;
+                            }
+                            this.$l.nonLinearDepth = pb.div(pb.sub(pb.div(this.cameraNearFar.x, this.linearDepth), this.cameraNearFar.y), pb.sub(this.cameraNearFar.x, this.cameraNearFar.y));
+                            this.$l.clipSpacePos = pb.vec4(pb.sub(pb.mul(this.uv, 2), pb.vec2(1)), pb.sub(pb.mul(this.nonLinearDepth, 2), 1), 1);
+                            // this.$l.clipSpacePos = pb.vec4(this.uv, this.nonLinearDepth, 1);
+                            this.$l.vPos = pb.mul(this.invProj, this.clipSpacePos);
+                            this.vPos = pb.div(this.vPos, this.vPos.w);
+                            this.$return(this.vPos.xyz);
+                        });
+                        pb.func('getOcclusion', [
+                            pb.vec3('centerPos'),
+                            pb.vec3('centerNormal'),
+                            pb.vec3('samplePos')
+                        ], function() {
+                            this.$l.viewDelta = pb.sub(this.samplePos, this.centerPos);
+                            this.$l.viewDistance = pb.length(this.viewDelta);
+                            this.$l.scaledScreenDistance = pb.mul(this.scaleDividedByCameraFar, this.viewDistance);
+                            this.$return(pb.div(pb.max(0, pb.sub(pb.div(pb.sub(pb.dot(this.centerNormal, this.viewDelta), this.minResolutionMultipliedByCameraFar), this.scaledScreenDistance), this.bias)), pb.add(pb.mul(this.scaledScreenDistance, this.scaledScreenDistance), 1)));
+                        });
+                        pb.func('getAO', [
+                            pb.vec3('vPos')
+                        ], function() {
+                            this.scaleDividedByCameraFar = pb.div(this.scale, this.cameraNearFar.y);
+                            this.minResolutionMultipliedByCameraFar = pb.mul(this.minResolution, this.cameraNearFar.y);
+                            this.$l.centerViewNormal = pb.normalize(pb.cross(pb.dpdx(this.vPos), pb.dpdy(this.vPos)));
+                            this.$l.angle = pb.mul(this.rand(pb.add(this.$inputs.uv, pb.vec2(this.randomSeed))), Math.PI * 2);
+                            this.$l.radius = pb.div(pb.vec2(pb.mul(this.kernelRadius, 1 / NUM_SAMPLES)), this.size);
+                            this.$l.radiusStep = this.radius;
+                            this.$l.occlusionSum = pb.float(0);
+                            this.$l.weightSum = pb.float(0);
+                            this.$for(pb.int('i'), 0, NUM_SAMPLES, function() {
+                                this.$l.sampleUV = pb.add(this.$inputs.uv, pb.mul(pb.vec2(pb.cos(this.angle), pb.sin(this.angle)), this.radius));
+                                this.radius = pb.add(this.radius, this.radiusStep);
+                                this.angle = pb.add(this.angle, Math.PI * NUM_RINGS / NUM_SAMPLES);
+                                this.samplePos = this.getPositionVS(this.sampleUV);
+                                this.occlusionSum = pb.add(this.occlusionSum, this.getOcclusion(this.vPos, this.centerViewNormal, this.samplePos));
+                                this.weightSum = pb.add(this.weightSum, 1);
+                            });
+                            this.$if(pb.equal(this.weightSum, 0), function() {
+                                pb.discard();
+                            });
+                            this.$return(pb.div(pb.mul(this.occlusionSum, this.intensity), this.weightSum));
+                        });
+                        pb.main(function() {
+                            this.$l.vPos = this.getPositionVS(this.$inputs.uv);
+                            this.$l.ao = pb.clamp(pb.sub(1, this.getAO(this.vPos)), 0, packed ? 0.999 : 1);
+                            if (packed) {
+                                this.$outputs.outColor = encodeNormalizedFloatToRGBA(this, this.ao);
+                            } else {
+                                this.$outputs.outColor = pb.vec4(this.ao, this.ao, this.ao, 1);
+                            }
+                        });
+                    }
+                });
+            }
+            if (!SAO._program) {
+                SAO._program = createProgram(false);
+                SAO._programPacked = createProgram(true);
+            }
+            if (!this._bindgroup) {
+                this._bindgroup = device.createBindGroup(SAO._program.bindGroupLayouts[0]);
+                this._bindgroupPacked = device.createBindGroup(SAO._programPacked.bindGroupLayouts[0]);
+            }
+        }
+    }
+    /** {@inheritDoc AbstractPostEffect.dispose} */ dispose() {
+        super.dispose();
+        this._bindgroup?.dispose();
+        this._bindgroup = null;
+    }
+}
+
+export { SAO };
+//# sourceMappingURL=sao.js.map

package/dist/posteffect/sao.js.map

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

package/dist/posteffect/tonemap.js

@@ -0,0 +1,112 @@
+import { Application } from '../app.js';
+import { AbstractPostEffect } from './posteffect.js';
+import { linearToGamma } from '../shaders/misc.js';
+
+/**
+ * The tonemap post effect
+ * @public
+ */ class Tonemap extends AbstractPostEffect {
+    static _nearestSampler = null;
+    static _programTonemap = null;
+    _bindgroupTonemap;
+    _exposure;
+    /**
+   * Creates an instance of tonemap post effect
+   */ constructor(){
+        super();
+        this._bindgroupTonemap = null;
+        this._opaque = false;
+        this._exposure = 1;
+    }
+    /** Exposure value */ get exposure() {
+        return this._exposure;
+    }
+    set exposure(val) {
+        this._exposure = val;
+    }
+    /** {@inheritDoc AbstractPostEffect.requireLinearDepthTexture} */ requireLinearDepthTexture() {
+        return false;
+    }
+    /** {@inheritDoc AbstractPostEffect.requireDepthAttachment} */ requireDepthAttachment() {
+        return false;
+    }
+    /** {@inheritDoc AbstractPostEffect.apply} */ apply(ctx, inputColorTexture, sceneDepthTexture, srgbOutput) {
+        const device = Application.instance.device;
+        this._prepare(device, inputColorTexture);
+        this._tonemap(device, inputColorTexture, srgbOutput);
+    }
+    /** @internal */ _tonemap(device, inputColorTexture, sRGBOutput) {
+        this._bindgroupTonemap.setValue('srgbOut', sRGBOutput ? 1 : 0);
+        this._bindgroupTonemap.setValue('exposure', this._exposure);
+        this._bindgroupTonemap.setValue('flip', this.needFlip(device) ? 1 : 0);
+        this._bindgroupTonemap.setTexture('tex', inputColorTexture, Tonemap._nearestSampler);
+        device.setProgram(Tonemap._programTonemap);
+        device.setBindGroup(0, this._bindgroupTonemap);
+        this.drawFullscreenQuad();
+    }
+    /** @internal */ _prepare(device, srcTexture) {
+        if (!Tonemap._programTonemap) {
+            Tonemap._programTonemap = device.buildRenderProgram({
+                vertex (pb) {
+                    this.flip = pb.int().uniform(0);
+                    this.$inputs.pos = pb.vec2().attrib('position');
+                    this.$outputs.uv = pb.vec2();
+                    pb.main(function() {
+                        this.$builtins.position = pb.vec4(this.$inputs.pos, 0, 1);
+                        this.$outputs.uv = pb.add(pb.mul(this.$inputs.pos.xy, 0.5), pb.vec2(0.5));
+                        this.$if(pb.notEqual(this.flip, 0), function() {
+                            this.$builtins.position.y = pb.neg(this.$builtins.position.y);
+                        });
+                    });
+                },
+                fragment (pb) {
+                    this.srgbOut = pb.int().uniform(0);
+                    this.exposure = pb.float().uniform(0);
+                    this.tex = pb.tex2D().uniform(0);
+                    this.$outputs.outColor = pb.vec4();
+                    pb.func('RRTAndODTFit', [
+                        pb.vec3('v')
+                    ], function() {
+                        this.$l.a = pb.sub(pb.mul(this.v, pb.add(this.v, pb.vec3(0.0245786))), pb.vec3(0.000090537));
+                        this.$l.b = pb.add(pb.mul(this.v, pb.add(pb.mul(this.v, 0.983729), pb.vec3(0.4329510))), pb.vec3(0.238081));
+                        this.$return(pb.div(this.a, this.b));
+                    });
+                    pb.main(function() {
+                        this.$l.vSample = pb.textureSample(this.tex, this.$inputs.uv);
+                        this.$l.ACESInputMat = pb.mat3(0.59719, 0.07600, 0.02840, 0.35458, 0.90834, 0.13383, 0.04823, 0.01566, 0.83777);
+                        this.$l.ACESOutputMat = pb.mat3(1.60475, -0.10208, -0.00327, -0.53108, 1.10813, -0.07276, -0.07367, -0.00605, 1.07602);
+                        this.$l.color = pb.mul(this.vSample.rgb, pb.div(this.exposure, 0.6));
+                        this.color = pb.mul(this.ACESInputMat, this.color);
+                        this.color = this.RRTAndODTFit(this.color);
+                        this.color = pb.mul(this.ACESOutputMat, this.color);
+                        this.color = pb.clamp(this.color, pb.vec3(0), pb.vec3(1));
+                        this.$if(pb.notEqual(this.srgbOut, 0), function() {
+                            this.$l.color = linearToGamma(this, this.color);
+                        });
+                        this.$outputs.outColor = pb.vec4(this.color, 1);
+                    });
+                }
+            });
+        }
+        if (!this._bindgroupTonemap) {
+            this._bindgroupTonemap = device.createBindGroup(Tonemap._programTonemap.bindGroupLayouts[0]);
+        }
+        if (!Tonemap._nearestSampler) {
+            Tonemap._nearestSampler = device.createSampler({
+                magFilter: 'nearest',
+                minFilter: 'nearest',
+                mipFilter: 'none',
+                addressU: 'clamp',
+                addressV: 'clamp'
+            });
+        }
+    }
+    /** {@inheritDoc AbstractPostEffect.dispose} */ dispose() {
+        super.dispose();
+        this._bindgroupTonemap?.dispose();
+        this._bindgroupTonemap = null;
+    }
+}
+
+export { Tonemap };
+//# sourceMappingURL=tonemap.js.map

package/dist/posteffect/tonemap.js.map

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