@zephyr3d/scene 0.1.0

package/dist/material/terrainmaterial.js

@@ -0,0 +1,139 @@
+import { Material } from './material.js';
+import { forwardComputeLighting } from '../shaders/lighting.js';
+import { RENDER_PASS_TYPE_FORWARD, RENDER_PASS_TYPE_SHADOWMAP, RENDER_PASS_TYPE_DEPTH_ONLY } from '../values.js';
+import { ShaderFramework } from '../shaders/framework.js';
+import { encodeColorOutput, nonLinearDepthToLinearNormalized, encodeNormalizedFloatToRGBA } from '../shaders/misc.js';
+import { Application } from '../app.js';
+import { TerrainLightModel } from './terrainlightmodel.js';
+import { MESH_MATERIAL } from '../shaders/builtins.js';
+
+/** @internal */ const MAX_DETAIL_TEXTURE_LEVELS = 8;
+/**
+ * The terrain material
+ * @public
+ */ class TerrainMaterial extends Material {
+    /** @internal */ _lightModel;
+    /** @internal */ _terrainInfo;
+    /**
+   * Creates an instance of TerrainMaterial
+   */ constructor(options){
+        super();
+        this._terrainInfo = null;
+        this._lightModel = new TerrainLightModel(options);
+    }
+    get lightModel() {
+        return this._lightModel;
+    }
+    get terrainInfo() {
+        return this._terrainInfo;
+    }
+    set terrainInfo(val) {
+        this._terrainInfo = val;
+        this.optionChanged(false);
+    }
+    /**
+   * {@inheritDoc Material.isTransparent}
+   * @override
+   */ isTransparent() {
+        return false;
+    }
+    /**
+   * {@inheritDoc Material.supportLighting}
+   * @override
+   */ supportLighting() {
+        return this._lightModel.supportLighting();
+    }
+    /**
+   * {@inheritDoc Material.applyUniforms}
+   * @override
+   */ applyUniforms(bindGroup, ctx, needUpdate) {
+        super.applyUniforms(bindGroup, ctx, needUpdate);
+        if (ctx.renderPass.type === RENDER_PASS_TYPE_FORWARD) {
+            this._lightModel.applyUniformsIfOutdated(bindGroup, ctx);
+        }
+    }
+    /**
+   * {@inheritDoc Material._applyUniforms}
+   * @override
+   */ _applyUniforms(bindGroup, ctx) {
+        if (ctx.renderPass.type === RENDER_PASS_TYPE_FORWARD) {
+            bindGroup.setValue('terrainInfo', this._terrainInfo);
+        }
+    }
+    /** @internal */ getHash(renderPassType) {
+        if (this._hash[renderPassType] === void 0) {
+            this._hash[renderPassType] = this.createHash(renderPassType);
+        }
+        return this._hash[renderPassType];
+    }
+    /** @internal */ _createHash(renderPassType) {
+        return renderPassType === RENDER_PASS_TYPE_FORWARD ? this._lightModel.getHash() : '';
+    }
+    /** @internal */ _createProgram(pb, ctx) {
+        const that = this;
+        if (ctx.renderPass.type === RENDER_PASS_TYPE_SHADOWMAP) {
+            const shadowMapParams = ctx.shadowMapInfo.get(ctx.renderPass.light);
+            pb.emulateDepthClamp = !!shadowMapParams.depthClampEnabled;
+        }
+        const program = pb.buildRenderProgram({
+            vertex () {
+                ShaderFramework.prepareVertexShader(pb, ctx);
+                this.$inputs.pos = pb.vec3().attrib('position');
+                if (ctx.renderPass.type === RENDER_PASS_TYPE_FORWARD) {
+                    this.terrainInfo = pb.vec4().uniform(2);
+                    this.$inputs.normal = pb.vec3().attrib('normal');
+                    that._lightModel.setupUniforms(this, ctx);
+                }
+                pb.main(function() {
+                    ShaderFramework.ftransform(this);
+                    if (ctx.renderPass.type === RENDER_PASS_TYPE_FORWARD) {
+                        this.$l.uv = pb.div(this.$inputs.pos.xz, this.terrainInfo.xy);
+                        for(let i = 0; i < Application.instance.device.getDeviceCaps().miscCaps.maxTexCoordIndex; i++){
+                            if (that._lightModel?.isTexCoordIndexUsed(i)) {
+                                this.$outputs[`texcoord${i}`] = that._lightModel.calculateTexCoordNoInput(this, i, this.uv);
+                            }
+                        }
+                    }
+                });
+            },
+            fragment () {
+                ShaderFramework.prepareFragmentShader(pb, ctx);
+                if (ctx.renderPass.type === RENDER_PASS_TYPE_FORWARD) {
+                    that._lightModel.setupUniforms(this, ctx);
+                    this.$outputs.outColor = pb.vec4();
+                    pb.main(function() {
+                        this.$l.litColor = forwardComputeLighting(this, that._lightModel, ctx);
+                        MESH_MATERIAL.DISCARD_IF_CLIPPED(this);
+                        this.$outputs.outColor = encodeColorOutput(this, this.litColor);
+                    });
+                } else if (ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH_ONLY) {
+                    this.$outputs.outColor = pb.vec4();
+                    pb.main(function() {
+                        MESH_MATERIAL.DISCARD_IF_CLIPPED(this);
+                        this.$l.depth = nonLinearDepthToLinearNormalized(this, this.$builtins.fragCoord.z);
+                        if (Application.instance.device.type === 'webgl') {
+                            this.$outputs.outColor = encodeNormalizedFloatToRGBA(this, this.depth);
+                        } else {
+                            this.$outputs.outColor = pb.vec4(this.depth, 0, 0, 1);
+                        }
+                    });
+                } else if (ctx.renderPass.type === RENDER_PASS_TYPE_SHADOWMAP) {
+                    this.$outputs.outColor = pb.vec4();
+                    pb.main(function() {
+                        MESH_MATERIAL.DISCARD_IF_CLIPPED(this);
+                        const shadowMapParams = ctx.shadowMapInfo.get(ctx.renderPass.light);
+                        this.$outputs.outColor = shadowMapParams.impl.computeShadowMapDepth(shadowMapParams, this);
+                    });
+                } else {
+                    throw new Error(`unknown render pass type: ${ctx.renderPass.type}`);
+                }
+            }
+        });
+        // console.log(program?.getShaderSource('vertex'));
+        // console.log(program?.getShaderSource('fragment'));
+        return program;
+    }
+}
+
+export { MAX_DETAIL_TEXTURE_LEVELS, TerrainMaterial };
+//# sourceMappingURL=terrainmaterial.js.map

