@babylonjs-toolkit/next 9.10.1

package/lib/lutblendplugin.js

@@ -0,0 +1,153 @@
+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/mousebuttonmode.d.ts

@@ -0,0 +1,6 @@
+export declare enum MouseButtonMode {
+    Pan = 0,
+    Look = 1,
+    Move = 2
+}
+//# sourceMappingURL=mousebuttonmode.d.ts.map

package/lib/mousebuttonmode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mousebuttonmode.d.ts","sourceRoot":"","sources":["../src/mousebuttonmode.ts"],"names":[],"mappings":"AAEA,oBAAY,eAAe;IACnB,GAAG,IAAI;IACP,IAAI,IAAI;IACR,IAAI,IAAI;CACX"}

package/lib/mousebuttonmode.js

@@ -0,0 +1,6 @@
+export var MouseButtonMode;
+(function (MouseButtonMode) {
+    MouseButtonMode[MouseButtonMode["Pan"] = 0] = "Pan";
+    MouseButtonMode[MouseButtonMode["Look"] = 1] = "Look";
+    MouseButtonMode[MouseButtonMode["Move"] = 2] = "Move";
+})(MouseButtonMode || (MouseButtonMode = {}));

package/lib/movementtype.d.ts

@@ -0,0 +1,5 @@
+export declare enum MovementType {
+    DirectVelocity = 0,
+    AppliedForces = 1
+}
+//# sourceMappingURL=movementtype.d.ts.map

package/lib/movementtype.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"movementtype.d.ts","sourceRoot":"","sources":["../src/movementtype.ts"],"names":[],"mappings":"AACA,oBAAY,YAAY;IAChB,cAAc,IAAI;IAClB,aAAa,IAAI;CACpB"}

package/lib/movementtype.js

@@ -0,0 +1,5 @@
+export var MovementType;
+(function (MovementType) {
+    MovementType[MovementType["DirectVelocity"] = 0] = "DirectVelocity";
+    MovementType[MovementType["AppliedForces"] = 1] = "AppliedForces";
+})(MovementType || (MovementType = {}));

package/lib/noisefunction2d.d.ts

@@ -0,0 +1,2 @@
+export type NoiseFunction2D = (x: number, y: number) => number;
+//# sourceMappingURL=noisefunction2d.d.ts.map

package/lib/noisefunction2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noisefunction2d.d.ts","sourceRoot":"","sources":["../src/noisefunction2d.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC"}

package/lib/noisefunction2d.js

@@ -0,0 +1 @@
+export {};

package/lib/noisefunction3d.d.ts

@@ -0,0 +1,2 @@
+export type NoiseFunction3D = (x: number, y: number, z: number) => number;
+//# sourceMappingURL=noisefunction3d.d.ts.map

package/lib/noisefunction3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noisefunction3d.d.ts","sourceRoot":"","sources":["../src/noisefunction3d.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC"}

package/lib/noisefunction3d.js

@@ -0,0 +1 @@
+export {};

package/lib/noisefunction4d.d.ts

@@ -0,0 +1,2 @@
+export type NoiseFunction4D = (x: number, y: number, z: number, w: number) => number;
+//# sourceMappingURL=noisefunction4d.d.ts.map

package/lib/noisefunction4d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noisefunction4d.d.ts","sourceRoot":"","sources":["../src/noisefunction4d.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC"}

package/lib/noisefunction4d.js

@@ -0,0 +1 @@
+export {};

package/lib/perlin2d.d.ts

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

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

@@ -0,0 +1,45 @@
+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);
+    }
+}

package/lib/playercontrol.d.ts

@@ -0,0 +1,5 @@
+export declare enum PlayerControl {
+    FirstPerson = 0,
+    ThirdPerson = 1
+}
+//# sourceMappingURL=playercontrol.d.ts.map

package/lib/playercontrol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playercontrol.d.ts","sourceRoot":"","sources":["../src/playercontrol.ts"],"names":[],"mappings":"AACA,oBAAY,aAAa;IACjB,WAAW,IAAI;IACf,WAAW,IAAI;CAClB"}

package/lib/playercontrol.js

@@ -0,0 +1,5 @@
+export var PlayerControl;
+(function (PlayerControl) {
+    PlayerControl[PlayerControl["FirstPerson"] = 0] = "FirstPerson";
+    PlayerControl[PlayerControl["ThirdPerson"] = 1] = "ThirdPerson";
+})(PlayerControl || (PlayerControl = {}));

package/lib/prefabobjectpool.d.ts

@@ -0,0 +1,20 @@
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { AssetContainer } from '@babylonjs/core/assetContainer';
+import { Vector3, Quaternion } from '@babylonjs/core/Maths/math.vector';
+import { Scene } from '@babylonjs/core/scene';
+export declare class PrefabObjectPool {
+    private prefabName;
+    private allowGrowth;
+    private assetContainer;
+    private cloneAnimations;
+    private makeNewMaterials;
+    private availableInstances;
+    getAvailableCount(): number;
+    constructor(container: AssetContainer | Scene, prefabName: string, prefabCount?: number, allowGrowth?: boolean, makeNewMaterials?: boolean, cloneAnimations?: boolean);
+    populatePool(count: number): void;
+    getInstance(position?: Vector3, rotation?: Quaternion): TransformNode;
+    freeInstance(instance: TransformNode): void;
+    private appendNewInstance;
+    private createNewInstance;
+}
+//# sourceMappingURL=prefabobjectpool.d.ts.map

