@babylonjs/core 8.11.0 → 8.12.0

package/Particles/Node/Blocks/particleGradientBlock.js

@@ -0,0 +1,118 @@
+import { RegisterClass } from "../../../Misc/typeStore.js";
+import { NodeParticleBlock } from "../nodeParticleBlock.js";
+import { NodeParticleBlockConnectionPointTypes } from "../Enums/nodeParticleBlockConnectionPointTypes.js";
+import { Lerp } from "../../../Maths/math.scalar.functions.js";
+import { Color4 } from "../../../Maths/math.color.js";
+import { Vector2, Vector3 } from "../../../Maths/math.vector.js";
+/**
+ * Block used to define a list of gradient entries
+ */
+export class ParticleGradientBlock extends NodeParticleBlock {
+    /**
+     * Creates a new ParticleGradientBlock
+     * @param name defines the block name
+     */
+    constructor(name) {
+        super(name);
+        this._entryCount = 1;
+        this.registerInput("gradient", NodeParticleBlockConnectionPointTypes.Float, true, 1, 0, 1);
+        this.registerInput("value0", NodeParticleBlockConnectionPointTypes.AutoDetect);
+        this.registerOutput("output", NodeParticleBlockConnectionPointTypes.BasedOnInput);
+        this._outputs[0]._typeConnectionSource = this._inputs[1];
+        this._outputs[0]._typeConnectionSourceTranslation = (type) => {
+            switch (type) {
+                case NodeParticleBlockConnectionPointTypes.FloatGradient:
+                    return NodeParticleBlockConnectionPointTypes.Float;
+                case NodeParticleBlockConnectionPointTypes.Vector2Gradient:
+                    return NodeParticleBlockConnectionPointTypes.Vector2;
+                case NodeParticleBlockConnectionPointTypes.Vector3Gradient:
+                    return NodeParticleBlockConnectionPointTypes.Vector3;
+                case NodeParticleBlockConnectionPointTypes.Color4Gradient:
+                    return NodeParticleBlockConnectionPointTypes.Color4;
+            }
+            return type;
+        };
+        this._inputs[1].addExcludedConnectionPointFromAllowedTypes(NodeParticleBlockConnectionPointTypes.FloatGradient |
+            NodeParticleBlockConnectionPointTypes.Vector2Gradient |
+            NodeParticleBlockConnectionPointTypes.Vector3Gradient |
+            NodeParticleBlockConnectionPointTypes.Color4Gradient);
+        this._manageExtendedInputs(1);
+    }
+    _manageExtendedInputs(index) {
+        this._inputs[index].onConnectionObservable.add(() => {
+            if (this._entryCount > index) {
+                return;
+            }
+            this._entryCount++;
+            this.registerInput("value" + (this._entryCount - 1), NodeParticleBlockConnectionPointTypes.AutoDetect, true);
+            this._linkConnectionTypes(1, this._entryCount);
+            this._manageExtendedInputs(this._entryCount);
+        });
+    }
+    /**
+     * Gets the current class name
+     * @returns the class name
+     */
+    getClassName() {
+        return "ParticleGradientBlock";
+    }
+    /**
+     * Gets the gradient operand input component
+     */
+    get gradient() {
+        return this._inputs[0];
+    }
+    /**
+     * Gets the output component
+     */
+    get output() {
+        return this._outputs[0];
+    }
+    _build() {
+        // Building the list of entries in order
+        const entries = [];
+        for (let i = 1; i < this._inputs.length; i++) {
+            if (this._inputs[i].isConnected) {
+                entries.push(this._inputs[i].connectedPoint?.ownerBlock);
+            }
+        }
+        entries.sort((a, b) => {
+            return a.reference - b.reference;
+        });
+        this.output._storedFunction = (state) => {
+            const gradient = this.gradient.getConnectedValue(state);
+            if (entries.length === 1) {
+                return entries[0].value.getConnectedValue(state);
+            }
+            // Go down the entries list in reverse order
+            let nextEntry = null;
+            for (let i = entries.length - 1; i >= 0; i--) {
+                const entry = entries[i];
+                if (entry.reference <= gradient) {
+                    const currentValue = entry.value.getConnectedValue(state);
+                    if (nextEntry) {
+                        const nextValue = nextEntry.value.getConnectedValue(state);
+                        const nextReference = nextEntry.reference;
+                        const currentReference = entry.reference;
+                        const scale = Math.max(0, Math.min(1, (gradient - currentReference) / (nextReference - currentReference)));
+                        switch (this.output.type) {
+                            case NodeParticleBlockConnectionPointTypes.Float:
+                                return Lerp(currentValue, nextValue, scale);
+                            case NodeParticleBlockConnectionPointTypes.Vector2:
+                                return Vector2.Lerp(currentValue, nextValue, scale);
+                            case NodeParticleBlockConnectionPointTypes.Vector3:
+                                return Vector3.Lerp(currentValue, nextValue, scale);
+                            case NodeParticleBlockConnectionPointTypes.Color4:
+                                return Color4.Lerp(currentValue, nextValue, scale);
+                        }
+                    }
+                    return currentValue;
+                }
+                nextEntry = entry;
+            }
+            return 0;
+        };
+    }
+}
+RegisterClass("BABYLON.ParticleGradientBlock", ParticleGradientBlock);
+//# sourceMappingURL=particleGradientBlock.js.map