package/dist/material/terrainmaterial.js.map

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

package/dist/material/unlit.js

@@ -0,0 +1,29 @@
+import { applyMaterialMixins, MeshMaterial } from './meshmaterial.js';
+import { mixinAlbedoColor } from './mixins/albedocolor.js';
+import { mixinVertexColor } from './mixins/vertexcolor.js';
+
+/**
+ * Unlit material
+ * @public
+ */ class UnlitMaterial extends applyMaterialMixins(MeshMaterial, mixinVertexColor, mixinAlbedoColor) {
+    static FEATURE_VERTEX_COLOR = 'um_vertexcolor';
+    constructor(){
+        super();
+    }
+    vertexShader(scope, ctx) {
+        super.vertexShader(scope, ctx);
+        scope.$inputs.zPos = scope.$builder.vec3().attrib('position');
+        this.transformVertexAndNormal(scope);
+    }
+    fragmentShader(scope, ctx) {
+        super.fragmentShader(scope, ctx);
+        let color = this.calculateAlbedoColor(scope, ctx);
+        if (this.vertexColor) {
+            color = scope.$builder.mul(color, this.getVertexColor(scope, ctx));
+        }
+        this.outputFragmentColor(scope, this.needFragmentColor(ctx) ? color : null, ctx);
+    }
+}
+
+export { UnlitMaterial };
+//# sourceMappingURL=unlit.js.map

package/dist/material/unlit.js.map

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

package/dist/posteffect/bloom.js

