@meimu/mutracer 0.0.0-stage → 0.1.0

package/lib/renderer/TileRender.js

@@ -0,0 +1,283 @@
+// Portions adapted from ray-tracing-renderer@0.10.15
+// (https://github.com/hoverinc/ray-tracing-renderer).
+// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.
+import { clamp } from './util.js';
+// TileRender is based on the concept of a compute shader's work group.
+// Path tracing the scene can be very slow (<1 fps).
+// This overworks the GPU and tends to lock up the OS, making it unresponsive.
+// To fix this, we can split the screen into smaller tiles, and sample the scene one tile at a time
+// The tile size is set such that each tile takes approximately a constant amount of time to render.
+// Since the render time of a tile is dependent on the device, we find the desired tile dimensions by measuring
+// the time it takes to render an arbitrarily-set tile size and adjusting the size according to the benchmark.
+export function makeTileRender(gl) {
+    let desiredMsPerTile = 21;
+    let maxNumTiles = Infinity;
+    let currentTile = -1;
+    let numTiles = 1;
+    let numSamples = 1;
+    let tileWidth;
+    let tileHeight;
+    let columns;
+    let rows;
+    let width = 0;
+    let height = 0;
+    let totalElapsedMs = 0;
+    let timedTiles = 0;
+    // initial number of pixels per rendered tile
+    // based on correlation between system performance and max supported render buffer size
+    // adjusted dynamically according to system performance
+    let pixelsPerTile = gl ? pixelsPerTileEstimate(gl) : 600000;
+    function reset() {
+        currentTile = -1;
+        totalElapsedMs = 0;
+        timedTiles = 0;
+    }
+    function setSize(w, h) {
+        width = w;
+        height = h;
+        reset();
+        calcTileDimensions();
+    }
+    function calcTileDimensions() {
+        const maxWidth = 3000;
+        const aspectRatio = width / height;
+        // quantize the width of the tile so that it evenly divides the entire window
+        tileWidth = Math.ceil(maxWidth /
+            Math.max(Math.round(maxWidth / Math.sqrt(pixelsPerTile * aspectRatio)), 1));
+        tileHeight = Math.ceil(tileWidth / aspectRatio);
+        if (tileWidth > width && tileHeight > height) {
+            columns = 1;
+            rows = 1;
+            numTiles = 1;
+            numSamples =
+                Math.round(tileWidth / width) * Math.round(tileHeight / height);
+        }
+        else {
+            numSamples = 1;
+            columns = Math.ceil(width / tileWidth);
+            rows = Math.ceil(height / tileHeight);
+            numTiles = columns * rows;
+        }
+        if (numTiles > maxNumTiles) {
+            // TODO maxNumTiles is not exact value.
+            numTiles = maxNumTiles;
+            columns = Math.ceil(Math.sqrt(numTiles));
+            rows = Math.ceil(numTiles / columns);
+            numTiles = columns * rows;
+            tileWidth = Math.ceil(width / columns);
+            tileHeight = Math.ceil(height / rows);
+        }
+    }
+    function updatePixelsPerTile() {
+        const msPerTile = totalElapsedMs / timedTiles;
+        const error = desiredMsPerTile - msPerTile;
+        // tweak to find balance. higher = faster convergence, lower = less fluctuations to microstutters
+        const strength = 5000;
+        // sqrt prevents massive fluctuations in pixelsPerTile for the occasional stutter
+        pixelsPerTile += strength * Math.sign(error) * Math.sqrt(Math.abs(error));
+        pixelsPerTile = Math.max(pixelsPerTile, 8192);
+    }
+    function nextTile(elapsedFrameMs) {
+        // The supplied time belongs to the previous tile. After a reset it may
+        // instead describe scene preparation, compilation, or the previous view.
+        if (currentTile >= 0 && elapsedFrameMs != null &&
+            Number.isFinite(elapsedFrameMs) && elapsedFrameMs > 0) {
+            totalElapsedMs += elapsedFrameMs;
+            timedTiles++;
+        }
+        currentTile++;
+        if (currentTile % numTiles === 0) {
+            if (timedTiles) {
+                updatePixelsPerTile();
+                calcTileDimensions();
+            }
+            totalElapsedMs = 0;
+            timedTiles = 0;
+            currentTile = 0;
+        }
+        const isLastTile = currentTile === numTiles - 1;
+        const x = currentTile % columns;
+        const y = Math.floor(currentTile / columns) % rows;
+        return {
+            xIndex: x,
+            yIndex: y,
+            columns,
+            rows,
+            x: x * tileWidth,
+            y: y * tileHeight,
+            tileWidth,
+            tileHeight,
+            isFirstTile: currentTile === 0,
+            isLastTile,
+            samplesPerFrame: numSamples
+        };
+    }
+    return {
+        nextTile,
+        reset,
+        setSize,
+        setMaxTiles(maxTiles) {
+            maxNumTiles = maxTiles;
+        },
+        setDesiredMsPerTile(time) {
+            desiredMsPerTile = time;
+        },
+        getDesiredMsPerTile() {
+            return desiredMsPerTile;
+        }
+    };
+}
+function getPredictResult(width, height, lastTraceTime, expectFrameTime, tilePixels, maxNumTiles) {
+    const maxTileSize = [width, height];
+    const rawCount = lastTraceTime > 0 ? expectFrameTime / lastTraceTime : 1;
+    // GPU cost is not perfectly linear with tile area: tiny probes include fixed
+    // dispatch overhead, while very large tiles can hit cache and divergence
+    // cliffs. Limit each update to 2x per dimension so prediction converges in a
+    // few samples without jumping from the probe straight to a blocking 4K tile.
+    const count = clamp(rawCount, 0.25, 4);
+    const wScale = Math.sqrt(count);
+    const hScale = count / wScale;
+    let newTileWidth = Math.ceil(wScale * tilePixels[0]);
+    let newTileHeight = Math.ceil(hScale * tilePixels[1]);
+    let samplesPerFrame = 1;
+    if (newTileWidth > maxTileSize[0] * 2) {
+        samplesPerFrame *= Math.floor(newTileWidth / maxTileSize[0]);
+    }
+    newTileWidth = Math.min(newTileWidth, maxTileSize[0]);
+    if (newTileHeight > maxTileSize[1] * 2) {
+        samplesPerFrame *= Math.floor(newTileHeight / maxTileSize[1]);
+    }
+    newTileHeight = Math.min(newTileHeight, maxTileSize[1]);
+    let newColumns = Math.round(width / newTileWidth);
+    let newRows = Math.round(height / newTileHeight);
+    newTileWidth = Math.ceil(width / newColumns);
+    newTileHeight = Math.ceil(height / newRows);
+    let newNumTiles = newRows * newColumns;
+    if (newNumTiles > maxNumTiles) {
+        newNumTiles = maxNumTiles;
+        newColumns = Math.ceil(Math.sqrt(newNumTiles));
+        newRows = Math.ceil(newNumTiles / newColumns);
+        newNumTiles = newColumns * newRows;
+        newTileWidth = Math.ceil(width / newColumns);
+        newTileHeight = Math.ceil(height / newRows);
+    }
+    return {
+        tileWidth: newTileWidth,
+        tileHeight: newTileHeight,
+        columns: newColumns,
+        rows: newRows,
+        numTiles: newNumTiles,
+        samplesPerFrame
+    };
+}
+// A 64x64 probe is dominated by dispatch and timestamp overhead on modern
+// GPUs. At 4K it also leads to an extremely conservative first prediction.
+// Use a still-small but representative amount of work, shaped like the frame.
+const initialProbePixels = 262144;
+function getInitialProbeSize(width, height) {
+    const aspectRatio = width > 0 && height > 0 ? width / height : 1;
+    return [
+        Math.min(width, Math.max(1, Math.round(Math.sqrt(initialProbePixels * aspectRatio)))),
+        Math.min(height, Math.max(1, Math.round(Math.sqrt(initialProbePixels / aspectRatio))))
+    ];
+}
+export function makeTileRenderWithPredict() {
+    let numTiles = 1;
+    let currentTile = -1;
+    let lastTraceTime = -1;
+    let lastFrameTotalTraceTime = 0;
+    let lastFrameTraceTimeValidCount = 0;
+    let tilePixels = [64, 64];
+    let width = 0;
+    let height = 0;
+    let expectFrameTime = 0;
+    // Calcualate
+    let tileWidth = 0;
+    let tileHeight = 0;
+    let samplesPerFrame = 1;
+    let columns = 0;
+    let rows = 0;
+    let maxNumTiles = Infinity;
+    function nextTile() {
+        currentTile++;
+        const avgTileTime = lastFrameTraceTimeValidCount > 0
+            ? lastFrameTotalTraceTime / lastFrameTraceTimeValidCount
+            : lastTraceTime;
+        if (currentTile % numTiles === 0) {
+            currentTile = 0;
+        }
+        if (currentTile === 0) {
+            const result = getPredictResult(width, height, avgTileTime, expectFrameTime, lastTraceTime >= 0 ? tilePixels : getInitialProbeSize(width, height), maxNumTiles);
+            lastFrameTotalTraceTime = 0;
+            lastFrameTraceTimeValidCount = 0;
+            tileWidth = result.tileWidth;
+            tileHeight = result.tileHeight;
+            columns = result.columns;
+            rows = result.rows;
+            numTiles = result.numTiles;
+            samplesPerFrame = result.samplesPerFrame;
+        }
+        const x = currentTile % columns;
+        const y = Math.floor(currentTile / columns) % rows;
+        const isLastTile = currentTile === numTiles - 1;
+        tilePixels = [tileWidth, tileHeight];
+        return {
+            xIndex: x,
+            yIndex: y,
+            columns,
+            rows,
+            x: x * tileWidth,
+            y: y * tileHeight,
+            tileWidth,
+            tileHeight,
+            isFirstTile: currentTile === 0,
+            isLastTile,
+            samplesPerFrame
+        };
+    }
+    return {
+        nextTile,
+        reset() {
+            currentTile = -1;
+        },
+        setSize(w, h) {
+            width = w;
+            height = h;
+        },
+        setMaxTiles(maxTiles) {
+            maxNumTiles = maxTiles;
+        },
+        setDesiredMsPerTile(time) {
+            expectFrameTime = time;
+        },
+        needsUpdatePredicting() {
+            lastTraceTime = -1;
+            lastFrameTotalTraceTime = 0;
+            lastFrameTraceTimeValidCount = 0;
+        },
+        setLastTraceTime(time) {
+            lastTraceTime = time;
+            lastFrameTraceTimeValidCount++;
+            lastFrameTotalTraceTime += time;
+        },
+        getLastTraceTime() {
+            return lastTraceTime;
+        },
+        getDesiredMsPerTile() {
+            return expectFrameTime;
+        }
+    };
+}
+function pixelsPerTileEstimate(gl) {
+    const maxRenderbufferSize = gl.getParameter(gl.MAX_RENDERBUFFER_SIZE);
+    if (maxRenderbufferSize <= 8192) {
+        return 200000;
+    }
+    else {
+        // 16K render targets are common on current desktop/integrated GPUs. The
+        // old 400K seed unnecessarily split even 720p into several tiles and took
+        // dozens of samples to grow to a full-frame tile.
+        return 1000000;
+    }
+}
+//# sourceMappingURL=TileRender.js.map

