@babylonjs-toolkit/next 9.25.1 → 9.28.0

package/lib/sgshadowdepth.d.ts

@@ -0,0 +1,19 @@
+import { Material } from '@babylonjs/core/Materials/material';
+import { SubMesh } from '@babylonjs/core/Meshes/subMesh';
+import { Scene } from '@babylonjs/core/scene';
+import { ShadowDepthWrapper } from '@babylonjs/core/Materials';
+import { Light } from '@babylonjs/core/Lights/light';
+export declare class SgShadowDepth {
+    static Enabled: boolean;
+    static Create(material: Material, scene: Scene): ShadowDepthWrapper;
+    static Token(options: string, baseKey: string): string;
+    static Hash(text: string): string;
+    static IsDefinesObject(defines: any): boolean;
+    static BaseDefines(wrapper: any, subMesh: SubMesh): any;
+    static ResolveHolderDefines(wrapper: any, subMesh: SubMesh, shadowGenerator: any): boolean;
+    static BaseDefinesStale(wrapper: any, subMesh: SubMesh): boolean;
+    static LightsMatch(defines: any, lights: Light[]): boolean;
+    static FilterDefines(defines: string): string;
+    static Share(wrapper: any, scene: Scene, options: string): void;
+}
+//# sourceMappingURL=sgshadowdepth.d.ts.map

package/lib/sgshadowdepth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sgshadowdepth.d.ts","sourceRoot":"","sources":["../src/sgshadowdepth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,kBAAkB,EAAkB,MAAM,2BAA2B,CAAC;AAC/E,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAWrD,qBAAa,aAAa;IAOlB,OAAc,OAAO,EAAE,OAAO,CAAS;WAGzB,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,kBAAkB;WAY5D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;WAK/C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;WAa1B,eAAe,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO;WAQtC,WAAW,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,GAAG,GAAG;WAqBhD,oBAAoB,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,GAAG,GAAG,OAAO;WAwBnF,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;WAezD,WAAW,CAAC,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO;WAenD,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;WAKtC,KAAK,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;CA6GzE"}

package/lib/sgshadowdepth.js

