@babylonjs-toolkit/next 9.22.2 → 9.28.0

package/lib/lutblendplugin.js

@@ -1,153 +0,0 @@
-import { Texture } from '@babylonjs/core/Materials/Textures/texture';
-import { PostProcess } from '@babylonjs/core';
-export class LUTBlendPlugin {
-    static CreatePostProcess(scene, camera, options) {
-        const lutA = options?.lutA || null;
-        const lutB = options?.lutB || null;
-        const mix = options?.mix ?? 0.0;
-        const fragment = `
-                precision highp float;
-                varying vec2 vUV;
-                uniform sampler2D textureSampler;
-                uniform sampler2D lutA;
-                uniform sampler2D lutB;
-                uniform float mixVal;
-                uniform float lutTileCountA; // number of tiles per row for LUT A
-                uniform float lutTileCountB; // number of tiles per row for LUT B
-
-                vec3 sampleLUT(in sampler2D lut, in vec3 color, in float tileCount) {
-                    if (tileCount <= 0.5) return color;
-                    float tc = floor(tileCount + 0.5);
-                    float tileSize = 1.0 / tc;
-
-                    // For normalized RGB [0..1], compute position in LUT
-                    float r = color.r;
-                    float g = color.g;
-                    float b = color.b;
-
-                    // Determine slice and tile coords
-                    float slice = b * (tc - 1.0);
-                    float sliceIndex = floor(slice + 0.5);
-
-                    float tx = mod(sliceIndex, tc);
-                    float ty = floor(sliceIndex / tc);
-
-                    vec2 uv = vec2(tx * tileSize + r * tileSize, ty * tileSize + g * tileSize);
-                    vec3 sampled = texture2D(lut, uv).rgb;
-                    return sampled;
-                }
-
-                void main(void) {
-                    vec4 sceneColor = texture2D(textureSampler, vUV);
-                    vec3 a = sceneColor.rgb;
-                    if (lutTileCountA <= 0.5 || lutTileCountB <= 0.5) {
-                        // No LUT size provided fallback to passthrough
-                        gl_FragColor = sceneColor;
-                        return;
-                    }
-                    vec3 colA = sampleLUT(lutA, a, lutTileCountA);
-                    vec3 colB = sampleLUT(lutB, a, lutTileCountB);
-                    vec3 outc = mix(colA, colB, mixVal);
-                    gl_FragColor = vec4(outc, sceneColor.a);
-                }
-            `;
-        const post = new PostProcess("lutBlend", fragment, ["mixVal", "lutTileCountA", "lutTileCountB"], ["lutA", "lutB"], 1.0, camera, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false);
-        function detectTileCountFromDims(w, h) {
-            if (!w || !h)
-                return 0;
-            if (w % h === 0)
-                return Math.round(w / h);
-            if (h % w === 0)
-                return Math.round(h / w);
-            if (w === h) {
-                const t = Math.round(Math.sqrt(w));
-                if (t * t === w)
-                    return t;
-                return Math.round(Math.sqrt(w));
-            }
-            return Math.round(Math.pow(w * h, 1.0 / 3.0));
-        }
-        let tileA = 0, tileB = 0;
-        post.onApply = (effect) => {
-            effect.setFloat('mixVal', mix);
-            if (lutA && typeof lutA === 'string') {
-                const tA = new Texture(lutA, scene, true, false, Texture.TRILINEAR_SAMPLINGMODE, undefined, undefined, undefined, false);
-                tA.onLoadObservable.addOnce(() => {
-                    tileA = detectTileCountFromDims(tA.getSize ? tA.getSize().width : tA.width, tA.getSize ? tA.getSize().height : tA.height);
-                });
-                effect.setTexture('lutA', tA);
-            }
-            else if (lutA instanceof Texture) {
-                const tA = lutA;
-                tileA = detectTileCountFromDims(tA.getSize ? tA.getSize().width : tA.width, tA.getSize ? tA.getSize().height : tA.height);
-                effect.setTexture('lutA', tA);
-            }
-            if (lutB && typeof lutB === 'string') {
-                const tB = new Texture(lutB, scene, true, false, Texture.TRILINEAR_SAMPLINGMODE, undefined, undefined, undefined, false);
-                tB.onLoadObservable.addOnce(() => {
-                    tileB = detectTileCountFromDims(tB.getSize ? tB.getSize().width : tB.width, tB.getSize ? tB.getSize().height : tB.height);
-                });
-                effect.setTexture('lutB', tB);
-            }
-            else if (lutB instanceof Texture) {
-                const tB = lutB;
-                tileB = detectTileCountFromDims(tB.getSize ? tB.getSize().width : tB.width, tB.getSize ? tB.getSize().height : tB.height);
-                effect.setTexture('lutB', tB);
-            }
-            effect.setFloat('lutTileCountA', tileA);
-            effect.setFloat('lutTileCountB', tileB);
-        };
-        post._detectedTileCountA = () => tileA;
-        post._detectedTileCountB = () => tileB;
-        return post;
-    }
-    getWGSLShaderCode() {
-        return `
-                [[group(0), binding(0)]] var textureSampler: texture_2d<f32>;
-                [[group(0), binding(1)]] var textureSamplerSampler: sampler;
-                [[group(0), binding(2)]] var lutA: texture_2d<f32>;
-                [[group(0), binding(3)]] var lutASampler: sampler;
-                [[group(0), binding(4)]] var lutB: texture_2d<f32>;
-                [[group(0), binding(5)]] var lutBSampler: sampler;
-
-                [[block]] struct Uniforms {
-                    mixVal: f32;
-                    lutTileCountA: f32;
-                    lutTileCountB: f32;
-                };
-                [[group(0), binding(6)]] var<uniform> uniforms: Uniforms;
-
-                fn sampleLUT(lut: texture_2d<f32>, lutSamp: sampler, color: vec3<f32>, tileCount: f32) -> vec3<f32> {
-                    if (tileCount <= 0.5) { return color; }
-                    let tc = floor(tileCount + 0.5);
-                    let tileSize = 1.0 / tc;
-
-                    let r = color.r;
-                    let g = color.g;
-                    let b = color.b;
-
-                    let slice = b * (tc - 1.0);
-                    let sliceIndex = floor(slice + 0.5);
-
-                    let tx = sliceIndex % tc;
-                    let ty = floor(sliceIndex / tc);
-
-                    let uv = vec2<f32>(tx * tileSize + r * tileSize, ty * tileSize + g * tileSize);
-                    let sampled = textureSample(lut, lutSamp, uv).rgb;
-                    return sampled;
-                }
-
-                fn mainImage(vUV: vec2<f32>) -> vec4<f32> {
-                    let sceneColor = textureSample(textureSampler, textureSamplerSampler, vUV);
-                    let a = sceneColor.rgb;
-                    if (uniforms.lutTileCountA <= 0.5 || uniforms.lutTileCountB <= 0.5) {
-                        return sceneColor;
-                    }
-                    let colA = sampleLUT(lutA, lutASampler, a, uniforms.lutTileCountA);
-                    let colB = sampleLUT(lutB, lutBSampler, a, uniforms.lutTileCountB);
-                    let outc = mix(colA, colB, uniforms.mixVal);
-                    return vec4<f32>(outc, sceneColor.a);
-                }
-            `;
-    }
-}