package/lib/renderer/TileRender.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TileRender.js","sourceRoot":"","sources":["../../src/renderer/TileRender.ts"],"names":[],"mappings":"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","sourcesContent":["// Portions adapted from ray-tracing-renderer@0.10.15\n// (https://github.com/hoverinc/ray-tracing-renderer).\n// Copyright (c) 2019 HOVER, MIT license; see LICENSES/RayTracingRenderer-MIT.txt.\n\nimport { clamp } from './util.js';\n\n// TileRender is based on the concept of a compute shader's work group.\n\n// Path tracing the scene can be very slow (<1 fps).\n// This overworks the GPU and tends to lock up the OS, making it unresponsive.\n\n// To fix this, we can split the screen into smaller tiles, and sample the scene one tile at a time\n// The tile size is set such that each tile takes approximately a constant amount of time to render.\n\n// Since the render time of a tile is dependent on the device, we find the desired tile dimensions by measuring\n// the time it takes to render an arbitrarily-set tile size and adjusting the size according to the benchmark.\n\nexport function makeTileRender(gl?: WebGL2RenderingContext) {\n  let desiredMsPerTile = 21;\n  let maxNumTiles = Infinity;\n\n  let currentTile = -1;\n  let numTiles = 1;\n  let numSamples = 1;\n\n  let tileWidth: number;\n  let tileHeight: number;\n\n  let columns: number;\n  let rows: number;\n\n  let width = 0;\n  let height = 0;\n\n  let totalElapsedMs = 0;\n  let timedTiles = 0;\n\n  // initial number of pixels per rendered tile\n  // based on correlation between system performance and max supported render buffer size\n  // adjusted dynamically according to system performance\n  let pixelsPerTile = gl ? pixelsPerTileEstimate(gl) : 600000;\n\n  function reset() {\n    currentTile = -1;\n    totalElapsedMs = 0;\n    timedTiles = 0;\n  }\n\n  function setSize(w: number, h: number) {\n    width = w;\n    height = h;\n    reset();\n    calcTileDimensions();\n  }\n\n  function calcTileDimensions() {\n    const maxWidth = 3000;\n    const aspectRatio = width / height;\n\n    // quantize the width of the tile so that it evenly divides the entire window\n    tileWidth = Math.ceil(\n      maxWidth /\n        Math.max(\n          Math.round(maxWidth / Math.sqrt(pixelsPerTile * aspectRatio)),\n          1\n        )\n    );\n    tileHeight = Math.ceil(tileWidth / aspectRatio);\n\n    if (tileWidth > width && tileHeight > height) {\n      columns = 1;\n      rows = 1;\n      numTiles = 1;\n\n      numSamples =\n        Math.round(tileWidth / width) * Math.round(tileHeight / height);\n    } else {\n      numSamples = 1;\n\n      columns = Math.ceil(width / tileWidth);\n      rows = Math.ceil(height / tileHeight);\n      numTiles = columns * rows;\n    }\n\n    if (numTiles > maxNumTiles) {\n      // TODO maxNumTiles is not exact value.\n      numTiles = maxNumTiles;\n      columns = Math.ceil(Math.sqrt(numTiles));\n      rows = Math.ceil(numTiles / columns);\n      numTiles = columns * rows;\n      tileWidth = Math.ceil(width / columns);\n      tileHeight = Math.ceil(height / rows);\n    }\n  }\n\n  function updatePixelsPerTile() {\n    const msPerTile = totalElapsedMs / timedTiles;\n\n    const error = desiredMsPerTile - msPerTile;\n\n    // tweak to find balance. higher = faster convergence, lower = less fluctuations to microstutters\n    const strength = 5000;\n\n    // sqrt prevents massive fluctuations in pixelsPerTile for the occasional stutter\n    pixelsPerTile += strength * Math.sign(error) * Math.sqrt(Math.abs(error));\n    pixelsPerTile = Math.max(pixelsPerTile, 8192);\n  }\n\n  function nextTile(elapsedFrameMs?: number) {\n    // The supplied time belongs to the previous tile. After a reset it may\n    // instead describe scene preparation, compilation, or the previous view.\n    if (\n      currentTile >= 0 && elapsedFrameMs != null &&\n      Number.isFinite(elapsedFrameMs) && elapsedFrameMs > 0\n    ) {\n      totalElapsedMs += elapsedFrameMs;\n      timedTiles++;\n    }\n    currentTile++;\n\n    if (currentTile % numTiles === 0) {\n      if (timedTiles) {\n        updatePixelsPerTile();\n        calcTileDimensions();\n      }\n\n      totalElapsedMs = 0;\n      timedTiles = 0;\n      currentTile = 0;\n    }\n\n    const isLastTile = currentTile === numTiles - 1;\n\n    const x = currentTile % columns;\n    const y = Math.floor(currentTile / columns) % rows;\n\n    return {\n      xIndex: x,\n      yIndex: y,\n      columns,\n      rows,\n      x: x * tileWidth,\n      y: y * tileHeight,\n      tileWidth,\n      tileHeight,\n      isFirstTile: currentTile === 0,\n      isLastTile,\n      samplesPerFrame: numSamples\n    };\n  }\n\n  return {\n    nextTile,\n    reset,\n    setSize,\n    setMaxTiles(maxTiles: number) {\n      maxNumTiles = maxTiles;\n    },\n    setDesiredMsPerTile(time: number) {\n      desiredMsPerTile = time;\n    },\n    getDesiredMsPerTile() {\n      return desiredMsPerTile;\n    }\n  };\n}\n\nfunction getPredictResult(\n  width: number,\n  height: number,\n  lastTraceTime: number,\n  expectFrameTime: number,\n  tilePixels: number[],\n  maxNumTiles: number\n) {\n  const maxTileSize = [width, height];\n  const rawCount = lastTraceTime > 0 ? expectFrameTime / lastTraceTime : 1;\n  // GPU cost is not perfectly linear with tile area: tiny probes include fixed\n  // dispatch overhead, while very large tiles can hit cache and divergence\n  // cliffs. Limit each update to 2x per dimension so prediction converges in a\n  // few samples without jumping from the probe straight to a blocking 4K tile.\n  const count = clamp(rawCount, 0.25, 4);\n\n  const wScale = Math.sqrt(count);\n  const hScale = count / wScale;\n\n  let newTileWidth = Math.ceil(wScale * tilePixels[0]);\n  let newTileHeight = Math.ceil(hScale * tilePixels[1]);\n\n  let samplesPerFrame = 1;\n  if (newTileWidth > maxTileSize[0] * 2) {\n    samplesPerFrame *= Math.floor(newTileWidth / maxTileSize[0]);\n  }\n  newTileWidth = Math.min(newTileWidth, maxTileSize[0]);\n  if (newTileHeight > maxTileSize[1] * 2) {\n    samplesPerFrame *= Math.floor(newTileHeight / maxTileSize[1]);\n  }\n  newTileHeight = Math.min(newTileHeight, maxTileSize[1]);\n\n  let newColumns = Math.round(width / newTileWidth);\n  let newRows = Math.round(height / newTileHeight);\n\n  newTileWidth = Math.ceil(width / newColumns);\n  newTileHeight = Math.ceil(height / newRows);\n\n  let newNumTiles = newRows * newColumns;\n\n  if (newNumTiles > maxNumTiles) {\n    newNumTiles = maxNumTiles;\n    newColumns = Math.ceil(Math.sqrt(newNumTiles));\n    newRows = Math.ceil(newNumTiles / newColumns);\n    newNumTiles = newColumns * newRows;\n    newTileWidth = Math.ceil(width / newColumns);\n    newTileHeight = Math.ceil(height / newRows);\n  }\n\n  return {\n    tileWidth: newTileWidth,\n    tileHeight: newTileHeight,\n    columns: newColumns,\n    rows: newRows,\n    numTiles: newNumTiles,\n    samplesPerFrame\n  };\n}\n\n// A 64x64 probe is dominated by dispatch and timestamp overhead on modern\n// GPUs. At 4K it also leads to an extremely conservative first prediction.\n// Use a still-small but representative amount of work, shaped like the frame.\nconst initialProbePixels = 262144;\n\nfunction getInitialProbeSize(width: number, height: number) {\n  const aspectRatio = width > 0 && height > 0 ? width / height : 1;\n  return [\n    Math.min(width, Math.max(1, Math.round(Math.sqrt(initialProbePixels * aspectRatio)))),\n    Math.min(height, Math.max(1, Math.round(Math.sqrt(initialProbePixels / aspectRatio))))\n  ];\n}\n\nexport function makeTileRenderWithPredict() {\n  let numTiles = 1;\n  let currentTile = -1;\n  let lastTraceTime = -1;\n  let lastFrameTotalTraceTime = 0;\n  let lastFrameTraceTimeValidCount = 0;\n  let tilePixels = [64, 64];\n  let width = 0;\n  let height = 0;\n  let expectFrameTime = 0;\n\n  // Calcualate\n  let tileWidth = 0;\n  let tileHeight = 0;\n  let samplesPerFrame = 1;\n  let columns = 0;\n  let rows = 0;\n\n  let maxNumTiles = Infinity;\n\n  function nextTile() {\n    currentTile++;\n    const avgTileTime =\n      lastFrameTraceTimeValidCount > 0\n        ? lastFrameTotalTraceTime / lastFrameTraceTimeValidCount\n        : lastTraceTime;\n\n    if (currentTile % numTiles === 0) {\n      currentTile = 0;\n    }\n\n    if (currentTile === 0) {\n      const result = getPredictResult(\n        width,\n        height,\n        avgTileTime,\n        expectFrameTime,\n        lastTraceTime >= 0 ? tilePixels : getInitialProbeSize(width, height),\n        maxNumTiles\n      );\n\n      lastFrameTotalTraceTime = 0;\n      lastFrameTraceTimeValidCount = 0;\n      tileWidth = result.tileWidth;\n      tileHeight = result.tileHeight;\n      columns = result.columns;\n      rows = result.rows;\n      numTiles = result.numTiles;\n      samplesPerFrame = result.samplesPerFrame;\n    }\n\n    const x = currentTile % columns;\n    const y = Math.floor(currentTile / columns) % rows;\n    const isLastTile = currentTile === numTiles - 1;\n\n    tilePixels = [tileWidth, tileHeight];\n\n    return {\n      xIndex: x,\n      yIndex: y,\n      columns,\n      rows,\n      x: x * tileWidth,\n      y: y * tileHeight,\n      tileWidth,\n      tileHeight,\n      isFirstTile: currentTile === 0,\n      isLastTile,\n      samplesPerFrame\n    };\n  }\n\n  return {\n    nextTile,\n    reset() {\n      currentTile = -1;\n    },\n    setSize(w: number, h: number) {\n      width = w;\n      height = h;\n    },\n    setMaxTiles(maxTiles: number) {\n      maxNumTiles = maxTiles;\n    },\n    setDesiredMsPerTile(time: number) {\n      expectFrameTime = time;\n    },\n    needsUpdatePredicting() {\n      lastTraceTime = -1;\n      lastFrameTotalTraceTime = 0;\n      lastFrameTraceTimeValidCount = 0;\n    },\n    setLastTraceTime(time: number) {\n      lastTraceTime = time;\n      lastFrameTraceTimeValidCount++;\n      lastFrameTotalTraceTime += time;\n    },\n    getLastTraceTime() {\n      return lastTraceTime;\n    },\n    getDesiredMsPerTile() {\n      return expectFrameTime;\n    }\n  };\n}\n\nexport type TileRenderWithPredict = ReturnType<\n  typeof makeTileRenderWithPredict\n>;\n\nfunction pixelsPerTileEstimate(gl: WebGL2RenderingContext) {\n  const maxRenderbufferSize = gl.getParameter(gl.MAX_RENDERBUFFER_SIZE);\n\n  if (maxRenderbufferSize <= 8192) {\n    return 200000;\n  } else {\n    // 16K render targets are common on current desktop/integrated GPUs. The\n    // old 400K seed unnecessarily split even 720p into several tiles and took\n    // dozens of samples to grow to a full-frame tile.\n    return 1000000;\n  }\n}\n"]}