package/Particles/Node/Blocks/particleGradientBlock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"particleGradientBlock.js","sourceRoot":"","sources":["../../../../../../dev/core/src/Particles/Node/Blocks/particleGradientBlock.ts"],"names":[],"mappings":"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","sourcesContent":["import { RegisterClass } from \"../../../Misc/typeStore\";\r\nimport { NodeParticleBlock } from \"../nodeParticleBlock\";\r\nimport { NodeParticleBlockConnectionPointTypes } from \"../Enums/nodeParticleBlockConnectionPointTypes\";\r\nimport type { NodeParticleConnectionPoint } from \"../nodeParticleBlockConnectionPoint\";\r\nimport type { ParticleGradientValueBlock } from \"./particleGradientValueBlock\";\r\nimport type { Nullable } from \"core/types\";\r\nimport { Lerp } from \"core/Maths/math.scalar.functions\";\r\nimport { Color4 } from \"core/Maths/math.color\";\r\nimport { Vector2, Vector3 } from \"core/Maths/math.vector\";\r\n/**\r\n * Block used to define a list of gradient entries\r\n */\r\nexport class ParticleGradientBlock extends NodeParticleBlock {\r\n    private _entryCount = 1;\r\n    /**\r\n     * Creates a new ParticleGradientBlock\r\n     * @param name defines the block name\r\n     */\r\n    public constructor(name: string) {\r\n        super(name);\r\n\r\n        this.registerInput(\"gradient\", NodeParticleBlockConnectionPointTypes.Float, true, 1, 0, 1);\r\n        this.registerInput(\"value0\", NodeParticleBlockConnectionPointTypes.AutoDetect);\r\n        this.registerOutput(\"output\", NodeParticleBlockConnectionPointTypes.BasedOnInput);\r\n\r\n        this._outputs[0]._typeConnectionSource = this._inputs[1];\r\n        this._outputs[0]._typeConnectionSourceTranslation = (type) => {\r\n            switch (type) {\r\n                case NodeParticleBlockConnectionPointTypes.FloatGradient:\r\n                    return NodeParticleBlockConnectionPointTypes.Float;\r\n                case NodeParticleBlockConnectionPointTypes.Vector2Gradient:\r\n                    return NodeParticleBlockConnectionPointTypes.Vector2;\r\n                case NodeParticleBlockConnectionPointTypes.Vector3Gradient:\r\n                    return NodeParticleBlockConnectionPointTypes.Vector3;\r\n                case NodeParticleBlockConnectionPointTypes.Color4Gradient:\r\n                    return NodeParticleBlockConnectionPointTypes.Color4;\r\n            }\r\n            return type;\r\n        };\r\n\r\n        this._inputs[1].addExcludedConnectionPointFromAllowedTypes(\r\n            NodeParticleBlockConnectionPointTypes.FloatGradient |\r\n                NodeParticleBlockConnectionPointTypes.Vector2Gradient |\r\n                NodeParticleBlockConnectionPointTypes.Vector3Gradient |\r\n                NodeParticleBlockConnectionPointTypes.Color4Gradient\r\n        );\r\n\r\n        this._manageExtendedInputs(1);\r\n    }\r\n\r\n    private _manageExtendedInputs(index: number) {\r\n        this._inputs[index].onConnectionObservable.add(() => {\r\n            if (this._entryCount > index) {\r\n                return;\r\n            }\r\n            this._entryCount++;\r\n            this.registerInput(\"value\" + (this._entryCount - 1), NodeParticleBlockConnectionPointTypes.AutoDetect, true);\r\n            this._linkConnectionTypes(1, this._entryCount);\r\n\r\n            this._manageExtendedInputs(this._entryCount);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Gets the current class name\r\n     * @returns the class name\r\n     */\r\n    public override getClassName() {\r\n        return \"ParticleGradientBlock\";\r\n    }\r\n\r\n    /**\r\n     * Gets the gradient operand input component\r\n     */\r\n    public get gradient(): NodeParticleConnectionPoint {\r\n        return this._inputs[0];\r\n    }\r\n\r\n    /**\r\n     * Gets the output component\r\n     */\r\n    public get output(): NodeParticleConnectionPoint {\r\n        return this._outputs[0];\r\n    }\r\n\r\n    public override _build() {\r\n        // Building the list of entries in order\r\n        const entries: ParticleGradientValueBlock[] = [];\r\n        for (let i = 1; i < this._inputs.length; i++) {\r\n            if (this._inputs[i].isConnected) {\r\n                entries.push(this._inputs[i].connectedPoint?.ownerBlock as ParticleGradientValueBlock);\r\n            }\r\n        }\r\n\r\n        entries.sort((a, b) => {\r\n            return a.reference - b.reference;\r\n        });\r\n\r\n        this.output._storedFunction = (state) => {\r\n            const gradient = this.gradient.getConnectedValue(state);\r\n\r\n            if (entries.length === 1) {\r\n                return entries[0].value.getConnectedValue(state);\r\n            }\r\n\r\n            // Go down the entries list in reverse order\r\n            let nextEntry: Nullable<ParticleGradientValueBlock> = null;\r\n            for (let i = entries.length - 1; i >= 0; i--) {\r\n                const entry = entries[i];\r\n                if (entry.reference <= gradient) {\r\n                    const currentValue = entry.value.getConnectedValue(state);\r\n                    if (nextEntry) {\r\n                        const nextValue = nextEntry.value.getConnectedValue(state);\r\n                        const nextReference = nextEntry.reference;\r\n                        const currentReference = entry.reference;\r\n                        const scale = Math.max(0, Math.min(1, (gradient - currentReference) / (nextReference - currentReference)));\r\n\r\n                        switch (this.output.type) {\r\n                            case NodeParticleBlockConnectionPointTypes.Float:\r\n                                return Lerp(currentValue, nextValue, scale);\r\n                            case NodeParticleBlockConnectionPointTypes.Vector2:\r\n                                return Vector2.Lerp(currentValue, nextValue, scale);\r\n                            case NodeParticleBlockConnectionPointTypes.Vector3:\r\n                                return Vector3.Lerp(currentValue, nextValue, scale);\r\n                            case NodeParticleBlockConnectionPointTypes.Color4:\r\n                                return Color4.Lerp(currentValue, nextValue, scale);\r\n                        }\r\n                    }\r\n                    return currentValue;\r\n                }\r\n\r\n                nextEntry = entry;\r\n            }\r\n\r\n            return 0;\r\n        };\r\n    }\r\n}\r\n\r\nRegisterClass(\"BABYLON.ParticleGradientBlock\", ParticleGradientBlock);\r\n"]}

