@babylonjs/core 6.11.0 → 6.11.2

package/Materials/greasedLinePluginMaterial.js

@@ -1,25 +1,58 @@
 import { Engine } from "../Engines/engine.js";
 import { RawTexture } from "./Textures/rawTexture.js";
 import { MaterialPluginBase } from "./materialPluginBase.js";
-import { TmpVectors } from "../Maths/math.vector.js";
+import { Vector2, TmpVectors } from "../Maths/math.vector.js";
 import { Color3 } from "../Maths/math.color.js";
 import { MaterialDefines } from "./materialDefines.js";
-import { DeepCopier } from "../Misc/deepCopier.js";
 import { RegisterClass } from "../Misc/typeStore.js";
+/**
+ * Material types for GreasedLine
+ * {@link https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/param/greased_line#materialtype}
+ */
 export var GreasedLineMeshMaterialType;
 (function (GreasedLineMeshMaterialType) {
+    /**
+     * StandardMaterial
+     */
     GreasedLineMeshMaterialType[GreasedLineMeshMaterialType["MATERIAL_TYPE_STANDARD"] = 0] = "MATERIAL_TYPE_STANDARD";
+    /**
+     * PBR Material
+     */
     GreasedLineMeshMaterialType[GreasedLineMeshMaterialType["MATERIAL_TYPE_PBR"] = 1] = "MATERIAL_TYPE_PBR";
 })(GreasedLineMeshMaterialType || (GreasedLineMeshMaterialType = {}));
+/**
+ * Color blending mode of the @see GreasedLineMaterial and the base material
+ * {@link https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/param/greased_line#colormode}
+ */
 export var GreasedLineMeshColorMode;
 (function (GreasedLineMeshColorMode) {
+    /**
+     * Color blending mode SET
+     */
     GreasedLineMeshColorMode[GreasedLineMeshColorMode["COLOR_MODE_SET"] = 0] = "COLOR_MODE_SET";
+    /**
+     * Color blending mode ADD
+     */
     GreasedLineMeshColorMode[GreasedLineMeshColorMode["COLOR_MODE_ADD"] = 1] = "COLOR_MODE_ADD";
+    /**
+     * Color blending mode ADD
+     */
     GreasedLineMeshColorMode[GreasedLineMeshColorMode["COLOR_MODE_MULTIPLY"] = 2] = "COLOR_MODE_MULTIPLY";
 })(GreasedLineMeshColorMode || (GreasedLineMeshColorMode = {}));