package/lib/renderer/WGPUBloomPass.d.ts

@@ -0,0 +1,17 @@
+declare class WGPUBloomPass {
+    private _brightPass;
+    private _downsamplePasses;
+    private _blurHPasses;
+    private _blurVPasses;
+    private _blendPasses;
+    constructor(device: GPUDevice);
+    reserveCapacity(): void;
+    setSize(width: number, height: number): void;
+    setBrightThreshold(threshold: number): void;
+    setRadius(radius: number): void;
+    createPass(encoder: GPUCommandEncoder, colorTex: GPUTexture): GPUTexture;
+    getMemoryBytes(): number;
+    dispose(): void;
+    getOutput(): GPUTexture;
+}
+export default WGPUBloomPass;

package/lib/renderer/WGPUBloomPass.js

@@ -0,0 +1,243 @@
+import { WGPUFullQuadPass } from './WGPUFullQuadPass.js';
+const COUNT = 5;
+const linearSamplerDescriptor = {
+    magFilter: 'linear',
+    minFilter: 'linear'
+};
+function createBrightPass(device) {
+    return new WGPUFullQuadPass('bright', device, {
+        inputs: ['colorTex'],
+        outputs: ['color'],
+        uniforms: [
+            {
+                label: 'threshold',
+                type: 'f32',
+                data: 1
+            },
+            {
+                label: 'scale',
+                type: 'f32',
+                data: 1
+            }
+        ],
+        fsDefine: /*wgsl*/ `
+fn sm(a: vec4f, b: vec4f, c: vec4f) -> vec4f {
+return a + b + c - min(min(a, b), c) - max(max(a, b), c);
+}
+`,
+        fsMain: /*wgsl*/ `
+${''
+        // Use median filter to reduce noise
+        // https://github.com/keijiro/KinoBloom/blob/master/Assets/Kino/Bloom/Shader/Bloom.cginc#L96
+        }
+let d = vec3i(1, 1, 0);
+
+var iW = load_colorTex(uv, 0);
+let s1 = load_colorTex(uv - d.xz, 0);
+let s2 = load_colorTex(uv + d.xz, 0);
+let s3 = load_colorTex(uv - d.zy, 0);
+let s4 = load_colorTex(uv + d.zy, 0);
+iW = sm(sm(iW, s1, s2), s3, s4);
+
+
+let lum = dot(iW.rgb, vec3f(0.2125, 0.7154, 0.0721));
+var color: vec4f;
+if (lum > threshold && iW.a > 0.0) {
+color = vec4f(iW.rgb * scale, iW.a);
+} else {
+
+color = vec4f(vec3(0.0), iW.a);
+}
+output.color = color;
+`
+    });
+}
+function createDownsamplePass(device) {
+    return new WGPUFullQuadPass('downsample', device, {
+        inputs: ['colorTex'],
+        outputs: ['color'],
+        uniforms: [],
+        samplers: {
+            linearSampler: device.createSampler(linearSamplerDescriptor)
+        },
+        fsDefine: /*wgsl*/ `
+fn vL(c: vec3f) -> f32 {
+return max(max(c.r, c.g), c.b);
+}
+`,
+        fsMain: /*wgsl*/ `
+let size = vec2f(colorTexRegion());
+let d = vec4f(-1.0, -1.0, 1.0, 1.0) / size.xyxy;
+${''}
+output.color = sample_colorTex_linearSampler(uv2 + d.xy) * 0.25
++ sample_colorTex_linearSampler(uv2 + d.zy) * 0.25
++ sample_colorTex_linearSampler(uv2 + d.xw) * 0.25
++ sample_colorTex_linearSampler(uv2 + d.zw) * 0.25;
+`
+    });
+}
+function createGaussianPass(device) {
+    return new WGPUFullQuadPass('gaussian', device, {
+        inputs: ['colorTex'],
+        outputs: ['color'],
+        uniforms: [
+            {
+                label: 'direction',
+                type: 'vec2f',
+                data: [1, 0]
+            },
+            {
+                label: 'size',
+                type: 'f32',
+                data: 1.0
+            }
+        ],
+        samplers: {
+            linearSampler: device.createSampler(linearSamplerDescriptor)
+        },
+        fsDefine: /*wgsl*/ `
+const vP = array<f32, 9>(0.07, 0.09, 0.12, 0.14, 0.16, 0.14, 0.12, 0.09, 0.07);
+`,
+        fsMain: /*wgsl*/ `
+let vE = vec2f(colorTexRegion());
+let off = direction / vE * size;
+
+var sum = vec4f(0.0);
+var sU = 0.0;
+for (var i = 0; i < 9; i++) {
+let w = vP[i];
+sum += sample_colorTex_linearSampler(uv2 + off * f32(i - 4)) * w;
+sU += w;
+}
+output.color = sum / max(sU, 0.01);
+`
+    });
+}
+function createBlendPass(device) {
+    return new WGPUFullQuadPass('blend', device, {
+        inputs: ['colorTex1', 'colorTex2'],
+        outputs: ['color'],
+        uniforms: [
+            {
+                label: 'weight',
+                type: 'f32',
+                data: 0.3
+            }
+        ],
+        samplers: {
+            linearSampler: device.createSampler(linearSamplerDescriptor)
+        },
+        fsMain: /*wgsl*/ `
+let vM = sample_colorTex1_linearSampler(uv2);
+let vN = sample_colorTex2_linearSampler(uv2);
+output.color = mix(vM, vN, weight);
+`
+    });
+}
+class WGPUBloomPass {
+    _brightPass;
+    _downsamplePasses = [];
+    _blurHPasses = [];
+    _blurVPasses = [];
+    _blendPasses = [];
+    constructor(device) {
+        this._brightPass = createBrightPass(device);
+        const commonOutputParams = {
+            color: {
+                format: 'rgba16float'
+            }
+        };
+        this._brightPass.setOutputParams(commonOutputParams);
+        for (let i = 0; i <= COUNT; i++) {
+            const downsamplePass = createDownsamplePass(device);
+            const blurHPass = createGaussianPass(device);
+            const blurVPass = createGaussianPass(device);
+            downsamplePass.setOutputParams(commonOutputParams);
+            blurHPass.setOutputParams(commonOutputParams);
+            blurVPass.setOutputParams(commonOutputParams);
+            blurHPass.setUniform('direction', [1, 0]);
+            blurVPass.setUniform('direction', [0, 1]);
+            this._downsamplePasses.push(downsamplePass);
+            this._blurHPasses.push(blurHPass);
+            this._blurVPasses.push(blurVPass);
+            if (i > 0) {
+                const blendPass = createBlendPass(device);
+                blendPass.setOutputParams(commonOutputParams);
+                this._blendPasses.push(blendPass);
+            }
+        }
+    }
+    reserveCapacity() {
+        [this._brightPass, ...this._downsamplePasses, ...this._blurHPasses, ...this._blurVPasses, ...this._blendPasses].forEach(pass => pass.reserveCapacity());
+    }
+    setSize(width, height) {
+        this._brightPass.setSize(width, height);
+        for (let i = 0; i <= COUNT; i++) {
+            this._downsamplePasses[i].setSize(width >> (i + 1), height >> (i + 1));
+            this._blurHPasses[i].setSize(width >> (i + 1), height >> (i + 1));
+            this._blurVPasses[i].setSize(width >> i, height >> i);
+            if (i > 0) {
+                this._blendPasses[i - 1].setSize(width >> (i - 1), height >> (i - 1));
+            }
+        }
+    }
+    setBrightThreshold(threshold) {
+        this._brightPass.setUniform('threshold', threshold);
+    }
+    setRadius(radius) {
+        this._blendPasses.forEach((blendPass) => {
+            blendPass.setUniform('weight', 
+            // Use weight to control radius
+            1 - Math.max(Math.min(radius ** 0.3 * 0.8, 0.8), 0));
+        });
+        [...this._blurHPasses, ...this._blurVPasses].forEach((blurPass) => {
+            //Some magic fomular
+            blurPass.setUniform('size', Math.max(Math.min(radius * 2, 1.0), 0.2));
+        });
+    }
+    createPass(encoder, colorTex) {
+        const brightPass = this._brightPass;
+        const downSamplePasses = this._downsamplePasses;
+        const blendPasses = this._blendPasses;
+        const blurHPasses = this._blurHPasses;
+        const blurVPasses = this._blurVPasses;
+        brightPass.createPass(encoder, { colorTex });
+        // Downsample
+        for (let i = 0; i <= COUNT; i++) {
+            const colorTex1 = (i === 0 ? brightPass : downSamplePasses[i - 1]).getOutput('color');
+            downSamplePasses[i].createPass(encoder, { colorTex: colorTex1 });
+        }
+        // Upsample with gaussian and blending
+        for (let i = COUNT; i >= 0; i--) {
+            // Blur
+            blurHPasses[i].createPass(encoder, {
+                colorTex: downSamplePasses[i].getOutput('color')
+            });
+            blurVPasses[i].createPass(encoder, {
+                colorTex: blurHPasses[i].getOutput('color')
+            });
+        }
+        for (let i = COUNT - 1; i >= 0; i--) {
+            blendPasses[i].createPass(encoder, {
+                colorTex1: (i === COUNT - 1
+                    ? blurVPasses[COUNT]
+                    : blendPasses[i + 1]).getOutput('color'),
+                colorTex2: blurVPasses[i].getOutput('color')
+            });
+        }
+        return blendPasses[0].getOutput('color');
+    }
+    getMemoryBytes() {
+        return [this._brightPass, ...this._downsamplePasses, ...this._blurHPasses, ...this._blurVPasses, ...this._blendPasses]
+            .reduce((sum, pass) => sum + pass.getMemoryBytes(), 0);
+    }
+    dispose() {
+        this._brightPass.dispose();
+        [...this._downsamplePasses, ...this._blurHPasses, ...this._blurVPasses, ...this._blendPasses].forEach(pass => pass.dispose());
+    }
+    getOutput() {
+        return this._blendPasses[0].getOutput('color');
+    }
+}
+export default WGPUBloomPass;
+//# sourceMappingURL=WGPUBloomPass.js.map