package/Particles/Node/Blocks/particleGradientValueBlock.d.ts

@@ -0,0 +1,32 @@
+import { NodeParticleBlock } from "../nodeParticleBlock.js";
+import type { NodeParticleConnectionPoint } from "../nodeParticleBlockConnectionPoint.js";
+/**
+ * Block used to define a gradient entry for a gradient block
+ */
+export declare class ParticleGradientValueBlock extends NodeParticleBlock {
+    /**
+     * Gets or sets the epsilon value used for comparison
+     */
+    reference: number;
+    /**
+     * Creates a new ParticleGradientEntryBlock
+     * @param name defines the block name
+     */
+    constructor(name: string);
+    /**
+     * Gets the current class name
+     * @returns the class name
+     */
+    getClassName(): string;
+    /**
+     * Gets the value operand input component
+     */
+    get value(): NodeParticleConnectionPoint;
+    /**
+     * Gets the output component
+     */
+    get output(): NodeParticleConnectionPoint;
+    _build(): void;
+    serialize(): any;
+    _deserialize(serializationObject: any): void;
+}

package/Particles/Node/Blocks/particleGradientValueBlock.js

@@ -0,0 +1,79 @@
+import { __decorate } from "../../../tslib.es6.js";
+import { RegisterClass } from "../../../Misc/typeStore.js";
+import { NodeParticleBlock } from "../nodeParticleBlock.js";
+import { NodeParticleBlockConnectionPointTypes } from "../Enums/nodeParticleBlockConnectionPointTypes.js";
+import { editableInPropertyPage } from "../../../Decorators/nodeDecorator.js";
+/**
+ * Block used to define a gradient entry for a gradient block
+ */
+export class ParticleGradientValueBlock extends NodeParticleBlock {
+    /**
+     * Creates a new ParticleGradientEntryBlock
+     * @param name defines the block name
+     */
+    constructor(name) {
+        super(name);
+        /**
+         * Gets or sets the epsilon value used for comparison
+         */
+        this.reference = 0;
+        this.registerInput("value", NodeParticleBlockConnectionPointTypes.AutoDetect);
+        this.registerOutput("output", NodeParticleBlockConnectionPointTypes.BasedOnInput);
+        this._outputs[0]._typeConnectionSource = this._inputs[0];
+        this._outputs[0]._typeConnectionSourceTranslation = (type) => {
+            switch (type) {
+                case NodeParticleBlockConnectionPointTypes.Float:
+                    return NodeParticleBlockConnectionPointTypes.FloatGradient;
+                case NodeParticleBlockConnectionPointTypes.Vector2:
+                    return NodeParticleBlockConnectionPointTypes.Vector2Gradient;
+                case NodeParticleBlockConnectionPointTypes.Vector3:
+                    return NodeParticleBlockConnectionPointTypes.Vector3Gradient;
+                case NodeParticleBlockConnectionPointTypes.Color4:
+                    return NodeParticleBlockConnectionPointTypes.Color4Gradient;
+            }
+            return type;
+        };
+        this._inputs[0].addExcludedConnectionPointFromAllowedTypes(NodeParticleBlockConnectionPointTypes.Float |
+            NodeParticleBlockConnectionPointTypes.Vector2 |
+            NodeParticleBlockConnectionPointTypes.Vector3 |
+            NodeParticleBlockConnectionPointTypes.Color4);
+    }
+    /**
+     * Gets the current class name
+     * @returns the class name
+     */
+    getClassName() {
+        return "ParticleGradientValueBlock";
+    }
+    /**
+     * Gets the value operand input component
+     */
+    get value() {
+        return this._inputs[0];
+    }
+    /**
+     * Gets the output component
+     */
+    get output() {
+        return this._outputs[0];
+    }
+    _build() {
+        this.output._storedFunction = (state) => {
+            return null;
+        };
+    }
+    serialize() {
+        const serializationObject = super.serialize();
+        serializationObject.reference = this.reference;
+        return serializationObject;
+    }
+    _deserialize(serializationObject) {
+        super._deserialize(serializationObject);
+        this.reference = serializationObject.reference;
+    }
+}
+__decorate([
+    editableInPropertyPage("Reference", 1 /* PropertyTypeForEdition.Float */, "ADVANCED", { embedded: true, notifiers: { rebuild: true }, min: 0, max: 1 })
+], ParticleGradientValueBlock.prototype, "reference", void 0);
+RegisterClass("BABYLON.ParticleGradientValueBlock", ParticleGradientValueBlock);
+//# sourceMappingURL=particleGradientValueBlock.js.map