package/lib/perlin2d.d.ts

@@ -1,9 +0,0 @@
-export declare class Perlin2D {
-    private perm;
-    constructor(seed: number);
-    private fade;
-    private lerp;
-    private grad;
-    noise(x: number, y: number): number;
-}
-//# sourceMappingURL=perlin2d.d.ts.map

package/lib/perlin2d.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"perlin2d.d.ts","sourceRoot":"","sources":["../src/perlin2d.ts"],"names":[],"mappings":"AACA,qBAAa,QAAQ;IACf,OAAO,CAAC,IAAI,CAAW;gBACX,IAAI,EAAE,MAAM;IAsBxB,OAAO,CAAC,IAAI;IAGZ,OAAO,CAAC,IAAI;IAGZ,OAAO,CAAC,IAAI;IAUL,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;CAuB7C"}

package/lib/perlin2d.js

@@ -1,45 +0,0 @@
-export class Perlin2D {
-    constructor(seed) {
-        const p = new Array(256);
-        for (let i = 0; i < 256; i++)
-            p[i] = i;
-        let state = (seed | 0) >>> 0;
-        const nextRand = () => {
-            state = (state * 16807) % 2147483647;
-            return state / 2147483647;
-        };
-        for (let i = 255; i > 0; i--) {
-            const r = Math.floor(nextRand() * (i + 1));
-            const tmp = p[i];
-            p[i] = p[r];
-            p[r] = tmp;
-        }
-        this.perm = new Array(512);
-        for (let i = 0; i < 512; i++) {
-            this.perm[i] = p[i & 255];
-        }
-    }
-    fade(t) {
-        return t * t * t * (t * (t * 6 - 15) + 10);
-    }
-    lerp(a, b, t) {
-        return a + t * (b - a);
-    }
-    grad(hash, x, y) {
-        const h = hash & 7;
-        const u = h < 4 ? x : y;
-        const v = h < 4 ? y : x;
-        return ((h & 1) ? -u : u) + ((h & 2) ? -v : v);
-    }
-    noise(x, y) {
-        const X = Math.floor(x) & 255;
-        const Y = Math.floor(y) & 255;
-        const xf = x - Math.floor(x);
-        const yf = y - Math.floor(y);
-        const u = this.fade(xf);
-        const v = this.fade(yf);
-        const A = this.perm[X] + Y;
-        const B = this.perm[X + 1] + Y;
-        return this.lerp(this.lerp(this.grad(this.perm[A], xf, yf), this.grad(this.perm[B], xf - 1, yf), u), this.lerp(this.grad(this.perm[A + 1], xf, yf - 1), this.grad(this.perm[B + 1], xf - 1, yf - 1), u), v);
-    }
-}