@@ -0,0 +1,398 @@
+import { Application } from '../app.js';
+import { AbstractPostEffect } from './posteffect.js';
+import { Vector4, Vector2 } from '@zephyr3d/base';
+import '../scene/octree.js';
+import '../material/material.js';
+import '@zephyr3d/device';
+import '../shaders/framework.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';
+
+/**
+ * The bloom post effect
+ * @public
+ */ class Bloom extends AbstractPostEffect {
+    static _nearestSampler = null;
+    static _programDownsampleH = null;
+    static _programDownsampleV = null;
+    static _programUpsample = null;
+    static _programFinalCompose = null;
+    static _programPrefilter = null;
+    static _renderStateAdditive = null;
+    _bindgroupDownsampleH;
+    _bindgroupDownsampleV;
+    _bindgroupUpsample;
+    _bindgroupFinalCompose;
+    _bindgroupPrefilter;
+    _thresholdValue;
+    _invTexSize;
+    _maxDownsampleLevels;
+    _downsampleLimit;
+    _threshold;
+    _thresholdKnee;
+    _intensity;
+    /**
+   * Creates an instance of tonemap post effect
+   */ constructor(){
+        super();
+        this._bindgroupDownsampleH = null;
+        this._bindgroupDownsampleV = null;
+        this._bindgroupUpsample = null;
+        this._bindgroupFinalCompose = null;
+        this._bindgroupPrefilter = null;
+        this._opaque = false;
+        this._thresholdValue = new Vector4();
+        this._invTexSize = new Vector2();
+        this._maxDownsampleLevels = 4;
+        this._downsampleLimit = 32;
+        this._threshold = 0.8;
+        this._thresholdKnee = 0;
+        this._intensity = 1;
+    }
+    /** The maximum downsample levels */ get maxDownsampleLevel() {
+        return this._maxDownsampleLevels;
+    }
+    set maxDownsampleLevel(val) {
+        this._maxDownsampleLevels = val;
+    }
+    /** Downsample resolution limitation */ get downsampleLimit() {
+        return this._downsampleLimit;
+    }
+    set downsampleLimit(val) {
+        this._downsampleLimit = val;
+    }
+    /** Bloom threshold */ get threshold() {
+        return this._threshold;
+    }
+    set threshold(val) {
+        this._threshold = val;
+    }
+    /** Bloom threshold knee */ get thresholdKnee() {
+        return this._thresholdKnee;
+    }
+    set thresholdKnee(val) {
+        this._thresholdKnee = val;
+    }
+    /** Bloom intensity */ get intensity() {
+        return this._intensity;
+    }
+    set intensity(val) {
+        this._intensity = 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;
+        const downsampleFramebuffers = [];
+        this._prepare(device, inputColorTexture);
+        device.pushDeviceStates();
+        const w = Math.max(inputColorTexture.width >> 1, 1);
+        const h = Math.max(inputColorTexture.height >> 1, 1);
+        const prefilterFramebuffer = TemporalCache.getFramebufferFixedSize(w, h, 1, inputColorTexture.format, null, '2d', null, false);
+        this.prefilter(device, inputColorTexture, prefilterFramebuffer);
+        this.downsample(device, prefilterFramebuffer.getColorAttachments()[0], downsampleFramebuffers);
+        this.upsample(device, downsampleFramebuffers);
+        device.popDeviceStates();
+        this.finalCompose(device, inputColorTexture, downsampleFramebuffers[0].getColorAttachments()[0]);
+        for (const fb of downsampleFramebuffers){
+            TemporalCache.releaseFramebuffer(fb);
+        }
+        TemporalCache.releaseFramebuffer(prefilterFramebuffer);
+    }
+    /** @internal */ prefilter(device, srcTexture, fb) {
+        this._thresholdValue.x = this._threshold * this._threshold;
+        this._thresholdValue.y = this._thresholdValue.x * this._thresholdKnee;
+        this._thresholdValue.z = 2 * this._thresholdValue.y;
+        this._thresholdValue.w = 0.25 / (this._thresholdValue.y + 0.00001);
+        this._thresholdValue.y -= this._thresholdValue.x;
+        device.setFramebuffer(fb);
+        device.setProgram(Bloom._programPrefilter);
+        device.setBindGroup(0, this._bindgroupPrefilter);
+        this._bindgroupPrefilter.setTexture('tex', srcTexture);
+        this._bindgroupPrefilter.setValue('flip', device.type === 'webgpu' ? 1 : 0);
+        this._bindgroupPrefilter.setValue('threshold', this._thresholdValue);
+        this.drawFullscreenQuad();
+    }
+    /** @internal */ finalCompose(device, srcTexture, bloomTexture) {
+        device.setProgram(Bloom._programFinalCompose);
+        device.setBindGroup(0, this._bindgroupFinalCompose);
+        this._bindgroupFinalCompose.setTexture('srcTex', srcTexture);
+        this._bindgroupFinalCompose.setTexture('bloomTex', bloomTexture);
+        this._bindgroupFinalCompose.setValue('intensity', this._intensity);
+        this._bindgroupFinalCompose.setValue('flip', device.type === 'webgpu' && device.getFramebuffer() ? 1 : 0);
+        this.drawFullscreenQuad();
+    }
+    /** @internal */ upsample(device, framebuffers) {
+        device.setProgram(Bloom._programUpsample);
+        device.setBindGroup(0, this._bindgroupUpsample);
+        this._bindgroupUpsample.setValue('flip', device.type === 'webgpu' ? 1 : 0);
+        for(let i = framebuffers.length - 2; i >= 0; i--){
+            this._bindgroupUpsample.setTexture('tex', framebuffers[i + 1].getColorAttachments()[0]);
+            device.setFramebuffer(framebuffers[i]);
+            this.drawFullscreenQuad(Bloom._renderStateAdditive);
+        }
+    }
+    /** @internal */ downsample(device, inputColorTexture, framebuffers) {
+        const t = Math.max(2, this._downsampleLimit);
+        let w = Math.max(t, inputColorTexture.width >> 1);
+        let h = Math.max(t, inputColorTexture.height >> 1);
+        let maxLevels = Math.max(this._maxDownsampleLevels, 1);
+        let sourceTex = inputColorTexture;
+        this._bindgroupDownsampleH.setValue('flip', device.type === 'webgpu' ? 1 : 0);
+        this._bindgroupDownsampleV.setValue('flip', device.type === 'webgpu' ? 1 : 0);
+        while((w >= t || h >= t) && maxLevels > 0){
+            const fb = TemporalCache.getFramebufferFixedSize(w, h, 1, inputColorTexture.format, null, '2d', '2d', false);
+            const fbMiddle = TemporalCache.getFramebufferFixedSize(w, h, 1, inputColorTexture.format, null, '2d', '2d', false);
+            framebuffers.push(fb);
+            // horizonal blur
+            this._invTexSize.setXY(1 / sourceTex.width, 1 / sourceTex.height);
+            device.setFramebuffer(fbMiddle);
+            device.setProgram(Bloom._programDownsampleH);
+            device.setBindGroup(0, this._bindgroupDownsampleH);
+            this._bindgroupDownsampleH.setTexture('tex', sourceTex);
+            this._bindgroupDownsampleH.setValue('invTexSize', this._invTexSize);
+            this.drawFullscreenQuad();
+            // vertical blur
+            const midTex = fbMiddle.getColorAttachments()[0];
+            this._invTexSize.setXY(1 / midTex.width, 1 / midTex.height);
+            device.setFramebuffer(fb);
+            device.setProgram(Bloom._programDownsampleV);
+            device.setBindGroup(0, this._bindgroupDownsampleV);
+            this._bindgroupDownsampleV.setTexture('tex', midTex);
+            this._bindgroupDownsampleV.setValue('invTexSize', this._invTexSize);
+            this.drawFullscreenQuad();
+            maxLevels--;
+            w = Math.max(1, w >> 1);
+            h = Math.max(1, h >> 1);
+            sourceTex = fb.getColorAttachments()[0];
+            TemporalCache.releaseFramebuffer(fbMiddle);
+        }
+    }
+    /** @internal */ _prepare(device, srcTexture) {
+        if (!Bloom._programFinalCompose) {
+            Bloom._programFinalCompose = 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.srcTex = pb.tex2D().uniform(0);
+                    this.bloomTex = pb.tex2D().uniform(0);
+                    this.intensity = pb.float().uniform(0);
+                    this.$outputs.outColor = pb.vec4();
+                    pb.main(function() {
+                        this.$l.srcSample = pb.textureSampleLevel(this.srcTex, this.$inputs.uv, 0);
+                        this.$l.bloomSample = pb.textureSampleLevel(this.bloomTex, this.$inputs.uv, 0);
+                        this.$outputs.outColor = pb.vec4(pb.add(this.srcSample.rgb, pb.mul(this.bloomSample.rgb, this.intensity)), 1);
+                    });
+                }
+            });
+        }
+        if (!this._bindgroupFinalCompose) {
+            this._bindgroupFinalCompose = device.createBindGroup(Bloom._programFinalCompose.bindGroupLayouts[0]);
+        }
+        if (!Bloom._programPrefilter) {
+            Bloom._programPrefilter = 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.tex = pb.tex2D().uniform(0);
+                    this.threshold = pb.vec4().uniform(0);
+                    this.$outputs.outColor = pb.vec4();
+                    pb.main(function() {
+                        this.$l.p = pb.textureSampleLevel(this.tex, this.$inputs.uv, 0);
+                        this.$l.brightness = pb.max(pb.max(this.p.r, this.p.g), this.p.b);
+                        this.$l.soft = pb.clamp(pb.add(this.brightness, this.threshold.y), 0, this.threshold.z);
+                        this.soft = pb.mul(this.soft, this.soft, this.threshold.w);
+                        this.$l.contrib = pb.div(pb.max(this.soft, pb.sub(this.brightness, this.threshold.x)), pb.max(this.brightness, 0.00001));
+                        this.$outputs.outColor = pb.vec4(pb.mul(this.p.rgb, this.contrib), 1);
+                    });
+                }
+            });
+        }
+        if (!this._bindgroupPrefilter) {
+            this._bindgroupPrefilter = device.createBindGroup(Bloom._programPrefilter.bindGroupLayouts[0]);
+        }
+        if (!Bloom._programUpsample) {
+            Bloom._programUpsample = 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.tex = pb.tex2D().uniform(0);
+                    this.$outputs.outColor = pb.vec4();
+                    pb.main(function() {
+                        this.$outputs.outColor = pb.textureSampleLevel(this.tex, this.$inputs.uv, 0);
+                    });
+                }
+            });
+        }
+        if (!this._bindgroupUpsample) {
+            this._bindgroupUpsample = device.createBindGroup(Bloom._programUpsample.bindGroupLayouts[0]);
+        }
+        if (!Bloom._programDownsampleH) {
+            const offsets = [
+                -4,
+                -3,
+                -2,
+                -1,
+                0,
+                1,
+                2,
+                3,
+                4
+            ];
+            const weights = [
+                0.01621622,
+                0.05405405,
+                0.12162162,
+                0.19459459,
+                0.22702703,
+                0.19459459,
+                0.12162162,
+                0.05405405,
+                0.01621622
+            ];
+            Bloom._programDownsampleH = 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.invTexSize = pb.vec2().uniform(0);
+                    this.tex = pb.tex2D().uniform(0);
+                    this.$outputs.outColor = pb.vec4();
+                    pb.main(function() {
+                        this.$l.sum = pb.vec3(0);
+                        this.$l.offset = pb.float();
+                        for(let i = 0; i < 9; i++){
+                            this.offset = pb.mul(this.invTexSize.x, offsets[i] * 2);
+                            this.sum = pb.add(this.sum, pb.mul(pb.textureSampleLevel(this.tex, pb.add(this.$inputs.uv, pb.vec2(this.offset, 0)), 0).rgb, weights[i]));
+                        }
+                        this.$outputs.outColor = pb.vec4(this.sum, 1);
+                    });
+                }
+            });
+        }
+        if (!this._bindgroupDownsampleH) {
+            this._bindgroupDownsampleH = device.createBindGroup(Bloom._programDownsampleH.bindGroupLayouts[0]);
+        }
+        if (!Bloom._programDownsampleV) {
+            const offsets = [
+                -3.23076923,
+                -1.38461538,
+                0.0,
+                1.38461538,
+                3.23076923
+            ];
+            const weights = [
+                0.07027027,
+                0.31621622,
+                0.22702703,
+                0.31621622,
+                0.07027027
+            ];
+            Bloom._programDownsampleV = 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.invTexSize = pb.vec2().uniform(0);
+                    this.tex = pb.tex2D().uniform(0);
+                    this.$outputs.outColor = pb.vec4();
+                    pb.main(function() {
+                        this.$l.sum = pb.vec3(0);
+                        this.$l.offset = pb.float();
+                        for(let i = 0; i < 5; i++){
+                            this.offset = pb.mul(this.invTexSize.y, offsets[i]);
+                            this.sum = pb.add(this.sum, pb.mul(pb.textureSampleLevel(this.tex, pb.add(this.$inputs.uv, pb.vec2(0, this.offset)), 0).rgb, weights[i]));
+                        }
+                        this.$outputs.outColor = pb.vec4(this.sum, 1);
+                    });
+                }
+            });
+        }
+        if (!this._bindgroupDownsampleV) {
+            this._bindgroupDownsampleV = device.createBindGroup(Bloom._programDownsampleV.bindGroupLayouts[0]);
+        }
+        if (!Bloom._nearestSampler) {
+            Bloom._nearestSampler = device.createSampler({
+                magFilter: 'nearest',
+                minFilter: 'nearest',
+                mipFilter: 'none',
+                addressU: 'clamp',
+                addressV: 'clamp'
+            });
+        }
+        if (!Bloom._renderStateAdditive) {
+            Bloom._renderStateAdditive = device.createRenderStateSet();
+            Bloom._renderStateAdditive.useRasterizerState().setCullMode('none');
+            Bloom._renderStateAdditive.useDepthState().enableTest(false).enableWrite(false);
+            Bloom._renderStateAdditive.useBlendingState().enable(true).setBlendFuncRGB('one', 'one').setBlendFuncAlpha('one', 'zero');
+        }
+    }
+    /** {@inheritDoc AbstractPostEffect.dispose} */ dispose() {
+        super.dispose();
+        this._bindgroupDownsampleH?.dispose();
+        this._bindgroupDownsampleH = null;
+    }
+}
+
+export { Bloom };
+//# sourceMappingURL=bloom.js.map

package/dist/posteffect/bloom.js.map

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