package/Particles/Node/Blocks/particleGradientValueBlock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"particleGradientValueBlock.js","sourceRoot":"","sources":["../../../../../../dev/core/src/Particles/Node/Blocks/particleGradientValueBlock.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,qCAAqC,EAAE,MAAM,gDAAgD,CAAC;AAEvG,OAAO,EAAE,sBAAsB,EAA0B,6CAAsC;AAC/F;;GAEG;AACH,MAAM,OAAO,0BAA2B,SAAQ,iBAAiB;IAO7D;;;OAGG;IACH,YAAmB,IAAY;QAC3B,KAAK,CAAC,IAAI,CAAC,CAAC;QAXhB;;WAEG;QAEI,cAAS,GAAG,CAAC,CAAC;QASjB,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,qCAAqC,CAAC,UAAU,CAAC,CAAC;QAC9E,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,qCAAqC,CAAC,YAAY,CAAC,CAAC;QAElF,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,qBAAqB,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,gCAAgC,GAAG,CAAC,IAAI,EAAE,EAAE;YACzD,QAAQ,IAAI,EAAE,CAAC;gBACX,KAAK,qCAAqC,CAAC,KAAK;oBAC5C,OAAO,qCAAqC,CAAC,aAAa,CAAC;gBAC/D,KAAK,qCAAqC,CAAC,OAAO;oBAC9C,OAAO,qCAAqC,CAAC,eAAe,CAAC;gBACjE,KAAK,qCAAqC,CAAC,OAAO;oBAC9C,OAAO,qCAAqC,CAAC,eAAe,CAAC;gBACjE,KAAK,qCAAqC,CAAC,MAAM;oBAC7C,OAAO,qCAAqC,CAAC,cAAc,CAAC;YACpE,CAAC;YACD,OAAO,IAAI,CAAC;QAChB,CAAC,CAAC;QAEF,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,0CAA0C,CACtD,qCAAqC,CAAC,KAAK;YACvC,qCAAqC,CAAC,OAAO;YAC7C,qCAAqC,CAAC,OAAO;YAC7C,qCAAqC,CAAC,MAAM,CACnD,CAAC;IACN,CAAC;IAED;;;OAGG;IACa,YAAY;QACxB,OAAO,4BAA4B,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,IAAW,KAAK;QACZ,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,IAAW,MAAM;QACb,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC5B,CAAC;IAEe,MAAM;QAClB,IAAI,CAAC,MAAM,CAAC,eAAe,GAAG,CAAC,KAAK,EAAE,EAAE;YACpC,OAAO,IAAI,CAAC;QAChB,CAAC,CAAC;IACN,CAAC;IAEe,SAAS;QACrB,MAAM,mBAAmB,GAAG,KAAK,CAAC,SAAS,EAAE,CAAC;QAE9C,mBAAmB,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAE/C,OAAO,mBAAmB,CAAC;IAC/B,CAAC;IAEe,YAAY,CAAC,mBAAwB;QACjD,KAAK,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC;QAExC,IAAI,CAAC,SAAS,GAAG,mBAAmB,CAAC,SAAS,CAAC;IACnD,CAAC;CACJ;AA5EU;IADN,sBAAsB,CAAC,WAAW,wCAAgC,UAAU,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;6DAC3H;AA8EzB,aAAa,CAAC,oCAAoC,EAAE,0BAA0B,CAAC,CAAC","sourcesContent":["import { RegisterClass } from \"../../../Misc/typeStore\";\r\nimport { NodeParticleBlock } from \"../nodeParticleBlock\";\r\nimport { NodeParticleBlockConnectionPointTypes } from \"../Enums/nodeParticleBlockConnectionPointTypes\";\r\nimport type { NodeParticleConnectionPoint } from \"../nodeParticleBlockConnectionPoint\";\r\nimport { editableInPropertyPage, PropertyTypeForEdition } from \"core/Decorators/nodeDecorator\";\r\n/**\r\n * Block used to define a gradient entry for a gradient block\r\n */\r\nexport class ParticleGradientValueBlock extends NodeParticleBlock {\r\n    /**\r\n     * Gets or sets the epsilon value used for comparison\r\n     */\r\n    @editableInPropertyPage(\"Reference\", PropertyTypeForEdition.Float, \"ADVANCED\", { embedded: true, notifiers: { rebuild: true }, min: 0, max: 1 })\r\n    public reference = 0;\r\n\r\n    /**\r\n     * Creates a new ParticleGradientEntryBlock\r\n     * @param name defines the block name\r\n     */\r\n    public constructor(name: string) {\r\n        super(name);\r\n\r\n        this.registerInput(\"value\", NodeParticleBlockConnectionPointTypes.AutoDetect);\r\n        this.registerOutput(\"output\", NodeParticleBlockConnectionPointTypes.BasedOnInput);\r\n\r\n        this._outputs[0]._typeConnectionSource = this._inputs[0];\r\n        this._outputs[0]._typeConnectionSourceTranslation = (type) => {\r\n            switch (type) {\r\n                case NodeParticleBlockConnectionPointTypes.Float:\r\n                    return NodeParticleBlockConnectionPointTypes.FloatGradient;\r\n                case NodeParticleBlockConnectionPointTypes.Vector2:\r\n                    return NodeParticleBlockConnectionPointTypes.Vector2Gradient;\r\n                case NodeParticleBlockConnectionPointTypes.Vector3:\r\n                    return NodeParticleBlockConnectionPointTypes.Vector3Gradient;\r\n                case NodeParticleBlockConnectionPointTypes.Color4:\r\n                    return NodeParticleBlockConnectionPointTypes.Color4Gradient;\r\n            }\r\n            return type;\r\n        };\r\n\r\n        this._inputs[0].addExcludedConnectionPointFromAllowedTypes(\r\n            NodeParticleBlockConnectionPointTypes.Float |\r\n                NodeParticleBlockConnectionPointTypes.Vector2 |\r\n                NodeParticleBlockConnectionPointTypes.Vector3 |\r\n                NodeParticleBlockConnectionPointTypes.Color4\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Gets the current class name\r\n     * @returns the class name\r\n     */\r\n    public override getClassName() {\r\n        return \"ParticleGradientValueBlock\";\r\n    }\r\n\r\n    /**\r\n     * Gets the value operand input component\r\n     */\r\n    public get value(): NodeParticleConnectionPoint {\r\n        return this._inputs[0];\r\n    }\r\n\r\n    /**\r\n     * Gets the output component\r\n     */\r\n    public get output(): NodeParticleConnectionPoint {\r\n        return this._outputs[0];\r\n    }\r\n\r\n    public override _build() {\r\n        this.output._storedFunction = (state) => {\r\n            return null;\r\n        };\r\n    }\r\n\r\n    public override serialize(): any {\r\n        const serializationObject = super.serialize();\r\n\r\n        serializationObject.reference = this.reference;\r\n\r\n        return serializationObject;\r\n    }\r\n\r\n    public override _deserialize(serializationObject: any) {\r\n        super._deserialize(serializationObject);\r\n\r\n        this.reference = serializationObject.reference;\r\n    }\r\n}\r\n\r\nRegisterClass(\"BABYLON.ParticleGradientValueBlock\", ParticleGradientValueBlock);\r\n"]}