@@ -0,0 +1,214 @@
+import { ShadowDepthWrapper, ShaderLanguage } from '@babylonjs/core/Materials';
+export class SgShadowDepth {
+    static Create(material, scene) {
+        if (SgShadowDepth.Enabled !== true)
+            return null;
+        const wgsl = (material.shaderLanguage === ShaderLanguage.WGSL);
+        const options = { standalone: true };
+        if (wgsl)
+            options.remappedVariables = ["vNormalW", "vertexOutputs.vNormalW"];
+        const wrapper = new ShadowDepthWrapper(material, scene, options);
+        SgShadowDepth.Share(wrapper, scene, (wgsl ? "wgsl" : "glsl") + "|" + (options.remappedVariables || []).join(","));
+        material.onDisposeObservable.addOnce(() => { wrapper.dispose(); });
+        return wrapper;
+    }
+    static Token(options, baseKey) {
+        return "sgShadowDepth|" + options + "|" + SgShadowDepth.Hash(baseKey);
+    }
+    static Hash(text) {
+        let h1 = 0xdeadbeef, h2 = 0x41c6ce57;
+        for (let i = 0; i < text.length; i++) {
+            const c = text.charCodeAt(i);
+            h1 = Math.imul(h1 ^ c, 2654435761);
+            h2 = Math.imul(h2 ^ c, 1597334677);
+        }
+        h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+        h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+        return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36) + ":" + text.length.toString(36);
+    }
+    static IsDefinesObject(defines) {
+        return (defines != null && typeof defines === "object");
+    }
+    static BaseDefines(wrapper, subMesh) {
+        const entry = (wrapper._subMeshToEffect != null) ? wrapper._subMeshToEffect.get(subMesh) : null;
+        if (entry == null || entry[0] == null)
+            return null;
+        const created = wrapper.__sgCreatedDefines;
+        const record = (created != null) ? created.get(subMesh) : null;
+        if (record != null && record.effect === entry[0] && SgShadowDepth.IsDefinesObject(record.defines))
+            return record.defines;
+        const s = subMesh;
+        const own = (typeof s._getDrawWrapper === "function") ? s._getDrawWrapper(entry[1]) : null;
+        if (own != null && SgShadowDepth.IsDefinesObject(own.defines))
+            return own.defines;
+        const wrappers = s._drawWrappers || [];
+        for (let i = 0; i < wrappers.length; i++) {
+            const dw = wrappers[i];
+            if (dw != null && dw.effect === entry[0] && SgShadowDepth.IsDefinesObject(dw.defines))
+                return dw.defines;
+        }
+        return null;
+    }
+    static ResolveHolderDefines(wrapper, subMesh, shadowGenerator) {
+        const holders = wrapper._subMeshToDepthWrapper;
+        const holder = (holders != null && typeof holders.get === "function") ? holders.get(subMesh, shadowGenerator) : null;
+        if (holder == null || holder.mainDrawWrapper == null)
+            return true;
+        const main = holder.mainDrawWrapper;
+        let defines = main.defines;
+        if (!SgShadowDepth.IsDefinesObject(defines)) {
+            defines = SgShadowDepth.BaseDefines(wrapper, subMesh);
+            if (defines == null)
+                return false;
+            main.defines = defines;
+        }
+        const passes = holder.drawWrapper || [];
+        for (let i = 0; i < passes.length; i++) {
+            const dw = passes[i];
+            if (dw != null && !SgShadowDepth.IsDefinesObject(dw.defines))
+                dw.defines = defines;
+        }
+        return true;
+    }
+    static BaseDefinesStale(wrapper, subMesh) {
+        const defines = SgShadowDepth.BaseDefines(wrapper, subMesh);
+        if (defines == null)
+            return false;
+        if (defines.isDirty === true)
+            return true;
+        const mesh = (subMesh != null) ? subMesh.getRenderingMesh() : null;
+        return !SgShadowDepth.LightsMatch(defines, (mesh != null) ? mesh.lightSources : null);
+    }
+    static LightsMatch(defines, lights) {
+        if (defines == null)
+            return true;
+        const list = lights || [];
+        for (let i = 0; i < 32; i++) {
+            if (defines["LIGHT" + i] !== true)
+                break;
+            const light = list[i];
+            if (light == null)
+                return false;
+            const kind = (typeof light.getClassName === "function") ? light.getClassName() : "";
+            const flag = (kind === "DirectionalLight") ? "DIRLIGHT" : (kind === "HemisphericLight") ? "HEMILIGHT" : (kind === "PointLight") ? "POINTLIGHT" : (kind === "SpotLight") ? "SPOTLIGHT" : null;
+            if (flag != null && defines[flag + i] !== true)
+                return false;
+        }
+        return true;
+    }
+    static FilterDefines(defines) {
+        return defines.split("\n").filter((line) => !/^\s*#define\s+(PREPASS|SCENE_MRT_COUNT)/.test(line)).join("\n");
+    }
+    static Share(wrapper, scene, options) {
+        const created = new WeakMap();
+        wrapper.__sgCreatedDefines = created;
+        const observer = wrapper._onEffectCreatedObserver;
+        if (observer != null && typeof observer.callback === "function") {
+            const callback = observer.callback;
+            observer.callback = function (info) {
+                const result = callback.apply(this, arguments);
+                const subMesh = (info != null) ? info.subMesh : null;
+                if (subMesh != null && info.effect != null) {
+                    const defines = subMesh.materialDefines;
+                    if (SgShadowDepth.IsDefinesObject(defines))
+                        created.set(subMesh, { effect: info.effect, defines: defines });
+                }
+                return result;
+            };
+        }
+        const makeEffect = wrapper._makeEffect;
+        if (typeof makeEffect === "function") {
+            wrapper._makeEffect = function (subMesh, depthDefines, shadowGenerator) {
+                const entry = (this._subMeshToEffect != null) ? this._subMeshToEffect.get(subMesh) : null;
+                const base = (entry != null) ? entry[0] : null;
+                const engine = scene.getEngine();
+                const createEffect = engine.createEffect;
+                engine.createEffect = function (source, effectOptions) {
+                    if (effectOptions != null && typeof effectOptions.defines === "string")
+                        effectOptions.defines = SgShadowDepth.FilterDefines(effectOptions.defines) + "\n#define SG_SHADOWPASS";
+                    const baseMaterial = wrapper._baseMaterial;
+                    const processor = (baseMaterial != null && typeof baseMaterial.getGraphFinalCodeProcessor === "function") ? baseMaterial.getGraphFinalCodeProcessor() : null;
+                    if (effectOptions != null && processor != null && effectOptions.processFinalCode == null)
+                        effectOptions.processFinalCode = processor;
+                    const token = (base != null && typeof base._key === "string" && base._key.length > 0) ? SgShadowDepth.Token(options, base._key) : null;
+                    if (token != null && source != null && typeof source === "object" && (source.vertexSource != null || source.fragmentSource != null)) {
+                        source.vertexToken = token;
+                        source.fragmentToken = token;
+                    }
+                    return createEffect.apply(engine, arguments);
+                };
+                let effect = null;
+                try {
+                    effect = makeEffect.apply(this, arguments);
+                }
+                finally {
+                    engine.createEffect = createEffect;
+                }
+                if (effect != null && !SgShadowDepth.ResolveHolderDefines(this, subMesh, shadowGenerator))
+                    return null;
+                return effect;
+            };
+        }
+        const isReady = wrapper.isReadyForSubMesh;
+        if (typeof isReady === "function") {
+            wrapper.isReadyForSubMesh = function (subMesh, defines, shadowGenerator, useInstances, passId) {
+                const entry = (this._subMeshToEffect != null) ? this._subMeshToEffect.get(subMesh) : null;
+                if (entry != null && entry[0] != null && typeof entry[0].isReady === "function" && entry[0].isReady()) {
+                    if (SgShadowDepth.BaseDefinesStale(this, subMesh)) {
+                        const renderingMesh = (subMesh != null) ? subMesh.getRenderingMesh() : null;
+                        const meshInfo = (renderingMesh != null) ? renderingMesh._internalAbstractMeshDataInfo : null;
+                        if (meshInfo != null && meshInfo._isActive === true)
+                            return false;
+                        return isReady.apply(this, arguments);
+                    }
+                    const effect = this._makeEffect(subMesh, defines, shadowGenerator, passId);
+                    return (effect != null && effect.isReady());
+                }
+                const mesh = (subMesh != null) ? subMesh.getRenderingMesh() : null;
+                const info = (mesh != null) ? mesh._internalAbstractMeshDataInfo : null;
+                if (entry == null && info != null && info._isActive === true)
+                    return false;
+                return isReady.apply(this, arguments);
+            };
+        }
+        const retired = new Set();
+        if (typeof wrapper._deleteDepthWrapperEffect === "function") {
+            wrapper._deleteDepthWrapperEffect = function (subMesh) {
+                const map = (this._subMeshToDepthWrapper != null) ? this._subMeshToDepthWrapper.mm.get(subMesh) : null;
+                if (map == null)
+                    return;
+                map.forEach((holder) => {
+                    const effect = (holder != null && holder.mainDrawWrapper != null) ? holder.mainDrawWrapper.effect : null;
+                    if (effect == null)
+                        return;
+                    if (retired.has(effect))
+                        effect.dispose();
+                    else
+                        retired.add(effect);
+                });
+                this._subMeshToDepthWrapper.mm.delete(subMesh);
+            };
+        }
+        const dispose = wrapper.dispose;
+        let disposed = false;
+        wrapper.dispose = function () {
+            if (disposed)
+                return;
+            disposed = true;
+            dispose.apply(this, arguments);
+            if (this._subMeshToDepthWrapper != null) {
+                this._subMeshToDepthWrapper.mm.forEach((map) => map.forEach((holder) => {
+                    const effect = (holder != null && holder.mainDrawWrapper != null) ? holder.mainDrawWrapper.effect : null;
+                    if (effect != null && !retired.has(effect))
+                        retired.add(effect);
+                    else if (effect != null)
+                        effect.dispose();
+                }));
+                this._subMeshToDepthWrapper.mm.clear();
+            }
+            retired.forEach((effect) => effect.dispose());
+            retired.clear();
+        };
+    }
+}
+SgShadowDepth.Enabled = false;