package/lib/prefabobjectpool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefabobjectpool.d.ts","sourceRoot":"","sources":["../src/prefabobjectpool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAErE,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAExE,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE9C,qBAAa,gBAAgB;IACrB,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,WAAW,CAAiB;IACpC,OAAO,CAAC,cAAc,CAAgC;IACtD,OAAO,CAAC,eAAe,CAAiB;IACxC,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,kBAAkB,CAAyB;IAC5C,iBAAiB,IAAI,MAAM;gBACf,SAAS,EAAE,cAAc,GAAG,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAE,MAAU,EAAE,WAAW,GAAE,OAAc,EAAE,gBAAgB,GAAE,OAAe,EAAE,eAAe,GAAE,OAAc;IAU3L,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IASjC,WAAW,CAAC,QAAQ,GAAE,OAAc,EAAE,QAAQ,GAAE,UAAiB,GAAG,aAAa;IAkBjF,YAAY,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAoBlD,OAAO,CAAC,iBAAiB;IAOzB,OAAO,CAAC,iBAAiB;CAW5B"}

package/lib/prefabobjectpool.js

@@ -0,0 +1,96 @@
+import { SceneManager } from './scenemanager';
+import { AssetContainer } from '@babylonjs/core/assetContainer';
+import { Quaternion } from '@babylonjs/core/Maths/math.vector';
+import { Scene } from '@babylonjs/core/scene';
+export class PrefabObjectPool {
+    getAvailableCount() { return this.availableInstances.length; }
+    constructor(container, prefabName, prefabCount = 1, allowGrowth = true, makeNewMaterials = false, cloneAnimations = true) {
+        this.prefabName = null;
+        this.allowGrowth = true;
+        this.assetContainer = null;
+        this.cloneAnimations = true;
+        this.makeNewMaterials = false;
+        this.availableInstances = null;
+        this.prefabName = prefabName;
+        this.allowGrowth = allowGrowth;
+        this.assetContainer = container;
+        this.cloneAnimations = cloneAnimations;
+        this.makeNewMaterials = makeNewMaterials;
+        this.availableInstances = [];
+        this.populatePool(prefabCount);
+    }
+    populatePool(count) {
+        if (count > 0) {
+            for (let i = 0; i < count; i++) {
+                const instance = this.createNewInstance();
+                if (instance != null)
+                    this.freeInstance(instance);
+            }
+        }
+    }
+    getInstance(position = null, rotation = null) {
+        const instance = (this.availableInstances.length > 0) ? this.availableInstances.pop() : this.appendNewInstance();
+        if (instance != null) {
+            if (position != null)
+                instance.position.copyFrom(position);
+            else
+                instance.position.set(0, 0, 0);
+            if (rotation != null) {
+                if (instance.rotationQuaternion != null)
+                    instance.rotationQuaternion.copyFrom(rotation);
+                else
+                    instance.rotationQuaternion = rotation.clone();
+            }
+            else {
+                if (instance.rotationQuaternion != null)
+                    instance.rotationQuaternion.set(0, 0, 0, 1);
+                else
+                    instance.rotationQuaternion = new Quaternion(0, 0, 0, 1);
+            }
+            instance.name = (this.prefabName + ".Instance");
+            instance.setEnabled(true);
+        }
+        return instance;
+    }
+    freeInstance(instance) {
+        if (instance != null) {
+            instance.setEnabled(false);
+            instance.position.set(0, 0, 0);
+            if (instance.rotationQuaternion != null)
+                instance.rotationQuaternion.set(0, 0, 0, 1);
+            else
+                instance.rotationQuaternion = new Quaternion(0, 0, 0, 1);
+            if (instance.metadata != null && instance.metadata.toolkit != null && instance.metadata.toolkit.components != null) {
+                instance.metadata.toolkit.components.forEach((script) => {
+                    if (script != null) {
+                        try {
+                            script.resetScriptComponent();
+                        }
+                        catch (e) { }
+                    }
+                });
+            }
+            instance.name = (this.prefabName + ".Unassigned");
+            this.availableInstances.push(instance);
+        }
+    }
+    appendNewInstance() {
+        let result = null;
+        if (this.allowGrowth === true) {
+            result = this.createNewInstance();
+        }
+        return result;
+    }
+    createNewInstance(newParent = null, newPosition = null, newRotation = null, newScaling = null) {
+        let result = null;
+        if (this.assetContainer != null && this.prefabName != null && this.prefabName !== "") {
+            if (this.assetContainer instanceof AssetContainer) {
+                result = SceneManager.InstantiatePrefabFromContainer(this.assetContainer, this.prefabName, (this.prefabName + ".Instance"), newParent, newPosition, newRotation, newScaling, this.cloneAnimations, this.makeNewMaterials);
+            }
+            else if (this.assetContainer instanceof Scene) {
+                result = SceneManager.InstantiatePrefabFromScene(this.assetContainer, this.prefabName, (this.prefabName + ".Instance"), newParent, newPosition, newRotation, newScaling, this.cloneAnimations);
+            }
+        }
+        return result;
+    }
+}