package/Particles/Node/Blocks/particleInputBlock.d.ts

@@ -0,0 +1,87 @@
+import { Observable } from "../../../Misc/observable.js";
+import { NodeParticleBlock } from "../nodeParticleBlock.js";
+import { NodeParticleBlockConnectionPointTypes } from "../Enums/nodeParticleBlockConnectionPointTypes.js";
+import type { NodeParticleConnectionPoint } from "../nodeParticleBlockConnectionPoint.js";
+import type { NodeParticleBuildState } from "../nodeParticleBuildState.js";
+import { NodeParticleContextualSources } from "../Enums/nodeParticleContextualSources.js";
+import { NodeParticleSystemSources } from "../Enums/nodeParticleSystemSources.js";
+/**
+ * Block used to expose an input value
+ */
+export declare class ParticleInputBlock extends NodeParticleBlock {
+    private _storedValue;
+    private _valueCallback;
+    private _type;
+    /** Gets or set a value used to limit the range of float values */
+    min: number;
+    /** Gets or set a value used to limit the range of float values */
+    max: number;
+    /** Gets or sets the group to use to display this block in the Inspector */
+    groupInInspector: string;
+    /**
+     * Gets or sets a boolean indicating that this input is displayed in the Inspector
+     */
+    displayInInspector: boolean;
+    /** Gets an observable raised when the value is changed */
+    onValueChangedObservable: Observable<ParticleInputBlock>;
+    /**
+     * Gets or sets the connection point type (default is float)
+     */
+    get type(): NodeParticleBlockConnectionPointTypes;
+    /** @internal */
+    private _systemSource;
+    /**
+     * Gets a boolean indicating that the current connection point is a system source
+     */
+    get isSystemSource(): boolean;
+    /**
+     * Gets or sets the system source used by this input block
+     */
+    get systemSource(): NodeParticleSystemSources;
+    set systemSource(value: NodeParticleSystemSources);
+    private _contextualSource;
+    /**
+     * Gets a boolean indicating that the current connection point is a contextual value
+     */
+    get isContextual(): boolean;
+    /**
+     * Gets or sets the current contextual value
+     */
+    get contextualValue(): NodeParticleContextualSources;
+    set contextualValue(value: NodeParticleContextualSources);
+    /**
+     * Creates a new InputBlock
+     * @param name defines the block name
+     * @param type defines the type of the input (can be set to NodeParticleBlockConnectionPointTypes.AutoDetect)
+     */
+    constructor(name: string, type?: NodeParticleBlockConnectionPointTypes);
+    /**
+     * Gets or sets the value of that point.
+     * Please note that this value will be ignored if valueCallback is defined
+     */
+    get value(): any;
+    set value(value: any);
+    /**
+     * Gets or sets a callback used to get the value of that point.
+     * Please note that setting this value will force the connection point to ignore the value property
+     */
+    get valueCallback(): () => any;
+    set valueCallback(value: () => any);
+    /**
+     * Gets the current class name
+     * @returns the class name
+     */
+    getClassName(): string;
+    /**
+     * Gets the output component
+     */
+    get output(): NodeParticleConnectionPoint;
+    /**
+     * Set the input block to its default value (based on its type)
+     */
+    setDefaultValue(): void;
+    _build(state: NodeParticleBuildState): void;
+    dispose(): void;
+    serialize(): any;
+    _deserialize(serializationObject: any): void;
+}