package/lib/shadergraphfullscreen.d.ts

@@ -0,0 +1,18 @@
+import { Scene } from '@babylonjs/core/scene';
+import { Camera } from '@babylonjs/core/Cameras/camera';
+import { ShaderGraphPass } from './scenemanager';
+import { PostProcess } from '@babylonjs/core';
+export declare class ShaderGraphFullscreen {
+    static Create(scene: Scene, className: string, options?: {
+        camera?: Camera;
+        injection?: string;
+        order?: number;
+        block?: any;
+    }): {
+        pass: ShaderGraphPass;
+        postProcess: PostProcess;
+        enabled: boolean;
+        dispose(): void;
+    };
+}
+//# sourceMappingURL=shadergraphfullscreen.d.ts.map

package/lib/shadergraphfullscreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadergraphfullscreen.d.ts","sourceRoot":"","sources":["../src/shadergraphfullscreen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,qBAAa,qBAAqB;WACZ,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,GAAG,CAAA;KAAE,GAChI;QAAE,IAAI,EAAE,eAAe,CAAC;QAAC,WAAW,EAAE,WAAW,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,IAAI,IAAI,CAAA;KAAE;CAe7F"}

package/lib/shadergraphfullscreen.js

@@ -0,0 +1,22 @@
+import { ShaderGraphPass } from './scenemanager';
+export class ShaderGraphFullscreen {
+    static Create(scene, className, options) {
+        const opts = options || {};
+        const camera = opts.camera || scene.activeCamera;
+        const pp = ShaderGraphPass.CreatePostProcess(scene, camera, className, { injection: opts.injection || "afterPost", block: opts.block });
+        if (pp == null)
+            return null;
+        if (opts.injection === "beforePost") {
+            camera.detachPostProcess(pp);
+            camera.attachPostProcess(pp, 0);
+        }
+        const handle = {
+            pass: pp.__sgPass,
+            postProcess: pp,
+            get enabled() { return pp.enabled !== false; },
+            set enabled(value) { pp.enabled = value; },
+            dispose() { pp.dispose(camera); }
+        };
+        return handle;
+    }
+}

