@babylonjs/gui 5.0.0-rc.0 → 5.0.0-rc.11

package/3D/materials/fluent/fluentMaterial.js

@@ -1,282 +1,293 @@
-import { __decorate, __extends } from "tslib";
-import { serializeAsColor4, serializeAsVector3, serializeAsTexture, serialize, expandToProperty, serializeAsColor3, SerializationHelper } from "@babylonjs/core/Misc/decorators.js";
-import { Vector3, TmpVectors } from "@babylonjs/core/Maths/math.vector.js";
-import { MaterialDefines } from "@babylonjs/core/Materials/materialDefines.js";
-import { MaterialHelper } from "@babylonjs/core/Materials/materialHelper.js";
-import { PushMaterial } from "@babylonjs/core/Materials/pushMaterial.js";
-import { VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
-import { RegisterClass } from "@babylonjs/core/Misc/typeStore.js";
-import { Color3, Color4 } from "@babylonjs/core/Maths/math.color.js";
-import "./shaders/fluent.vertex.js";
-import "./shaders/fluent.fragment.js";
-/** @hidden */
-var FluentMaterialDefines = /** @class */ (function (_super) {
-    __extends(FluentMaterialDefines, _super);
-    function FluentMaterialDefines() {
-        var _this = _super.call(this) || this;
-        _this.INNERGLOW = false;
-        _this.BORDER = false;
-        _this.HOVERLIGHT = false;
-        _this.TEXTURE = false;
-        _this.rebuild();
-        return _this;
-    }
-    return FluentMaterialDefines;
-}(MaterialDefines));
-export { FluentMaterialDefines };
-/**
- * Class used to render controls with fluent desgin
- */
-var FluentMaterial = /** @class */ (function (_super) {
-    __extends(FluentMaterial, _super);
-    /**
-     * Creates a new Fluent material
-     * @param name defines the name of the material
-     * @param scene defines the hosting scene
-     */
-    function FluentMaterial(name, scene) {
-        var _this = _super.call(this, name, scene) || this;
-        /**
-         * Gets or sets inner glow intensity. A value of 0 means no glow (default is 0.5)
-         */
-        _this.innerGlowColorIntensity = 0.5;
-        /**
-         * Gets or sets the inner glow color (white by default)
-         */
-        _this.innerGlowColor = new Color3(1.0, 1.0, 1.0);
-        /**
-         * Gets or sets the albedo color (Default is Color3(0.3, 0.35, 0.4))
-         */
-        _this.albedoColor = new Color3(0.3, 0.35, 0.4);
-        /**
-         * Gets or sets a boolean indicating if borders must be rendered (default is false)
-         */
-        _this.renderBorders = false;
-        /**
-         * Gets or sets border width (default is 0.5)
-         */
-        _this.borderWidth = 0.5;
-        /**
-         * Gets or sets a value indicating the smoothing value applied to border edges (0.02 by default)
-         */
-        _this.edgeSmoothingValue = 0.02;
-        /**
-         * Gets or sets the minimum value that can be applied to border width (default is 0.1)
-         */
-        _this.borderMinValue = 0.1;
-        /**
-         * Gets or sets a boolean indicating if hover light must be rendered (default is false)
-         */
-        _this.renderHoverLight = false;
-        /**
-         * Gets or sets the radius used to render the hover light (default is 1.0)
-         */
-        _this.hoverRadius = 0.01;
-        /**
-         * Gets or sets the color used to render the hover light (default is Color4(0.3, 0.3, 0.3, 1.0))
-         */
-        _this.hoverColor = new Color4(0.3, 0.3, 0.3, 1.0);
-        /**
-         * Gets or sets the hover light position in world space (default is Vector3.Zero())
-         */
-        _this.hoverPosition = Vector3.Zero();
-        return _this;
-    }
-    FluentMaterial.prototype.needAlphaBlending = function () {
-        return this.alpha !== 1.0;
-    };
-    FluentMaterial.prototype.needAlphaTesting = function () {
-        return false;
-    };
-    FluentMaterial.prototype.getAlphaTestTexture = function () {
-        return null;
-    };
-    FluentMaterial.prototype.isReadyForSubMesh = function (mesh, subMesh, useInstances) {
-        if (this.isFrozen) {
-            if (subMesh.effect && subMesh.effect._wasPreviouslyReady) {
-                return true;
-            }
-        }
-        if (!subMesh.materialDefines) {
-            subMesh.materialDefines = new FluentMaterialDefines();
-        }
-        var scene = this.getScene();
-        var defines = subMesh.materialDefines;
-        if (!this.checkReadyOnEveryCall && subMesh.effect) {
-            if (defines._renderId === scene.getRenderId()) {
-                return true;
-            }
-        }
-        if (defines._areTexturesDirty) {
-            defines.INNERGLOW = this.innerGlowColorIntensity > 0;
-            defines.BORDER = this.renderBorders;
-            defines.HOVERLIGHT = this.renderHoverLight;
-            if (this._albedoTexture) {
-                if (!this._albedoTexture.isReadyOrNotBlocking()) {
-                    return false;
-                }
-                else {
-                    defines.TEXTURE = true;
-                }
-            }
-            else {
-                defines.TEXTURE = false;
-            }
-        }
-        var engine = scene.getEngine();
-        // Get correct effect
-        if (defines.isDirty) {
-            defines.markAsProcessed();
-            scene.resetCachedMaterial();
-            //Attributes
-            var attribs = [VertexBuffer.PositionKind];
-            attribs.push(VertexBuffer.NormalKind);
-            attribs.push(VertexBuffer.UVKind);
-            var shaderName = "fluent";
-            var uniforms = ["world", "viewProjection", "innerGlowColor", "albedoColor", "borderWidth", "edgeSmoothingValue", "scaleFactor", "borderMinValue",
-                "hoverColor", "hoverPosition", "hoverRadius", "textureMatrix"
-            ];
-            var samplers = ["albedoSampler"];
-            var uniformBuffers = new Array();
-            MaterialHelper.PrepareUniformsAndSamplersList({
-                uniformsNames: uniforms,
-                uniformBuffersNames: uniformBuffers,
-                samplers: samplers,
-                defines: defines,
-                maxSimultaneousLights: 4
-            });
-            var join = defines.toString();
-            subMesh.setEffect(scene.getEngine().createEffect(shaderName, {
-                attributes: attribs,
-                uniformsNames: uniforms,
-                uniformBuffersNames: uniformBuffers,
-                samplers: samplers,
-                defines: join,
-                fallbacks: null,
-                onCompiled: this.onCompiled,
-                onError: this.onError,
-                indexParameters: { maxSimultaneousLights: 4 }
-            }, engine), defines, this._materialContext);
-        }
-        if (!subMesh.effect || !subMesh.effect.isReady()) {
-            return false;
-        }
-        defines._renderId = scene.getRenderId();
-        subMesh.effect._wasPreviouslyReady = true;
-        return true;
-    };
-    FluentMaterial.prototype.bindForSubMesh = function (world, mesh, subMesh) {
-        var scene = this.getScene();
-        var defines = subMesh.materialDefines;
-        if (!defines) {
-            return;
-        }
-        var effect = subMesh.effect;
-        if (!effect) {
-            return;
-        }
-        this._activeEffect = effect;
-        // Matrices
-        this.bindOnlyWorldMatrix(world);
-        this._activeEffect.setMatrix("viewProjection", scene.getTransformMatrix());
-        if (this._mustRebind(scene, effect)) {
-            this._activeEffect.setColor4("albedoColor", this.albedoColor, this.alpha);
-            if (defines.INNERGLOW) {
-                this._activeEffect.setColor4("innerGlowColor", this.innerGlowColor, this.innerGlowColorIntensity);
-            }
-            if (defines.BORDER) {
-                this._activeEffect.setFloat("borderWidth", this.borderWidth);
-                this._activeEffect.setFloat("edgeSmoothingValue", this.edgeSmoothingValue);
-                this._activeEffect.setFloat("borderMinValue", this.borderMinValue);
-                mesh.getBoundingInfo().boundingBox.extendSize.multiplyToRef(mesh.scaling, TmpVectors.Vector3[0]);
-                this._activeEffect.setVector3("scaleFactor", TmpVectors.Vector3[0]);
-            }
-            if (defines.HOVERLIGHT) {
-                this._activeEffect.setDirectColor4("hoverColor", this.hoverColor);
-                this._activeEffect.setFloat("hoverRadius", this.hoverRadius);
-                this._activeEffect.setVector3("hoverPosition", this.hoverPosition);
-            }
-            if (defines.TEXTURE && this._albedoTexture) {
-                this._activeEffect.setTexture("albedoSampler", this._albedoTexture);
-                var matrix = this._albedoTexture.getTextureMatrix();
-                this._activeEffect.setMatrix("textureMatrix", matrix);
-            }
-        }
-        this._afterBind(mesh, this._activeEffect);
-    };
-    FluentMaterial.prototype.getActiveTextures = function () {
-        var activeTextures = _super.prototype.getActiveTextures.call(this);
-        return activeTextures;
-    };
-    FluentMaterial.prototype.hasTexture = function (texture) {
-        if (_super.prototype.hasTexture.call(this, texture)) {
-            return true;
-        }
-        return false;
-    };
-    FluentMaterial.prototype.dispose = function (forceDisposeEffect) {
-        _super.prototype.dispose.call(this, forceDisposeEffect);
-    };
-    FluentMaterial.prototype.clone = function (name) {
-        var _this = this;
-        return SerializationHelper.Clone(function () { return new FluentMaterial(name, _this.getScene()); }, this);
-    };
-    FluentMaterial.prototype.serialize = function () {
-        var serializationObject = _super.prototype.serialize.call(this);
-        serializationObject.customType = "BABYLON.GUI.FluentMaterial";
-        return serializationObject;
-    };
-    FluentMaterial.prototype.getClassName = function () {
-        return "FluentMaterial";
-    };
-    // Statics
-    FluentMaterial.Parse = function (source, scene, rootUrl) {
-        return SerializationHelper.Parse(function () { return new FluentMaterial(source.name, scene); }, source, scene, rootUrl);
-    };
-    __decorate([
-        serialize(),
-        expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], FluentMaterial.prototype, "innerGlowColorIntensity", void 0);
-    __decorate([
-        serializeAsColor3()
-    ], FluentMaterial.prototype, "innerGlowColor", void 0);
-    __decorate([
-        serializeAsColor3()
-    ], FluentMaterial.prototype, "albedoColor", void 0);
-    __decorate([
-        serialize(),
-        expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], FluentMaterial.prototype, "renderBorders", void 0);
-    __decorate([
-        serialize()
-    ], FluentMaterial.prototype, "borderWidth", void 0);
-    __decorate([
-        serialize()
-    ], FluentMaterial.prototype, "edgeSmoothingValue", void 0);
-    __decorate([
-        serialize()
-    ], FluentMaterial.prototype, "borderMinValue", void 0);
-    __decorate([
-        serialize(),
-        expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], FluentMaterial.prototype, "renderHoverLight", void 0);
-    __decorate([
-        serialize()
-    ], FluentMaterial.prototype, "hoverRadius", void 0);
-    __decorate([
-        serializeAsColor4()
-    ], FluentMaterial.prototype, "hoverColor", void 0);
-    __decorate([
-        serializeAsVector3()
-    ], FluentMaterial.prototype, "hoverPosition", void 0);
-    __decorate([
-        serializeAsTexture("albedoTexture")
-    ], FluentMaterial.prototype, "_albedoTexture", void 0);
-    __decorate([
-        expandToProperty("_markAllSubMeshesAsTexturesAndMiscDirty")
-    ], FluentMaterial.prototype, "albedoTexture", void 0);
-    return FluentMaterial;
-}(PushMaterial));
-export { FluentMaterial };
-RegisterClass("BABYLON.GUI.FluentMaterial", FluentMaterial);
+import { __decorate, __extends } from "tslib";
+import { serializeAsColor4, serializeAsVector3, serializeAsTexture, serialize, expandToProperty, serializeAsColor3, SerializationHelper } from "@babylonjs/core/Misc/decorators.js";
+import { Vector3, TmpVectors } from "@babylonjs/core/Maths/math.vector.js";
+import { MaterialDefines } from "@babylonjs/core/Materials/materialDefines.js";
+import { MaterialHelper } from "@babylonjs/core/Materials/materialHelper.js";
+import { PushMaterial } from "@babylonjs/core/Materials/pushMaterial.js";
+import { VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
+import { RegisterClass } from "@babylonjs/core/Misc/typeStore.js";
+import { Color3, Color4 } from "@babylonjs/core/Maths/math.color.js";
+import "./shaders/fluent.vertex";
+import "./shaders/fluent.fragment";
+/** @hidden */
+var FluentMaterialDefines = /** @class */ (function (_super) {
+    __extends(FluentMaterialDefines, _super);
+    function FluentMaterialDefines() {
+        var _this = _super.call(this) || this;
+        _this.INNERGLOW = false;
+        _this.BORDER = false;
+        _this.HOVERLIGHT = false;
+        _this.TEXTURE = false;
+        _this.rebuild();
+        return _this;
+    }
+    return FluentMaterialDefines;
+}(MaterialDefines));
+export { FluentMaterialDefines };
+/**
+ * Class used to render controls with fluent design
+ */
+var FluentMaterial = /** @class */ (function (_super) {
+    __extends(FluentMaterial, _super);
+    /**
+     * Creates a new Fluent material
+     * @param name defines the name of the material
+     * @param scene defines the hosting scene
+     */
+    function FluentMaterial(name, scene) {
+        var _this = _super.call(this, name, scene) || this;
+        /**
+         * Gets or sets inner glow intensity. A value of 0 means no glow (default is 0.5)
+         */
+        _this.innerGlowColorIntensity = 0.5;
+        /**
+         * Gets or sets the inner glow color (white by default)
+         */
+        _this.innerGlowColor = new Color3(1.0, 1.0, 1.0);
+        /**
+         * Gets or sets the albedo color (Default is Color3(0.3, 0.35, 0.4))
+         */
+        _this.albedoColor = new Color3(0.3, 0.35, 0.4);
+        /**
+         * Gets or sets a boolean indicating if borders must be rendered (default is false)
+         */
+        _this.renderBorders = false;
+        /**
+         * Gets or sets border width (default is 0.5)
+         */
+        _this.borderWidth = 0.5;
+        /**
+         * Gets or sets a value indicating the smoothing value applied to border edges (0.02 by default)
+         */
+        _this.edgeSmoothingValue = 0.02;
+        /**
+         * Gets or sets the minimum value that can be applied to border width (default is 0.1)
+         */
+        _this.borderMinValue = 0.1;
+        /**
+         * Gets or sets a boolean indicating if hover light must be rendered (default is false)
+         */
+        _this.renderHoverLight = false;
+        /**
+         * Gets or sets the radius used to render the hover light (default is 1.0)
+         */
+        _this.hoverRadius = 0.01;
+        /**
+         * Gets or sets the color used to render the hover light (default is Color4(0.3, 0.3, 0.3, 1.0))
+         */
+        _this.hoverColor = new Color4(0.3, 0.3, 0.3, 1.0);
+        /**
+         * Gets or sets the hover light position in world space (default is Vector3.Zero())
+         */
+        _this.hoverPosition = Vector3.Zero();
+        return _this;
+    }
+    FluentMaterial.prototype.needAlphaBlending = function () {
+        return this.alpha !== 1.0;
+    };
+    FluentMaterial.prototype.needAlphaTesting = function () {
+        return false;
+    };
+    FluentMaterial.prototype.getAlphaTestTexture = function () {
+        return null;
+    };
+    FluentMaterial.prototype.isReadyForSubMesh = function (mesh, subMesh) {
+        if (this.isFrozen) {
+            if (subMesh.effect && subMesh.effect._wasPreviouslyReady) {
+                return true;
+            }
+        }
+        if (!subMesh.materialDefines) {
+            subMesh.materialDefines = new FluentMaterialDefines();
+        }
+        var scene = this.getScene();
+        var defines = subMesh.materialDefines;
+        if (!this.checkReadyOnEveryCall && subMesh.effect) {
+            if (defines._renderId === scene.getRenderId()) {
+                return true;
+            }
+        }
+        if (defines._areTexturesDirty) {
+            defines.INNERGLOW = this.innerGlowColorIntensity > 0;
+            defines.BORDER = this.renderBorders;
+            defines.HOVERLIGHT = this.renderHoverLight;
+            if (this._albedoTexture) {
+                if (!this._albedoTexture.isReadyOrNotBlocking()) {
+                    return false;
+                }
+                else {
+                    defines.TEXTURE = true;
+                }
+            }
+            else {
+                defines.TEXTURE = false;
+            }
+        }
+        var engine = scene.getEngine();
+        // Get correct effect
+        if (defines.isDirty) {
+            defines.markAsProcessed();
+            scene.resetCachedMaterial();
+            //Attributes
+            var attribs = [VertexBuffer.PositionKind];
+            attribs.push(VertexBuffer.NormalKind);
+            attribs.push(VertexBuffer.UVKind);
+            var shaderName = "fluent";
+            var uniforms = [
+                "world",
+                "viewProjection",
+                "innerGlowColor",
+                "albedoColor",
+                "borderWidth",
+                "edgeSmoothingValue",
+                "scaleFactor",
+                "borderMinValue",
+                "hoverColor",
+                "hoverPosition",
+                "hoverRadius",
+                "textureMatrix",
+            ];
+            var samplers = ["albedoSampler"];
+            var uniformBuffers = new Array();
+            MaterialHelper.PrepareUniformsAndSamplersList({
+                uniformsNames: uniforms,
+                uniformBuffersNames: uniformBuffers,
+                samplers: samplers,
+                defines: defines,
+                maxSimultaneousLights: 4,
+            });
+            var join = defines.toString();
+            subMesh.setEffect(scene.getEngine().createEffect(shaderName, {
+                attributes: attribs,
+                uniformsNames: uniforms,
+                uniformBuffersNames: uniformBuffers,
+                samplers: samplers,
+                defines: join,
+                fallbacks: null,
+                onCompiled: this.onCompiled,
+                onError: this.onError,
+                indexParameters: { maxSimultaneousLights: 4 },
+            }, engine), defines, this._materialContext);
+        }
+        if (!subMesh.effect || !subMesh.effect.isReady()) {
+            return false;
+        }
+        defines._renderId = scene.getRenderId();
+        subMesh.effect._wasPreviouslyReady = true;
+        return true;
+    };
+    FluentMaterial.prototype.bindForSubMesh = function (world, mesh, subMesh) {
+        var scene = this.getScene();
+        var defines = subMesh.materialDefines;
+        if (!defines) {
+            return;
+        }
+        var effect = subMesh.effect;
+        if (!effect) {
+            return;
+        }
+        this._activeEffect = effect;
+        // Matrices
+        this.bindOnlyWorldMatrix(world);
+        this._activeEffect.setMatrix("viewProjection", scene.getTransformMatrix());
+        if (this._mustRebind(scene, effect)) {
+            this._activeEffect.setColor4("albedoColor", this.albedoColor, this.alpha);
+            if (defines.INNERGLOW) {
+                this._activeEffect.setColor4("innerGlowColor", this.innerGlowColor, this.innerGlowColorIntensity);
+            }
+            if (defines.BORDER) {
+                this._activeEffect.setFloat("borderWidth", this.borderWidth);
+                this._activeEffect.setFloat("edgeSmoothingValue", this.edgeSmoothingValue);
+                this._activeEffect.setFloat("borderMinValue", this.borderMinValue);
+                mesh.getBoundingInfo().boundingBox.extendSize.multiplyToRef(mesh.scaling, TmpVectors.Vector3[0]);
+                this._activeEffect.setVector3("scaleFactor", TmpVectors.Vector3[0]);
+            }
+            if (defines.HOVERLIGHT) {
+                this._activeEffect.setDirectColor4("hoverColor", this.hoverColor);
+                this._activeEffect.setFloat("hoverRadius", this.hoverRadius);
+                this._activeEffect.setVector3("hoverPosition", this.hoverPosition);
+            }
+            if (defines.TEXTURE && this._albedoTexture) {
+                this._activeEffect.setTexture("albedoSampler", this._albedoTexture);
+                var matrix = this._albedoTexture.getTextureMatrix();
+                this._activeEffect.setMatrix("textureMatrix", matrix);
+            }
+        }
+        this._afterBind(mesh, this._activeEffect);
+    };
+    FluentMaterial.prototype.getActiveTextures = function () {
+        var activeTextures = _super.prototype.getActiveTextures.call(this);
+        return activeTextures;
+    };
+    FluentMaterial.prototype.hasTexture = function (texture) {
+        if (_super.prototype.hasTexture.call(this, texture)) {
+            return true;
+        }
+        return false;
+    };
+    FluentMaterial.prototype.dispose = function (forceDisposeEffect) {
+        _super.prototype.dispose.call(this, forceDisposeEffect);
+    };
+    FluentMaterial.prototype.clone = function (name) {
+        var _this = this;
+        return SerializationHelper.Clone(function () { return new FluentMaterial(name, _this.getScene()); }, this);
+    };
+    FluentMaterial.prototype.serialize = function () {
+        var serializationObject = _super.prototype.serialize.call(this);
+        serializationObject.customType = "BABYLON.GUI.FluentMaterial";
+        return serializationObject;
+    };
+    FluentMaterial.prototype.getClassName = function () {
+        return "FluentMaterial";
+    };
+    // Statics
+    FluentMaterial.Parse = function (source, scene, rootUrl) {
+        return SerializationHelper.Parse(function () { return new FluentMaterial(source.name, scene); }, source, scene, rootUrl);
+    };
+    __decorate([
+        serialize(),
+        expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], FluentMaterial.prototype, "innerGlowColorIntensity", void 0);
+    __decorate([
+        serializeAsColor3()
+    ], FluentMaterial.prototype, "innerGlowColor", void 0);
+    __decorate([
+        serializeAsColor3()
+    ], FluentMaterial.prototype, "albedoColor", void 0);
+    __decorate([
+        serialize(),
+        expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], FluentMaterial.prototype, "renderBorders", void 0);
+    __decorate([
+        serialize()
+    ], FluentMaterial.prototype, "borderWidth", void 0);
+    __decorate([
+        serialize()
+    ], FluentMaterial.prototype, "edgeSmoothingValue", void 0);
+    __decorate([
+        serialize()
+    ], FluentMaterial.prototype, "borderMinValue", void 0);
+    __decorate([
+        serialize(),
+        expandToProperty("_markAllSubMeshesAsTexturesDirty")
+    ], FluentMaterial.prototype, "renderHoverLight", void 0);
+    __decorate([
+        serialize()
+    ], FluentMaterial.prototype, "hoverRadius", void 0);
+    __decorate([
+        serializeAsColor4()
+    ], FluentMaterial.prototype, "hoverColor", void 0);
+    __decorate([
+        serializeAsVector3()
+    ], FluentMaterial.prototype, "hoverPosition", void 0);
+    __decorate([
+        serializeAsTexture("albedoTexture")
+    ], FluentMaterial.prototype, "_albedoTexture", void 0);
+    __decorate([
+        expandToProperty("_markAllSubMeshesAsTexturesAndMiscDirty")
+    ], FluentMaterial.prototype, "albedoTexture", void 0);
+    return FluentMaterial;
+}(PushMaterial));
+export { FluentMaterial };
+RegisterClass("BABYLON.GUI.FluentMaterial", FluentMaterial);
 //# sourceMappingURL=fluentMaterial.js.map