+/**
+ * Color distribution type of the @see colors.
+ * {@link https://doc.babylonjs.com/features/featuresDeepDive/mesh/creation/param/greased_line#colordistributiontype}
+ *
+ */
 export var GreasedLineMeshColorDistributionType;
 (function (GreasedLineMeshColorDistributionType) {
+    /**
+     * Colors distributed between segments of the line
+     */
     GreasedLineMeshColorDistributionType[GreasedLineMeshColorDistributionType["COLOR_DISTRIBUTION_TYPE_SEGMENT"] = 0] = "COLOR_DISTRIBUTION_TYPE_SEGMENT";
+    /**
+     * Colors distributed along the line ingoring the segments
+     */
     GreasedLineMeshColorDistributionType[GreasedLineMeshColorDistributionType["COLOR_DISTRIBUTION_TYPE_LINE"] = 1] = "COLOR_DISTRIBUTION_TYPE_LINE";
 })(GreasedLineMeshColorDistributionType || (GreasedLineMeshColorDistributionType = {}));
 /**
@@ -50,25 +83,39 @@ export class MaterialGreasedLineDefines extends MaterialDefines {
  */
 export class GreasedLinePluginMaterial extends MaterialPluginBase {
     constructor(material, _scene, options) {
-        var _a, _b, _c;
-        options = options !== null && options !== void 0 ? options : {};
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+        options = options || {
+            color: GreasedLinePluginMaterial.DEFAULT_COLOR,
+        };
         const defines = new MaterialGreasedLineDefines();
         defines.GREASED_LINE_HAS_COLOR = !!options.color;
         defines.GREASED_LINE_SIZE_ATTENUATION = (_a = options.sizeAttenuation) !== null && _a !== void 0 ? _a : false;
         defines.GREASED_LINE_COLOR_DISTRIBUTION_TYPE_LINE = options.colorDistributionType === GreasedLineMeshColorDistributionType.COLOR_DISTRIBUTION_TYPE_LINE;
         super(material, GreasedLinePluginMaterial.GREASED_LINE_MATERIAL_NAME, 200, defines);
         this._scene = _scene;
-        this._dashArray = 0;
-        this._options = options;
         this._scene = (_b = this._scene) !== null && _b !== void 0 ? _b : material.getScene();
         this._engine = this._scene.getEngine();
-        if (options.colors) {
-            this._createColorsTexture(`${material.name}-colors-texture`, options.colors);
+        this.visibility = (_c = options.visibility) !== null && _c !== void 0 ? _c : 1;
+        this.useDash = (_d = options.useDash) !== null && _d !== void 0 ? _d : false;
+        this.dashRatio = (_e = options.dashRatio) !== null && _e !== void 0 ? _e : 0.5;
+        this.dashOffset = (_f = options.dashOffset) !== null && _f !== void 0 ? _f : 0;
+        this.width = options.width ? options.width : options.sizeAttenuation ? GreasedLinePluginMaterial.DEFAULT_WIDTH_ATTENUATED : GreasedLinePluginMaterial.DEFAULT_WIDTH;
+        this._sizeAttenuation = (_g = options.sizeAttenuation) !== null && _g !== void 0 ? _g : false;
+        this.colorMode = (_h = options.colorMode) !== null && _h !== void 0 ? _h : GreasedLineMeshColorMode.COLOR_MODE_SET;
+        this._color = (_j = options.color) !== null && _j !== void 0 ? _j : null;
+        this.useColors = (_k = options.useColors) !== null && _k !== void 0 ? _k : false;
+        this._colorsDistributionType = (_l = options.colorDistributionType) !== null && _l !== void 0 ? _l : GreasedLineMeshColorDistributionType.COLOR_DISTRIBUTION_TYPE_SEGMENT;
+        this.colorsSampling = (_m = options.colorsSampling) !== null && _m !== void 0 ? _m : RawTexture.NEAREST_NEAREST;
+        this._colors = (_o = options.colors) !== null && _o !== void 0 ? _o : null;
+        this.dashCount = (_p = options.dashCount) !== null && _p !== void 0 ? _p : 1; // calculate the _dashArray value, call the setter
+        this.resolution = (_q = options.resolution) !== null && _q !== void 0 ? _q : new Vector2(this._engine.getRenderWidth(), this._engine.getRenderHeight()); // calculate aspect call the setter
+        if (this._colors) {
+            this._createColorsTexture(`${material.name}-colors-texture`, this._colors);
         }
         else {
+            this._color = (_r = this._color) !== null && _r !== void 0 ? _r : GreasedLinePluginMaterial.DEFAULT_COLOR;
             GreasedLinePluginMaterial._PrepareEmptyColorsTexture(_scene);
         }
-        this.setDashCount((_c = options.dashCount) !== null && _c !== void 0 ? _c : 1); // calculate the _dashArray value
         this._enable(true); // always enabled
     }
     /**
@@ -106,14 +153,14 @@ export class GreasedLinePluginMaterial extends MaterialPluginBase {
         const ubo = [
             { name: "grl_projection", size: 16, type: "mat4" },
             { name: "grl_singleColor", size: 3, type: "vec3" },
-            { name: "grl_resolution_lineWidth", size: 3, type: "vec3" },
+            { name: "grl_aspect_lineWidth", size: 3, type: "vec3" },
             { name: "grl_dashOptions", size: 4, type: "vec4" },
             { name: "grl_colorMode_visibility_colorsWidth_useColors", size: 4, type: "vec4" },
         ];
         return {
             ubo,
             vertex: `
-                uniform vec3 grl_resolution_lineWidth;
+                uniform vec3 grl_aspect_lineWidth;
                 uniform mat4 grl_projection;
                 `,
             fragment: `
@@ -133,7 +180,7 @@ export class GreasedLinePluginMaterial extends MaterialPluginBase {
      * @param uniformBuffer
      */
     bindForSubMesh(uniformBuffer) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a;
         const activeCamera = this._scene.activeCamera;
         if (activeCamera) {
             const projection = activeCamera.getProjectionMatrix();
@@ -143,32 +190,26 @@ export class GreasedLinePluginMaterial extends MaterialPluginBase {
             throw Error("GreasedLinePluginMaterial requires an active camera.");
         }
         const resolutionLineWidth = TmpVectors.Vector3[0];
-        if (this._options.resolution) {
-            resolutionLineWidth.x = this._options.resolution.x;
-            resolutionLineWidth.y = this._options.resolution.y;
-        }
-        else {
-            resolutionLineWidth.x = this._engine.getRenderWidth();
-            resolutionLineWidth.y = this._engine.getRenderHeight();
-        }
-        resolutionLineWidth.z = this._options.width ? this._options.width : this._options.sizeAttenuation ? 1 : 0.1;
-        uniformBuffer.updateVector3("grl_resolution_lineWidth", resolutionLineWidth);
+        resolutionLineWidth.x = this._aspect;
+        // TODO: y free
+        resolutionLineWidth.z = this.width;
+        uniformBuffer.updateVector3("grl_aspect_lineWidth", resolutionLineWidth);
         const dashOptions = TmpVectors.Vector4[0];
-        dashOptions.x = GreasedLinePluginMaterial._BooleanToNumber(this._options.useDash);
-        dashOptions.y = (_a = this._dashArray) !== null && _a !== void 0 ? _a : 0;
-        dashOptions.z = (_b = this._options.dashOffset) !== null && _b !== void 0 ? _b : 0;
-        dashOptions.w = (_c = this._options.dashRatio) !== null && _c !== void 0 ? _c : 0.5;
+        dashOptions.x = GreasedLinePluginMaterial._BooleanToNumber(this.useDash);
+        dashOptions.y = this._dashArray;
+        dashOptions.z = this.dashOffset;
+        dashOptions.w = this.dashRatio;
         uniformBuffer.updateVector4("grl_dashOptions", dashOptions);
         const colorModeVisibilityColorsWidthUseColors = TmpVectors.Vector4[1];
-        colorModeVisibilityColorsWidthUseColors.x = (_d = this._options.colorMode) !== null && _d !== void 0 ? _d : GreasedLineMeshColorMode.COLOR_MODE_SET;
-        colorModeVisibilityColorsWidthUseColors.y = (_e = this._options.visibility) !== null && _e !== void 0 ? _e : 1;
+        colorModeVisibilityColorsWidthUseColors.x = this.colorMode;
+        colorModeVisibilityColorsWidthUseColors.y = this.visibility;
         colorModeVisibilityColorsWidthUseColors.z = this._colorsTexture ? this._colorsTexture.getSize().width : 0;
-        colorModeVisibilityColorsWidthUseColors.w = GreasedLinePluginMaterial._BooleanToNumber(this._options.useColors);
+        colorModeVisibilityColorsWidthUseColors.w = GreasedLinePluginMaterial._BooleanToNumber(this.useColors);
         uniformBuffer.updateVector4("grl_colorMode_visibility_colorsWidth_useColors", colorModeVisibilityColorsWidthUseColors);
-        if (this._options.color) {
-            uniformBuffer.updateColor3("grl_singleColor", (_f = this._options.color) !== null && _f !== void 0 ? _f : Color3.White());
+        if (this._color) {
+            uniformBuffer.updateColor3("grl_singleColor", this._color);
         }
-        uniformBuffer.setTexture("grl_colors", (_g = this._colorsTexture) !== null && _g !== void 0 ? _g : GreasedLinePluginMaterial._EmptyColorsTexture);
+        uniformBuffer.setTexture("grl_colors", (_a = this._colorsTexture) !== null && _a !== void 0 ? _a : GreasedLinePluginMaterial._EmptyColorsTexture);
     }
     /**
      * Prepare the defines
@@ -178,10 +219,9 @@ export class GreasedLinePluginMaterial extends MaterialPluginBase {
      */
     prepareDefines(defines, _scene, _mesh) {
         var _a;
-        const options = this._options;
-        defines.GREASED_LINE_HAS_COLOR = !!options.color;
-        defines.GREASED_LINE_SIZE_ATTENUATION = (_a = options.sizeAttenuation) !== null && _a !== void 0 ? _a : false;
-        defines.GREASED_LINE_COLOR_DISTRIBUTION_TYPE_LINE = options.colorDistributionType === GreasedLineMeshColorDistributionType.COLOR_DISTRIBUTION_TYPE_LINE;
+        defines.GREASED_LINE_HAS_COLOR = !!this._color;
+        defines.GREASED_LINE_SIZE_ATTENUATION = (_a = this._sizeAttenuation) !== null && _a !== void 0 ? _a : false;
+        defines.GREASED_LINE_COLOR_DISTRIBUTION_TYPE_LINE = this._colorsDistributionType === GreasedLineMeshColorDistributionType.COLOR_DISTRIBUTION_TYPE_LINE;
     }
     /**
      * Get the class name
@@ -222,8 +262,9 @@ export class GreasedLinePluginMaterial extends MaterialPluginBase {
                 `,
                 // eslint-disable-next-line @typescript-eslint/naming-convention
                 CUSTOM_VERTEX_MAIN_END: `
-                    vec2 grlResolution = grl_resolution_lineWidth.xy;
-                    float grlBaseWidth = grl_resolution_lineWidth.z;
+
+                    float grlAspect = grl_aspect_lineWidth.x;
+                    float grlBaseWidth = grl_aspect_lineWidth.z;
 
                     grlColorPointer = grl_colorPointers;
 
@@ -233,7 +274,6 @@ export class GreasedLinePluginMaterial extends MaterialPluginBase {
                     vec3 grlNext = grl_nextAndCounters.xyz;
                     grlCounters = grl_nextAndCounters.w;
 
-                    float grlAspect = grlResolution.x / grlResolution.y;
 
                     mat4 grlMatrix = viewProjection * world;
                     vec4 grlFinalPosition = grlMatrix * vec4( positionUpdated , 1.0 );
@@ -357,9 +397,8 @@ export class GreasedLinePluginMaterial extends MaterialPluginBase {
      * @param colors Uint8Array of colors
      */
     _createColorsTexture(name, colors) {
-        var _a;
         const colorsArray = GreasedLinePluginMaterial._Color3toRGBAUint8(colors);
-        this._colorsTexture = new RawTexture(colorsArray, colors.length, 1, Engine.TEXTUREFORMAT_RGBA, this._scene, false, true, (_a = this._options.colorsSampling) !== null && _a !== void 0 ? _a : RawTexture.NEAREST_NEAREST);
+        this._colorsTexture = new RawTexture(colorsArray, colors.length, 1, Engine.TEXTUREFORMAT_RGBA, this._scene, false, true, this.colorsSampling);
         this._colorsTexture.name = name;
     }
     /**
@@ -371,11 +410,16 @@ export class GreasedLinePluginMaterial extends MaterialPluginBase {
         super.dispose();
     }
     /**
-     * Sets whether to use the colors option to colorize the line.
-     * @param value true if use the colors, otherwise false
+     * Returns the colors used to colorize the line
+     */
+    get colors() {
+        return this._colors;
+    }
+    /**
+     * Sets the colors used to colorize the line
      */
-    setUseColors(value) {
-        this._options.useColors = value;
+    set colors(value) {
+        this.setColors(value);
     }
     /**
      * Creates or updates the colors texture
@@ -386,12 +430,12 @@ export class GreasedLinePluginMaterial extends MaterialPluginBase {
      */
     setColors(colors, lazy = false, forceUpdate = false) {
         var _a, _b, _c, _d;
+        const origColorsCount = (_b = (_a = this._colors) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        this._colors = colors;
         if (colors === null || colors.length === 0) {
-            (_a = this._colorsTexture) === null || _a === void 0 ? void 0 : _a.dispose();
+            (_c = this._colorsTexture) === null || _c === void 0 ? void 0 : _c.dispose();
             return;
         }
-        const origColorsCount = (_c = (_b = this._options.colors) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
-        this._options.colors = colors;
         if (lazy && !forceUpdate) {
             return;
         }
@@ -408,90 +452,92 @@ export class GreasedLinePluginMaterial extends MaterialPluginBase {
      * Updates the material. Use when material created in lazy mode.
      */
     updateLazy() {
-        if (this._options.colors) {
-            this.setColors(this._options.colors, false, true);
+        if (this._colors) {
+            this.setColors(this._colors, false, true);
         }
     }
     /**
-     * Gets the plugin material options
-     * @returns the plugin material options @see GreasedLineMaterialOptions
-     */
-    getOptions() {
-        return this._options;
-    }
-    /**
-     * Sets the line length visibility.
-     * 0 - 0% of the line will be visible
-     * 1 - 100% of the line will be visible
-     * @param value
-     */
-    setVisibility(value) {
-        this._options.visibility = value;
-    }
-    /**
-     * Turns on/off dashmode
-     * @param value
+     * Gets the number of dashes in the line
      */
-    setUseDash(value) {
-        this._options.useDash = value;
+    get dashCount() {
+        return this._dashCount;
     }
     /**
-     * Sets the dash array.
-     * @param value dash array
+     * Sets the number of dashes in the line
+     * @param value dash
      */
-    setDashCount(value) {
-        this._options.dashCount = value;
+    set dashCount(value) {
+        this._dashCount = value;
         this._dashArray = 1 / value;
     }
     /**
-     * Sets the dash ratio
-     * @param value dash length ratio 0..1 (0.5 = half empty, half drawn)
+     * False means 1 unit in width = 1 unit on scene, true means 1 unit in width is reduced on the screen to make better looking lines
      */
-    setDashRatio(value) {
-        this._options.dashRatio = value;
+    get sizeAttenuation() {
+        return this._sizeAttenuation;
     }
     /**
-     * Sets the dash offset
-     * @param value the dashes will be offset by this value
+     * Turn on/off attenuation of the width option and widths array.
+     * @param value false means 1 unit in width = 1 unit on scene, true means 1 unit in width is reduced on the screen to make better looking lines
      */
-    setDashOffset(value) {
-        this._options.dashOffset = value;
+    set sizeAttenuation(value) {
+        this._sizeAttenuation = value;
+        this.markAllDefinesAsDirty();
     }
     /**
-     * Sets line base width. At each point the line width is calculated by widths[pointIndex] * width
-     * @param value base width
+     * Gets the color of the line
      */
-    setWidth(value) {
-        this._options.width = value;
+    get color() {
+        return this.color;
     }
     /**
-     * Turn on/off attenuation of the width option and widths array.
-     * @param value false means 1 unit in width = 1 unit on scene, true means 1 unit in width is reduced on the screen to make better looking lines
+     * Sets the color of the line
+     * @param value Color3 or null to clear the color. You need to clear the color if you use colors and useColors = true
      */
-    setSizeAttenuation(value) {
-        this._options.sizeAttenuation = value;
-        this.markAllDefinesAsDirty();
+    set color(value) {
+        this.setColor(value);
     }
     /**
      * Sets the color of the line. If set the whole line will be mixed with this color according to the colorMode option.
      * @param value color
      */
     setColor(value, doNotMarkDirty = false) {
-        if ((this._options.color === undefined && value !== undefined) || (this._options.color !== undefined && value === undefined)) {
-            this._options.color = value;
+        if ((this._color === null && value !== null) || (this._color !== null && value === null)) {
+            this._color = value;
             !doNotMarkDirty && this.markAllDefinesAsDirty();
         }
         else {
-            this._options.color = value;
+            this._color = value;
         }
     }
     /**
-     * Sets the mixing mode of the color paramater. Default value is GreasedLineMeshColorMode.SET
-     * @see GreasedLineMeshColorMode
-     * @param value color mode
+     * Gets the color distributiopn type
      */
-    setColorMode(value) {
-        this._options.colorMode = value;
+    get colorsDistributionType() {
+        return this._colorsDistributionType;
+    }
+    /**
+     * Sets the color distribution type
+     * @see GreasedLineMeshColorDistributionType
+     * @param value color distribution type
+     */
+    set colorsDistributionType(value) {
+        this._colorsDistributionType = value;
+        this.markAllDefinesAsDirty();
+    }
+    /**
+     * Gets the resolution
+     */
+    get resolution() {
+        return this._resolution;
+    }
+    /**
+     * Sets the resolution
+     * @param value resolution of the screen for GreasedLine
+     */
+    set resolution(value) {
+        this._aspect = value.x / value.y;
+        this._resolution = value;
     }
     /**
      * Serializes this plugin material
@@ -499,8 +545,23 @@ export class GreasedLinePluginMaterial extends MaterialPluginBase {
      */
     serialize() {
         const serializationObject = super.serialize();
-        serializationObject.materialOptions = {};
-        DeepCopier.DeepCopy(this._options, serializationObject.materialOptions);
+        const greasedLineMaterialOptions = {
+            colorDistributionType: this._colorsDistributionType,
+            colorsSampling: this.colorsSampling,
+            colorMode: this.colorMode,
+            dashCount: this._dashCount,
+            dashOffset: this.dashOffset,
+            dashRatio: this.dashRatio,
+            resolution: this._resolution,
+            sizeAttenuation: this._sizeAttenuation,
+            useColors: this.useColors,
+            useDash: this.useDash,
+            visibility: this.visibility,
+            width: this.width,
+        };
+        this._colors && (greasedLineMaterialOptions.colors = this._colors);
+        this._color && (greasedLineMaterialOptions.color = this._color);
+        serializationObject.greasedLineMaterialOptions = greasedLineMaterialOptions;
         return serializationObject;
     }
     /**
@@ -512,24 +573,27 @@ export class GreasedLinePluginMaterial extends MaterialPluginBase {
     parse(source, scene, rootUrl) {
         var _a;
         super.parse(source, scene, rootUrl);
-        this._options = source.materialOptions;
+        const greasedLineMaterialOptions = source.greasedLineMaterialOptions;
         (_a = this._colorsTexture) === null || _a === void 0 ? void 0 : _a.dispose();
-        if (this._options.colors) {
-            this._createColorsTexture(`${this._material.name}-colors-texture`, this._options.colors);
+        if (greasedLineMaterialOptions.colors) {
+            this._createColorsTexture(`${this._material.name}-colors-texture`, greasedLineMaterialOptions.colors);
         }
         else {
             GreasedLinePluginMaterial._PrepareEmptyColorsTexture(scene);
         }
-        this._options.color && this.setColor(this._options.color, true);
-        this._options.colorMode && this.setColorMode(this._options.colorMode);
-        this._options.useColors && this.setUseColors(this._options.useColors);
-        this._options.visibility && this.setVisibility(this._options.visibility);
-        this._options.useDash && this.setUseDash(this._options.useDash);
-        this._options.dashCount && this.setDashCount(this._options.dashCount);
-        this._options.dashRatio && this.setDashRatio(this._options.dashRatio);
-        this._options.dashOffset && this.setDashOffset(this._options.dashOffset);
-        this._options.width && this.setWidth(this._options.width);
-        this._options.sizeAttenuation && this.setSizeAttenuation(this._options.sizeAttenuation);
+        greasedLineMaterialOptions.color && this.setColor(greasedLineMaterialOptions.color, true);
+        greasedLineMaterialOptions.colorDistributionType && (this.colorsDistributionType = greasedLineMaterialOptions.colorDistributionType);
+        greasedLineMaterialOptions.colorsSampling && (this.colorsSampling = greasedLineMaterialOptions.colorsSampling);
+        greasedLineMaterialOptions.colorMode && (this.colorMode = greasedLineMaterialOptions.colorMode);
+        greasedLineMaterialOptions.useColors && (this.useColors = greasedLineMaterialOptions.useColors);
+        greasedLineMaterialOptions.visibility && (this.visibility = greasedLineMaterialOptions.visibility);
+        greasedLineMaterialOptions.useDash && (this.useDash = greasedLineMaterialOptions.useDash);
+        greasedLineMaterialOptions.dashCount && (this.dashCount = greasedLineMaterialOptions.dashCount);
+        greasedLineMaterialOptions.dashRatio && (this.dashRatio = greasedLineMaterialOptions.dashRatio);
+        greasedLineMaterialOptions.dashOffset && (this.dashOffset = greasedLineMaterialOptions.dashOffset);
+        greasedLineMaterialOptions.width && (this.width = greasedLineMaterialOptions.width);
+        greasedLineMaterialOptions.sizeAttenuation && (this.sizeAttenuation = greasedLineMaterialOptions.sizeAttenuation);
+        greasedLineMaterialOptions.resolution && (this.resolution = greasedLineMaterialOptions.resolution);
         this.markAllDefinesAsDirty();
     }
     /**
@@ -549,5 +613,17 @@ export class GreasedLinePluginMaterial extends MaterialPluginBase {
  * Plugin name
  */
 GreasedLinePluginMaterial.GREASED_LINE_MATERIAL_NAME = "GreasedLinePluginMaterial";
+/**
+ * Default line color for newly created lines
+ */
+GreasedLinePluginMaterial.DEFAULT_COLOR = Color3.White();
+/**
+ * Default line width when sizeAttenuation is true
+ */
+GreasedLinePluginMaterial.DEFAULT_WIDTH_ATTENUATED = 1;
+/**
+ * Defaule line width
+ */
+GreasedLinePluginMaterial.DEFAULT_WIDTH = 0.1;
 RegisterClass(`BABYLON.${GreasedLinePluginMaterial.GREASED_LINE_MATERIAL_NAME}`, GreasedLinePluginMaterial);
 //# sourceMappingURL=greasedLinePluginMaterial.js.map