package/Particles/Node/Blocks/particleInputBlock.js

@@ -0,0 +1,279 @@
+import { Observable } from "../../../Misc/observable.js";
+import { GetClass, RegisterClass } from "../../../Misc/typeStore.js";
+import { Matrix, Vector2, Vector3 } from "../../../Maths/math.vector.js";
+import { NodeParticleBlock } from "../nodeParticleBlock.js";
+import { NodeParticleBlockConnectionPointTypes } from "../Enums/nodeParticleBlockConnectionPointTypes.js";
+import { Color4 } from "../../../Maths/math.color.js";
+import { NodeParticleContextualSources } from "../Enums/nodeParticleContextualSources.js";
+import { NodeParticleSystemSources } from "../Enums/nodeParticleSystemSources.js";
+/**
+ * Block used to expose an input value
+ */
+export class ParticleInputBlock extends NodeParticleBlock {
+    /**
+     * Gets or sets the connection point type (default is float)
+     */
+    get type() {
+        if (this._type === NodeParticleBlockConnectionPointTypes.AutoDetect) {
+            if (this.value != null) {
+                if (!isNaN(this.value)) {
+                    this._type = NodeParticleBlockConnectionPointTypes.Float;
+                    return this._type;
+                }
+                switch (this.value.getClassName()) {
+                    case "Vector2":
+                        this._type = NodeParticleBlockConnectionPointTypes.Vector2;
+                        return this._type;
+                    case "Vector3":
+                        this._type = NodeParticleBlockConnectionPointTypes.Vector3;
+                        return this._type;
+                    case "Color4":
+                        this._type = NodeParticleBlockConnectionPointTypes.Color4;
+                        return this._type;
+                    case "Matrix":
+                        this._type = NodeParticleBlockConnectionPointTypes.Matrix;
+                        return this._type;
+                }
+            }
+        }
+        return this._type;
+    }
+    /**
+     * Gets a boolean indicating that the current connection point is a system source
+     */
+    get isSystemSource() {
+        return this._contextualSource === NodeParticleContextualSources.None && this._systemSource !== NodeParticleSystemSources.None;
+    }
+    /**
+     * Gets or sets the system source used by this input block
+     */
+    get systemSource() {
+        return this._systemSource;
+    }
+    set systemSource(value) {
+        this._systemSource = value;
+        if (value !== NodeParticleSystemSources.None) {
+            this._contextualSource = NodeParticleContextualSources.None;
+            this._type = NodeParticleBlockConnectionPointTypes.Float;
+            switch (value) {
+                case NodeParticleSystemSources.Time:
+                case NodeParticleSystemSources.Delta:
+                    this._type = NodeParticleBlockConnectionPointTypes.Float;
+                    break;
+                case NodeParticleSystemSources.Emitter:
+                    this._type = NodeParticleBlockConnectionPointTypes.Vector3;
+                    break;
+            }
+            if (this.output) {
+                this.output.type = this._type;
+            }
+        }
+    }
+    /**
+     * Gets a boolean indicating that the current connection point is a contextual value
+     */
+    get isContextual() {
+        return this._contextualSource !== NodeParticleContextualSources.None;
+    }
+    /**
+     * Gets or sets the current contextual value
+     */
+    get contextualValue() {
+        return this._contextualSource;
+    }
+    set contextualValue(value) {
+        this._contextualSource = value;
+        if (value !== NodeParticleContextualSources.None) {
+            this._systemSource = NodeParticleSystemSources.None;
+            switch (value) {
+                case NodeParticleContextualSources.Scale:
+                    this._type = NodeParticleBlockConnectionPointTypes.Vector2;
+                    break;
+                case NodeParticleContextualSources.Position:
+                case NodeParticleContextualSources.Direction:
+                case NodeParticleContextualSources.ScaledDirection:
+                    this._type = NodeParticleBlockConnectionPointTypes.Vector3;
+                    break;
+                case NodeParticleContextualSources.Color:
+                    this._type = NodeParticleBlockConnectionPointTypes.Color4;
+                    break;
+                case NodeParticleContextualSources.Age:
+                case NodeParticleContextualSources.Lifetime:
+                case NodeParticleContextualSources.Angle:
+                case NodeParticleContextualSources.AgeGradient:
+                    this._type = NodeParticleBlockConnectionPointTypes.Float;
+                    break;
+                case NodeParticleContextualSources.SpriteCellEnd:
+                case NodeParticleContextualSources.SpriteCellStart:
+                case NodeParticleContextualSources.SpriteCellIndex:
+                    this._type = NodeParticleBlockConnectionPointTypes.Int;
+                    break;
+            }
+            if (this.output) {
+                this.output.type = this._type;
+            }
+        }
+    }
+    /**
+     * Creates a new InputBlock
+     * @param name defines the block name
+     * @param type defines the type of the input (can be set to NodeParticleBlockConnectionPointTypes.AutoDetect)
+     */
+    constructor(name, type = NodeParticleBlockConnectionPointTypes.AutoDetect) {
+        super(name);
+        this._type = NodeParticleBlockConnectionPointTypes.Undefined;
+        /** Gets or set a value used to limit the range of float values */
+        this.min = 0;
+        /** Gets or set a value used to limit the range of float values */
+        this.max = 0;
+        /** Gets or sets the group to use to display this block in the Inspector */
+        this.groupInInspector = "";
+        /**
+         * Gets or sets a boolean indicating that this input is displayed in the Inspector
+         */
+        this.displayInInspector = true;
+        /** Gets an observable raised when the value is changed */
+        this.onValueChangedObservable = new Observable();
+        /** @internal */
+        this._systemSource = NodeParticleSystemSources.None;
+        this._contextualSource = NodeParticleContextualSources.None;
+        this._type = type;
+        this._isInput = true;
+        this._storedValue = null;
+        this.setDefaultValue();
+        this.registerOutput("output", type);
+    }
+    /**
+     * Gets or sets the value of that point.
+     * Please note that this value will be ignored if valueCallback is defined
+     */
+    get value() {
+        return this._storedValue;
+    }
+    set value(value) {
+        if (this.type === NodeParticleBlockConnectionPointTypes.Float) {
+            if (this.min !== this.max) {
+                value = Math.max(this.min, value);
+                value = Math.min(this.max, value);
+            }
+        }
+        this._storedValue = value;
+        this.onValueChangedObservable.notifyObservers(this);
+    }
+    /**
+     * Gets or sets a callback used to get the value of that point.
+     * Please note that setting this value will force the connection point to ignore the value property
+     */
+    get valueCallback() {
+        return this._valueCallback;
+    }
+    set valueCallback(value) {
+        this._valueCallback = value;
+    }
+    /**
+     * Gets the current class name
+     * @returns the class name
+     */
+    getClassName() {
+        return "ParticleInputBlock";
+    }
+    /**
+     * Gets the output component
+     */
+    get output() {
+        return this._outputs[0];
+    }
+    /**
+     * Set the input block to its default value (based on its type)
+     */
+    setDefaultValue() {
+        switch (this.type) {
+            case NodeParticleBlockConnectionPointTypes.Int:
+            case NodeParticleBlockConnectionPointTypes.Float:
+                this.value = 0;
+                break;
+            case NodeParticleBlockConnectionPointTypes.Vector2:
+                this.value = Vector2.Zero();
+                break;
+            case NodeParticleBlockConnectionPointTypes.Vector3:
+                this.value = Vector3.Zero();
+                break;
+            case NodeParticleBlockConnectionPointTypes.Color4:
+                this.value = new Color4(1, 1, 1, 1);
+                break;
+            case NodeParticleBlockConnectionPointTypes.Matrix:
+                this.value = Matrix.Identity();
+                break;
+        }
+    }
+    _build(state) {
+        super._build(state);
+        if (this.isSystemSource) {
+            this.output._storedValue = null;
+            this.output._storedFunction = (state) => {
+                return state.getSystemValue(this._systemSource);
+            };
+        }
+        else if (this.isContextual) {
+            this.output._storedValue = null;
+            this.output._storedFunction = (state) => {
+                return state.getContextualValue(this._contextualSource);
+            };
+        }
+        else {
+            this.output._storedFunction = null;
+            this.output._storedValue = this.value;
+        }
+    }
+    dispose() {
+        this.onValueChangedObservable.clear();
+        super.dispose();
+    }
+    serialize() {
+        const serializationObject = super.serialize();
+        serializationObject.type = this.type;
+        serializationObject.contextualValue = this.contextualValue;
+        serializationObject.systemSource = this.systemSource;
+        serializationObject.min = this.min;
+        serializationObject.max = this.max;
+        serializationObject.groupInInspector = this.groupInInspector;
+        serializationObject.displayInInspector = this.displayInInspector;
+        if (this._storedValue !== null && !this.isContextual && !this.isSystemSource) {
+            if (this._storedValue.asArray) {
+                serializationObject.valueType = "BABYLON." + this._storedValue.getClassName();
+                serializationObject.value = this._storedValue.asArray();
+            }
+            else {
+                serializationObject.valueType = "number";
+                serializationObject.value = this._storedValue;
+            }
+        }
+        return serializationObject;
+    }
+    _deserialize(serializationObject) {
+        super._deserialize(serializationObject);
+        this._type = serializationObject.type;
+        this.contextualValue = serializationObject.contextualValue;
+        this.systemSource = serializationObject.systemSource || NodeParticleSystemSources.None;
+        this.min = serializationObject.min || 0;
+        this.max = serializationObject.max || 0;
+        this.groupInInspector = serializationObject.groupInInspector || "";
+        if (serializationObject.displayInInspector !== undefined) {
+            this.displayInInspector = serializationObject.displayInInspector;
+        }
+        if (!serializationObject.valueType) {
+            return;
+        }
+        if (serializationObject.valueType === "number") {
+            this._storedValue = serializationObject.value;
+        }
+        else {
+            const valueType = GetClass(serializationObject.valueType);
+            if (valueType) {
+                this._storedValue = valueType.FromArray(serializationObject.value);
+            }
+        }
+    }
+}
+RegisterClass("BABYLON.ParticleInputBlock", ParticleInputBlock);
+//# sourceMappingURL=particleInputBlock.js.map