package/lib/shadergraphlighttable.d.ts

@@ -0,0 +1,7 @@
+import { CustomShaderMaterial } from './scenemanager';
+import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+export declare class ShaderGraphLightTable {
+    static readonly SLOTS: number;
+    static Bind(material: CustomShaderMaterial, mesh: AbstractMesh): void;
+}
+//# sourceMappingURL=shadergraphlighttable.d.ts.map

package/lib/shadergraphlighttable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadergraphlighttable.d.ts","sourceRoot":"","sources":["../src/shadergraphlighttable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAuB,MAAM,gBAAgB,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AASnE,qBAAa,qBAAqB;IAC1B,gBAAuB,KAAK,EAAE,MAAM,CAAK;WAG3B,IAAI,CAAC,QAAQ,EAAE,oBAAoB,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI;CA0D/E"}

package/lib/shadergraphlighttable.js

@@ -0,0 +1,74 @@
+import { LightingConversions } from './scenemanager';
+import { Vector4 } from '@babylonjs/core/Maths/math.vector';
+import { DirectionalLight } from '@babylonjs/core/Lights/directionalLight';
+import { SpotLight } from '@babylonjs/core/Lights/spotLight';
+import { PointLight } from '@babylonjs/core/Lights/pointLight';
+export class ShaderGraphLightTable {
+    static Bind(material, mesh) {
+        if (material == null)
+            return;
+        const scene = material.getScene();
+        let main = null;
+        if (scene != null) {
+            for (const light of scene.lights) {
+                if (light instanceof DirectionalLight && light.isEnabled()) {
+                    main = light;
+                    break;
+                }
+            }
+        }
+        const info = material.getGraphInfo != null ? material.getGraphInfo() : null;
+        const destinationPi = (info != null && info.pipeline === "hdrp") ? 1 : Math.PI;
+        const lights = (mesh != null) ? (mesh.lightSources || []) : [];
+        let count = 0;
+        for (let i = 0; i < lights.length && count < ShaderGraphLightTable.SLOTS; i++) {
+            const light = lights[i];
+            if (light == null || light === main || !light.isEnabled())
+                continue;
+            let type = -1;
+            if (light instanceof SpotLight)
+                type = 2;
+            else if (light instanceof PointLight)
+                type = 1;
+            else if (light instanceof DirectionalLight)
+                type = 0;
+            if (type < 0)
+                continue;
+            const slot = String(count);
+            if (type === 0) {
+                const d = (light.transformedDirection != null ? light.transformedDirection : light.direction).clone().normalize();
+                material.setVector4Value("g_sgLight" + slot + "A", new Vector4(-d.x, -d.y, -d.z, 0));
+            }
+            else {
+                const p = light.getAbsolutePosition();
+                material.setVector4Value("g_sgLight" + slot + "A", new Vector4(p.x, p.y, p.z, type));
+            }
+            const unity = LightingConversions.MainLightColor(light);
+            const diffuse = light.diffuse;
+            const peak = (diffuse != null) ? Math.max(diffuse.r, diffuse.g, diffuse.b) : 0;
+            const scale = (peak > 0) ? (Math.max(unity.r, unity.g, unity.b) / peak / destinationPi) : 0;
+            const linear = LightingConversions.UnityLinearLightColor(light);
+            const range = (typeof light.range === "number" && isFinite(light.range) && light.range > 0 && light.range < 1e30) ? light.range : 0;
+            material.setVector4Value("g_sgLight" + slot + "B", new Vector4(linear.r * scale, linear.g * scale, linear.b * scale, range > 0 ? 1 / (range * range) : 0));
+            if (type === 2) {
+                const s = (light.transformedDirection != null ? light.transformedDirection : light.direction).clone().normalize();
+                const cosOuter = Math.cos((light.angle != null ? light.angle : Math.PI / 2) / 2);
+                const inner = (typeof light.innerAngle === "number" && light.innerAngle > 0) ? Math.cos(light.innerAngle / 2) : cosOuter;
+                material.setVector4Value("g_sgLight" + slot + "C", new Vector4(-s.x, -s.y, -s.z, cosOuter));
+                material.setVector4Value("g_sgLight" + slot + "D", new Vector4(inner, 0, 0, 0));
+            }
+            else {
+                material.setVector4Value("g_sgLight" + slot + "C", new Vector4(0, 0, 0, -1));
+                material.setVector4Value("g_sgLight" + slot + "D", new Vector4(1, 0, 0, 0));
+            }
+            count++;
+        }
+        for (let i = count; i < ShaderGraphLightTable.SLOTS; i++) {
+            const slot = String(i);
+            material.setVector4Value("g_sgLight" + slot + "A", new Vector4(0, 0, 0, 0));
+            material.setVector4Value("g_sgLight" + slot + "B", new Vector4(0, 0, 0, 0));
+        }
+        material.setVector4Value("g_sgLightCount", new Vector4(count, 0, 0, 0));
+    }
+}
+ShaderGraphLightTable.SLOTS = 8;