package/lib/renderer/WGPUBloomPass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WGPUBloomPass.js","sourceRoot":"","sources":["../../src/renderer/WGPUBloomPass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,MAAM,KAAK,GAAG,CAAC,CAAC;AAEhB,MAAM,uBAAuB,GAAG;IAC9B,SAAS,EAAE,QAAQ;IACnB,SAAS,EAAE,QAAQ;CACW,CAAC;AAEjC,SAAS,gBAAgB,CAAC,MAAiB;IACzC,OAAO,IAAI,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE;QAC5C,MAAM,EAAE,CAAC,UAAU,CAAC;QACpB,OAAO,EAAE,CAAC,OAAO,CAAC;QAClB,QAAQ,EAAE;YACR;gBACE,KAAK,EAAE,WAAW;gBAClB,IAAI,EAAE,KAAK;gBACX,IAAI,EAAE,CAAC;aACR;YACD;gBACE,KAAK,EAAE,OAAO;gBACd,IAAI,EAAE,KAAK;gBACX,IAAI,EAAE,CAAC;aACR;SACF;QACD,QAAQ,EAAE,QAAQ,CAAC;;;;CAItB;QACG,MAAM,EAAE,QAAQ,CAAC;EAEnB,EAAE;QACF,oCAAoC;QACpC,4FAA4F;QAC9F;;;;;;;;;;;;;;;;;;;;CAoBC;KACE,CAAC,CAAC;AACL,CAAC;AAED,SAAS,oBAAoB,CAAC,MAAiB;IAC7C,OAAO,IAAI,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE;QAChD,MAAM,EAAE,CAAC,UAAU,CAAC;QACpB,OAAO,EAAE,CAAC,OAAO,CAAC;QAClB,QAAQ,EAAE,EAAE;QACZ,QAAQ,EAAE;YACR,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,uBAAuB,CAAC;SAC7D;QACD,QAAQ,EAAE,QAAQ,CAAC;;;;CAItB;QACG,MAAM,EAAE,QAAQ,CAAC;;;EAInB,EACF;;;;;CAKC;KACE,CAAC,CAAC;AACL,CAAC;AAED,SAAS,kBAAkB,CAAC,MAAiB;IAC3C,OAAO,IAAI,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE;QAC9C,MAAM,EAAE,CAAC,UAAU,CAAC;QACpB,OAAO,EAAE,CAAC,OAAO,CAAC;QAClB,QAAQ,EAAE;YACR;gBACE,KAAK,EAAE,WAAW;gBAClB,IAAI,EAAE,OAAO;gBACb,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;aACb;YACD;gBACE,KAAK,EAAE,MAAM;gBACb,IAAI,EAAE,KAAK;gBACX,IAAI,EAAE,GAAG;aACV;SACF;QACD,QAAQ,EAAE;YACR,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,uBAAuB,CAAC;SAC7D;QACD,QAAQ,EAAE,QAAQ,CAAC;;CAEtB;QACG,MAAM,EAAE,QAAQ,CAAC;;;;;;;;;;;;CAYpB;KACE,CAAC,CAAC;AACL,CAAC;AAED,SAAS,eAAe,CAAC,MAAiB;IACxC,OAAO,IAAI,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE;QAC3C,MAAM,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC;QAClC,OAAO,EAAE,CAAC,OAAO,CAAC;QAClB,QAAQ,EAAE;YACR;gBACE,KAAK,EAAE,QAAQ;gBACf,IAAI,EAAE,KAAK;gBACX,IAAI,EAAE,GAAG;aACV;SACF;QAED,QAAQ,EAAE;YACR,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,uBAAuB,CAAC;SAC7D;QACD,MAAM,EAAE,QAAQ,CAAC;;;;CAIpB;KACE,CAAC,CAAC;AACL,CAAC;AAED,MAAM,aAAa;IACT,WAAW,CAAC;IACZ,iBAAiB,GAA8C,EAAE,CAAC;IAClE,YAAY,GAA4C,EAAE,CAAC;IAC3D,YAAY,GAA4C,EAAE,CAAC;IAC3D,YAAY,GAAyC,EAAE,CAAC;IAEhE,YAAY,MAAiB;QAC3B,IAAI,CAAC,WAAW,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAC5C,MAAM,kBAAkB,GAAG;YACzB,KAAK,EAAE;gBACL,MAAM,EAAE,aAAa;aACtB;SACO,CAAC;QACX,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC;QACrD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YAChC,MAAM,cAAc,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC;YACpD,MAAM,SAAS,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;YAC7C,MAAM,SAAS,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;YAC7C,cAAc,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC;YACnD,SAAS,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC;YAC9C,SAAS,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC;YAC9C,SAAS,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC1C,SAAS,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC1C,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YAC5C,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAClC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAClC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBACV,MAAM,SAAS,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC;gBAC1C,SAAS,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC;gBAC9C,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACpC,CAAC;QACH,CAAC;IACH,CAAC;IAED,eAAe;QACb,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,iBAAiB,EAAE,GAAG,IAAI,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;IAC1J,CAAC;IAED,OAAO,CAAC,KAAa,EAAE,MAAc;QACnC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YAChC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACvE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAClE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC;YACtD,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBACV,IAAI,CAAC,YAAY,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACxE,CAAC;QACH,CAAC;IACH,CAAC;IAED,kBAAkB,CAAC,SAAiB;QAClC,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;IACtD,CAAC;IAED,SAAS,CAAC,MAAc;QACtB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;YACtC,SAAS,CAAC,UAAU,CAClB,QAAQ;YACR,+BAA+B;YAC/B,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,IAAI,GAAG,GAAG,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CACpD,CAAC;QACJ,CAAC,CAAC,CAAC;QACH,CAAC,GAAG,IAAI,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;YAChE,oBAAoB;YACpB,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;QACxE,CAAC,CAAC,CAAC;IACL,CAAC;IAED,UAAU,CAAC,OAA0B,EAAE,QAAoB;QACzD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC;QACpC,MAAM,gBAAgB,GAAG,IAAI,CAAC,iBAAiB,CAAC;QAChD,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC;QACtC,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC;QACtC,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC;QACtC,UAAU,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC7C,aAAa;QACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YAChC,MAAM,SAAS,GAAG,CAChB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,GAAG,CAAC,CAAC,CAC/C,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;YACrB,gBAAgB,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;QACnE,CAAC;QAED,sCAAsC;QACtC,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAChC,OAAO;YACP,WAAW,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,EAAE;gBACjC,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC;aACjD,CAAC,CAAC;YACH,WAAW,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,EAAE;gBACjC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC;aAC5C,CAAC,CAAC;QACL,CAAC;QACD,KAAK,IAAI,CAAC,GAAG,KAAK,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACpC,WAAW,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,EAAE;gBACjC,SAAS,EAAE,CAAC,CAAC,KAAK,KAAK,GAAG,CAAC;oBACzB,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC;oBACpB,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CACrB,CAAC,SAAS,CAAC,OAAO,CAAC;gBACpB,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC;aAC7C,CAAC,CAAC;QACL,CAAC;QAED,OAAO,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAC3C,CAAC;IAED,cAAc;QACZ,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,iBAAiB,EAAE,GAAG,IAAI,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC;aACnH,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC,CAAC;IAC3D,CAAC;IAED,OAAO;QACL,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;QAC3B,CAAC,GAAG,IAAI,CAAC,iBAAiB,EAAE,GAAG,IAAI,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IAChI,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IACjD,CAAC;CACF;AAED,eAAe,aAAa,CAAC","sourcesContent":["import { WGPUFullQuadPass } from './WGPUFullQuadPass.js';\n\nconst COUNT = 5;\n\nconst linearSamplerDescriptor = {\n  magFilter: 'linear',\n  minFilter: 'linear'\n} satisfies GPUSamplerDescriptor;\n\nfunction createBrightPass(device: GPUDevice) {\n  return new WGPUFullQuadPass('bright', device, {\n    inputs: ['colorTex'],\n    outputs: ['color'],\n    uniforms: [\n      {\n        label: 'threshold',\n        type: 'f32',\n        data: 1\n      },\n      {\n        label: 'scale',\n        type: 'f32',\n        data: 1\n      }\n    ],\n    fsDefine: /*wgsl*/ `\nfn median(a: vec4f, b: vec4f, c: vec4f) -> vec4f {\nreturn a + b + c - min(min(a, b), c) - max(max(a, b), c);\n}\n`,\n    fsMain: /*wgsl*/ `\n${\n  ''\n  // Use median filter to reduce noise\n  // https://github.com/keijiro/KinoBloom/blob/master/Assets/Kino/Bloom/Shader/Bloom.cginc#L96\n}\nlet d = vec3i(1, 1, 0);\n\nvar texel = load_colorTex(uv, 0);\nlet s1 = load_colorTex(uv - d.xz, 0);\nlet s2 = load_colorTex(uv + d.xz, 0);\nlet s3 = load_colorTex(uv - d.zy, 0);\nlet s4 = load_colorTex(uv + d.zy, 0);\ntexel = median(median(texel, s1, s2), s3, s4);\n\n// Premultiplied Alpha\nlet lum = dot(texel.rgb, vec3f(0.2125, 0.7154, 0.0721));\nvar color: vec4f;\nif (lum > threshold && texel.a > 0.0) {\n  color = vec4f(texel.rgb * scale, texel.a);\n} else {\n  // Bleed the alpha to avoid sharp edge when using alpha\n  color = vec4f(vec3(0.0), texel.a);\n}\noutput.color = color;\n`\n  });\n}\n\nfunction createDownsamplePass(device: GPUDevice) {\n  return new WGPUFullQuadPass('downsample', device, {\n    inputs: ['colorTex'],\n    outputs: ['color'],\n    uniforms: [],\n    samplers: {\n      linearSampler: device.createSampler(linearSamplerDescriptor)\n    },\n    fsDefine: /*wgsl*/ `\nfn brightness(c: vec3f) -> f32 {\n  return max(max(c.r, c.g), c.b);\n}\n`,\n    fsMain: /*wgsl*/ `\nlet size = vec2f(colorTexRegion());\nlet d = vec4f(-1.0, -1.0, 1.0, 1.0) / size.xyxy;\n${\n  ''\n}\noutput.color = sample_colorTex_linearSampler(uv2 + d.xy) * 0.25\n  + sample_colorTex_linearSampler(uv2 + d.zy) * 0.25\n  + sample_colorTex_linearSampler(uv2 + d.xw) * 0.25\n  + sample_colorTex_linearSampler(uv2 + d.zw) * 0.25;\n`\n  });\n}\n\nfunction createGaussianPass(device: GPUDevice) {\n  return new WGPUFullQuadPass('gaussian', device, {\n    inputs: ['colorTex'],\n    outputs: ['color'],\n    uniforms: [\n      {\n        label: 'direction',\n        type: 'vec2f',\n        data: [1, 0]\n      },\n      {\n        label: 'size',\n        type: 'f32',\n        data: 1.0\n      }\n    ],\n    samplers: {\n      linearSampler: device.createSampler(linearSamplerDescriptor)\n    },\n    fsDefine: /*wgsl*/ `\nconst kernel = array<f32, 9>(0.07, 0.09, 0.12, 0.14, 0.16, 0.14, 0.12, 0.09, 0.07);\n`,\n    fsMain: /*wgsl*/ `\nlet texSize = vec2f(colorTexRegion());\nlet off = direction / texSize * size;\n\nvar sum = vec4f(0.0);\nvar weightAll = 0.0;\nfor (var i = 0; i < 9; i++) {\n  let w = kernel[i];\n  sum += sample_colorTex_linearSampler(uv2 + off * f32(i - 4)) * w;\n  weightAll += w;\n}\noutput.color = sum / max(weightAll, 0.01);\n`\n  });\n}\n\nfunction createBlendPass(device: GPUDevice) {\n  return new WGPUFullQuadPass('blend', device, {\n    inputs: ['colorTex1', 'colorTex2'],\n    outputs: ['color'],\n    uniforms: [\n      {\n        label: 'weight',\n        type: 'f32',\n        data: 0.3\n      }\n    ],\n\n    samplers: {\n      linearSampler: device.createSampler(linearSamplerDescriptor)\n    },\n    fsMain: /*wgsl*/ `\nlet color1 = sample_colorTex1_linearSampler(uv2);\nlet color2 = sample_colorTex2_linearSampler(uv2);\noutput.color = mix(color1, color2, weight);\n`\n  });\n}\n\nclass WGPUBloomPass {\n  private _brightPass;\n  private _downsamplePasses: ReturnType<typeof createDownsamplePass>[] = [];\n  private _blurHPasses: ReturnType<typeof createGaussianPass>[] = [];\n  private _blurVPasses: ReturnType<typeof createGaussianPass>[] = [];\n  private _blendPasses: ReturnType<typeof createBlendPass>[] = [];\n\n  constructor(device: GPUDevice) {\n    this._brightPass = createBrightPass(device);\n    const commonOutputParams = {\n      color: {\n        format: 'rgba16float'\n      }\n    } as const;\n    this._brightPass.setOutputParams(commonOutputParams);\n    for (let i = 0; i <= COUNT; i++) {\n      const downsamplePass = createDownsamplePass(device);\n      const blurHPass = createGaussianPass(device);\n      const blurVPass = createGaussianPass(device);\n      downsamplePass.setOutputParams(commonOutputParams);\n      blurHPass.setOutputParams(commonOutputParams);\n      blurVPass.setOutputParams(commonOutputParams);\n      blurHPass.setUniform('direction', [1, 0]);\n      blurVPass.setUniform('direction', [0, 1]);\n      this._downsamplePasses.push(downsamplePass);\n      this._blurHPasses.push(blurHPass);\n      this._blurVPasses.push(blurVPass);\n      if (i > 0) {\n        const blendPass = createBlendPass(device);\n        blendPass.setOutputParams(commonOutputParams);\n        this._blendPasses.push(blendPass);\n      }\n    }\n  }\n\n  reserveCapacity() {\n    [this._brightPass, ...this._downsamplePasses, ...this._blurHPasses, ...this._blurVPasses, ...this._blendPasses].forEach(pass => pass.reserveCapacity());\n  }\n\n  setSize(width: number, height: number) {\n    this._brightPass.setSize(width, height);\n    for (let i = 0; i <= COUNT; i++) {\n      this._downsamplePasses[i].setSize(width >> (i + 1), height >> (i + 1));\n      this._blurHPasses[i].setSize(width >> (i + 1), height >> (i + 1));\n      this._blurVPasses[i].setSize(width >> i, height >> i);\n      if (i > 0) {\n        this._blendPasses[i - 1].setSize(width >> (i - 1), height >> (i - 1));\n      }\n    }\n  }\n\n  setBrightThreshold(threshold: number) {\n    this._brightPass.setUniform('threshold', threshold);\n  }\n\n  setRadius(radius: number) {\n    this._blendPasses.forEach((blendPass) => {\n      blendPass.setUniform(\n        'weight',\n        // Use weight to control radius\n        1 - Math.max(Math.min(radius ** 0.3 * 0.8, 0.8), 0)\n      );\n    });\n    [...this._blurHPasses, ...this._blurVPasses].forEach((blurPass) => {\n      //Some magic fomular\n      blurPass.setUniform('size', Math.max(Math.min(radius * 2, 1.0), 0.2));\n    });\n  }\n\n  createPass(encoder: GPUCommandEncoder, colorTex: GPUTexture) {\n    const brightPass = this._brightPass;\n    const downSamplePasses = this._downsamplePasses;\n    const blendPasses = this._blendPasses;\n    const blurHPasses = this._blurHPasses;\n    const blurVPasses = this._blurVPasses;\n    brightPass.createPass(encoder, { colorTex });\n    // Downsample\n    for (let i = 0; i <= COUNT; i++) {\n      const colorTex1 = (\n        i === 0 ? brightPass : downSamplePasses[i - 1]\n      ).getOutput('color');\n      downSamplePasses[i].createPass(encoder, { colorTex: colorTex1 });\n    }\n\n    // Upsample with gaussian and blending\n    for (let i = COUNT; i >= 0; i--) {\n      // Blur\n      blurHPasses[i].createPass(encoder, {\n        colorTex: downSamplePasses[i].getOutput('color')\n      });\n      blurVPasses[i].createPass(encoder, {\n        colorTex: blurHPasses[i].getOutput('color')\n      });\n    }\n    for (let i = COUNT - 1; i >= 0; i--) {\n      blendPasses[i].createPass(encoder, {\n        colorTex1: (i === COUNT - 1\n          ? blurVPasses[COUNT]\n          : blendPasses[i + 1]\n        ).getOutput('color'),\n        colorTex2: blurVPasses[i].getOutput('color')\n      });\n    }\n\n    return blendPasses[0].getOutput('color');\n  }\n\n  getMemoryBytes() {\n    return [this._brightPass, ...this._downsamplePasses, ...this._blurHPasses, ...this._blurVPasses, ...this._blendPasses]\n      .reduce((sum, pass) => sum + pass.getMemoryBytes(), 0);\n  }\n\n  dispose() {\n    this._brightPass.dispose();\n    [...this._downsamplePasses, ...this._blurHPasses, ...this._blurVPasses, ...this._blendPasses].forEach(pass => pass.dispose());\n  }\n\n  getOutput() {\n    return this._blendPasses[0].getOutput('color');\n  }\n}\n\nexport default WGPUBloomPass;\n"]}

package/lib/renderer/WGPUCanvasSurface.d.ts

@@ -0,0 +1,21 @@
+type InspectableContext = GPUCanvasContext & {
+    getConfiguration?: () => GPUCanvasConfiguration & {
+        toneMapping?: {
+            mode?: string;
+        };
+    };
+};
+/** One canvas surface; composing or exporting an image never reconfigures it. */
+export declare class WGPUCanvasSurface {
+    private readonly device;
+    private readonly standardFormat;
+    readonly context: InspectableContext;
+    hdr: boolean;
+    private compatibleHDR?;
+    constructor(canvas: HTMLCanvasElement | OffscreenCanvas, device: GPUDevice, standardFormat: GPUTextureFormat);
+    get format(): GPUTextureFormat;
+    get supportsHDR(): boolean;
+    configure(enabled: boolean): void;
+    dispose(): void;
+}
+export {};