package/lib/unityscrollbar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unityscrollbar.d.ts","sourceRoot":"","sources":["../src/unityscrollbar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAClF,OAAO,EAAE,SAAS,EAAE,MAAM,8CAA8C,CAAC;AAEzE,qBAAa,cAAe,SAAQ,SAAS;IACrC,OAAO,CAAC,UAAU,CAAyB;IAE3C,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED,IAAW,SAAS,CAAC,KAAK,EAAE,MAAM,EAGjC;IAED,SAAS,CAAC,iBAAiB,IAAI,MAAM;IAkBrB,SAAS,CAAC,mBAAmB,EAAE,GAAG;IAKlC,iBAAiB,CAAC,mBAAmB,EAAE,GAAG,EAAE,IAAI,EAAE,sBAAsB;CAM3F"}
+{"version":3,"file":"unityscrollbar.d.ts","sourceRoot":"","sources":["../src/unityscrollbar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAClF,OAAO,EAAE,SAAS,EAAE,MAAM,8CAA8C,CAAC;AAGzE,qBAAa,cAAe,SAAQ,SAAS;IACrC,OAAO,CAAC,UAAU,CAAyB;IAE3C,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED,IAAW,SAAS,CAAC,KAAK,EAAE,MAAM,EAGjC;IAED,SAAS,CAAC,iBAAiB,IAAI,MAAM;IAkBrB,SAAS,CAAC,mBAAmB,EAAE,GAAG;IAKlC,iBAAiB,CAAC,mBAAmB,EAAE,GAAG,EAAE,IAAI,EAAE,sBAAsB;CAM3F"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@babylonjs-toolkit/next",
-    "version": "9.25.1",
+    "version": "9.28.0",
     "description": "Babylon Toolkit Runtime Library (ES6)",
     "author": "MackeyK24 <mackeyk24@gmail.com>",
     "main": "lib/index.js",
@@ -160,23 +160,23 @@
         "lib/**/*"
     ],
     "devDependencies": {
-        "@babylonjs/core": "9.25.0",
-        "@babylonjs/gui": "9.25.0",
+        "@babylonjs/core": "9.28.0",
+        "@babylonjs/gui": "9.28.0",
         "@babylonjs/havok": "^1.3.14",
-        "@babylonjs/addons": "9.25.0",
-        "@babylonjs/loaders": "9.25.0",
-        "@babylonjs/materials": "9.25.0",
-        "@babylonjs/inspector": "9.25.0",
+        "@babylonjs/addons": "9.28.0",
+        "@babylonjs/loaders": "9.28.0",
+        "@babylonjs/materials": "9.28.0",
+        "@babylonjs/inspector": "9.28.0",
         "rimraf": "^6.0.1",
         "typescript": "^6.0.3"
     },
     "peerDependencies": {
-        "@babylonjs/core": "9.25.0",
-        "@babylonjs/gui": "9.25.0",
+        "@babylonjs/core": "9.28.0",
+        "@babylonjs/gui": "9.28.0",
         "@babylonjs/havok": "^1.3.14",
-        "@babylonjs/addons": "9.25.0",
-        "@babylonjs/loaders": "9.25.0",
-        "@babylonjs/materials": "9.25.0",
-        "@babylonjs/inspector": "9.25.0"
+        "@babylonjs/addons": "9.28.0",
+        "@babylonjs/loaders": "9.28.0",
+        "@babylonjs/materials": "9.28.0",
+        "@babylonjs/inspector": "9.28.0"
     }
 }

package/lib/iparticlesystemtransform.d.ts

@@ -1,9 +0,0 @@
-import { IParticleSystemVector3 } from './scenemanager';
-export interface IParticleSystemTransform {
-    name: string;
-    instanceId: number;
-    position: IParticleSystemVector3;
-    rotation: IParticleSystemVector3;
-    scale: IParticleSystemVector3;
-}
-//# sourceMappingURL=iparticlesystemtransform.d.ts.map

package/lib/iparticlesystemtransform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"iparticlesystemtransform.d.ts","sourceRoot":"","sources":["../src/iparticlesystemtransform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAExD,MAAM,WAAW,wBAAwB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,sBAAsB,CAAC;IACjC,QAAQ,EAAE,sBAAsB,CAAC;IACjC,KAAK,EAAE,sBAAsB,CAAC;CACjC"}

package/lib/iparticlesystemtransform.js

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

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);
-    }
-}