@babylonjs/materials 9.15.0 → 9.16.1

package/grid/gridMaterial.js

@@ -1,4 +1,4 @@
-import { __decorate } from "@babylonjs/core/tslib.es6.js";
+import { __classPrivateFieldGet, __classPrivateFieldSet, __esDecorate, __runInitializers } from "@babylonjs/core/tslib.es6.js";
 /* eslint-disable @typescript-eslint/naming-convention */
 import { serializeAsTexture, serialize, expandToProperty, serializeAsColor3, serializeAsVector3 } from "@babylonjs/core/Misc/decorators.js";
 import { SerializationHelper } from "@babylonjs/core/Misc/decorators.serialization.js";
@@ -44,416 +44,471 @@ class GridMaterialDefines extends MaterialDefines {
  * The grid materials allows you to wrap any shape with a grid.
  * Colors are customizable.
  */
-export class GridMaterial extends PushMaterial {
-    /**
-     * Color of grid lines when the camera is below the surface.
-     * When set, lineColor acts as the above-surface color.
-     */
-    get belowLineColor() {
-        return this._belowLineColor;
-    }
-    set belowLineColor(value) {
-        if (this._belowLineColor === value) {
-            return;
-        }
-        this._belowLineColor = value;
-        this._markAllSubMeshesAsMiscDirty();
-    }
-    /**
-     * When true, only grid lines are visible — non-grid pixels are discarded.
-     * Puts the material in the alpha-blend queue and enables a depth pre-pass so grid lines
-     * correctly occlude translucent objects (e.g. Gaussian splats). Set mesh.alphaIndex to a
-     * value lower than other transparent objects so the depth pre-pass fires first.
-     */
-    get linesOnly() {
-        return this._linesOnly;
-    }
-    set linesOnly(value) {
-        if (this._linesOnly === value) {
-            return;
-        }
-        this._linesOnly = value;
-        this.needDepthPrePass = value;
-        this._markAllSubMeshesAsMiscDirty();
-    }
-    /**
-     * constructor
-     * @param name The name given to the material in order to identify it afterwards.
-     * @param scene The scene the material is used in.
-     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
-     */
-    constructor(name, scene, forceGLSL = false) {
-        super(name, scene, undefined, forceGLSL);
-        /**
-         * Main color of the grid (e.g. between lines)
-         */
-        this.mainColor = Color3.Black();
-        /**
-         * Color of the grid lines.
-         */
-        this.lineColor = Color3.Teal();
-        /**
-         * The scale of the grid compared to unit.
-         */
-        this.gridRatio = 1.0;
-        /**
-         * Allows setting an offset for the grid lines.
-         */
-        this.gridOffset = Vector3.Zero();
-        /**
-         * The frequency of thicker lines.
-         */
-        this.majorUnitFrequency = 10;
-        /**
-         * The visibility of minor units in the grid.
-         */
-        this.minorUnitVisibility = 0.33;
-        /**
-         * Overall mesh opacity. In linesOnly mode this also scales the maximum line alpha.
-         */
-        this.opacity = 1.0;
-        /**
-         * Whether to antialias the grid
-         */
-        this.antialias = true;
-        this._belowLineColor = null;
-        /**
-         * Enable multi-scale logarithmic grid LOD. Number of octaves is controlled by gridOctaves.
-         */
-        this.useMultiScale = false;
-        /**
-         * World-unit spacing of the finest octave. Default 0.001.
-         */
-        this.minGridSpacing = 0.001;
-        /**
-         * Number of logarithmic octaves rendered (1–8). Default 4.
-         */
-        this.gridOctaves = 4;
-        /**
-         * Enable camera-distance-aware horizon (grazing-angle) fade.
-         */
-        this.useHorizonFade = false;
-        /**
-         * Render an ultra-fine crosshair at the world origin.
-         */
-        this.useOriginMarker = false;
-        this._linesOnly = false;
-        /**
-         * Scales grid line width. Values \> 1 produce thicker lines. Default 1.0.
-         */
-        this.gridThicknessModifier = 1.0;
-        /**
-         * Determine RBG output is premultiplied by alpha value.
-         */
-        this.preMultiplyAlpha = false;
-        /**
-         * Determines if the max line value will be used instead of the sum wherever grid lines intersect.
-         */
-        this.useMaxLine = false;
-        this._gridControl = new Vector4(this.gridRatio, this.majorUnitFrequency, this.minorUnitVisibility, this.opacity);
-        this._viewportSize = new Vector2();
-        this._shadersLoaded = false;
-    }
-    /**
-     * @returns whether or not the grid requires alpha blending.
-     */
-    needAlphaBlending() {
-        return this.linesOnly || this.opacity < 1.0 || (this._opacityTexture && this._opacityTexture.isReady());
-    }
-    needAlphaBlendingForMesh(mesh) {
-        return mesh.visibility < 1.0 || this.needAlphaBlending();
-    }
-    isReadyForSubMesh(mesh, subMesh, useInstances) {
-        const drawWrapper = subMesh._drawWrapper;
-        if (this.isFrozen) {
-            if (drawWrapper.effect && drawWrapper._wasPreviouslyReady && drawWrapper._wasPreviouslyUsingInstances === useInstances) {
-                return true;
+let GridMaterial = (() => {
+    var _a, _GridMaterial_opacityTexture_accessor_storage;
+    let _classSuper = PushMaterial;
+    let _instanceExtraInitializers = [];
+    let _mainColor_decorators;
+    let _mainColor_initializers = [];
+    let _mainColor_extraInitializers = [];
+    let _lineColor_decorators;
+    let _lineColor_initializers = [];
+    let _lineColor_extraInitializers = [];
+    let _gridRatio_decorators;
+    let _gridRatio_initializers = [];
+    let _gridRatio_extraInitializers = [];
+    let _gridOffset_decorators;
+    let _gridOffset_initializers = [];
+    let _gridOffset_extraInitializers = [];
+    let _majorUnitFrequency_decorators;
+    let _majorUnitFrequency_initializers = [];
+    let _majorUnitFrequency_extraInitializers = [];
+    let _minorUnitVisibility_decorators;
+    let _minorUnitVisibility_initializers = [];
+    let _minorUnitVisibility_extraInitializers = [];
+    let _opacity_decorators;
+    let _opacity_initializers = [];
+    let _opacity_extraInitializers = [];
+    let _antialias_decorators;
+    let _antialias_initializers = [];
+    let _antialias_extraInitializers = [];
+    let _get_belowLineColor_decorators;
+    let _useMultiScale_decorators;
+    let _useMultiScale_initializers = [];
+    let _useMultiScale_extraInitializers = [];
+    let _minGridSpacing_decorators;
+    let _minGridSpacing_initializers = [];
+    let _minGridSpacing_extraInitializers = [];
+    let _gridOctaves_decorators;
+    let _gridOctaves_initializers = [];
+    let _gridOctaves_extraInitializers = [];
+    let _useHorizonFade_decorators;
+    let _useHorizonFade_initializers = [];
+    let _useHorizonFade_extraInitializers = [];
+    let _useOriginMarker_decorators;
+    let _useOriginMarker_initializers = [];
+    let _useOriginMarker_extraInitializers = [];
+    let _get_linesOnly_decorators;
+    let _gridThicknessModifier_decorators;
+    let _gridThicknessModifier_initializers = [];
+    let _gridThicknessModifier_extraInitializers = [];
+    let _preMultiplyAlpha_decorators;
+    let _preMultiplyAlpha_initializers = [];
+    let _preMultiplyAlpha_extraInitializers = [];
+    let _useMaxLine_decorators;
+    let _useMaxLine_initializers = [];
+    let _useMaxLine_extraInitializers = [];
+    let __opacityTexture_decorators;
+    let __opacityTexture_initializers = [];
+    let __opacityTexture_extraInitializers = [];
+    let _opacityTexture_decorators;
+    let _opacityTexture_initializers = [];
+    let _opacityTexture_extraInitializers = [];
+    return _a = class GridMaterial extends _classSuper {
+            /**
+             * Color of grid lines when the camera is below the surface.
+             * When set, lineColor acts as the above-surface color.
+             */
+            get belowLineColor() {
+                return this._belowLineColor;
             }
-        }
-        if (!subMesh.materialDefines) {
-            subMesh.materialDefines = new GridMaterialDefines();
-        }
-        const defines = subMesh.materialDefines;
-        const scene = this.getScene();
-        if (this._isReadyForSubMesh(subMesh)) {
-            return true;
-        }
-        if (defines.LINES_ONLY !== this.linesOnly) {
-            defines.LINES_ONLY = this.linesOnly;
-            defines.markAsUnprocessed();
-        }
-        if (defines.PREMULTIPLYALPHA != this.preMultiplyAlpha) {
-            defines.PREMULTIPLYALPHA = !defines.PREMULTIPLYALPHA;
-            defines.markAsUnprocessed();
-        }
-        if (defines.MAX_LINE !== this.useMaxLine) {
-            defines.MAX_LINE = !defines.MAX_LINE;
-            defines.markAsUnprocessed();
-        }
-        if (defines.ANTIALIAS !== this.antialias) {
-            defines.ANTIALIAS = this.antialias;
-            defines.markAsUnprocessed();
-        }
-        if (defines.MULTI_SCALE !== this.useMultiScale) {
-            defines.MULTI_SCALE = this.useMultiScale;
-            defines.markAsUnprocessed();
-        }
-        if (defines.HORIZON_FADE !== this.useHorizonFade) {
-            defines.HORIZON_FADE = this.useHorizonFade;
-            defines.markAsUnprocessed();
-        }
-        const wantsBelowColor = this._belowLineColor !== null;
-        if (defines.BELOW_LINE_COLOR !== wantsBelowColor) {
-            defines.BELOW_LINE_COLOR = wantsBelowColor;
-            defines.markAsUnprocessed();
-        }
-        if (defines.ORIGIN_MARKER !== this.useOriginMarker) {
-            defines.ORIGIN_MARKER = this.useOriginMarker;
-            defines.markAsUnprocessed();
-        }
-        // Textures
-        if (defines._areTexturesDirty) {
-            defines._needUVs = false;
-            if (scene.texturesEnabled) {
-                if (this._opacityTexture && MaterialFlags.OpacityTextureEnabled) {
-                    if (!this._opacityTexture.isReady()) {
-                        return false;
-                    }
-                    else {
-                        defines._needUVs = true;
-                        defines.OPACITY = true;
-                    }
+            set belowLineColor(value) {
+                if (this._belowLineColor === value) {
+                    return;
                 }
+                this._belowLineColor = value;
+                this._markAllSubMeshesAsMiscDirty();
             }
-        }
-        PrepareDefinesForMisc(mesh, scene, this._useLogarithmicDepth, false, this.fogEnabled, false, defines, undefined, undefined, undefined, this._isVertexOutputInvariant);
-        // Values that need to be evaluated on every frame
-        PrepareDefinesForFrameBoundValues(scene, scene.getEngine(), this, defines, !!useInstances);
-        // Get correct effect
-        if (defines.isDirty) {
-            defines.markAsProcessed();
-            scene.resetCachedMaterial();
-            // Attributes
-            PrepareDefinesForAttributes(mesh, defines, false, false);
-            const attribs = [VertexBuffer.PositionKind, VertexBuffer.NormalKind];
-            if (defines.UV1) {
-                attribs.push(VertexBuffer.UVKind);
+            /**
+             * When true, only grid lines are visible — non-grid pixels are discarded.
+             * Puts the material in the alpha-blend queue and enables a depth pre-pass so grid lines
+             * correctly occlude translucent objects (e.g. Gaussian splats). Set mesh.alphaIndex to a
+             * value lower than other transparent objects so the depth pre-pass fires first.
+             */
+            get linesOnly() {
+                return this._linesOnly;
             }
-            if (defines.UV2) {
-                attribs.push(VertexBuffer.UV2Kind);
+            set linesOnly(value) {
+                if (this._linesOnly === value) {
+                    return;
+                }
+                this._linesOnly = value;
+                this.needDepthPrePass = value;
+                this._markAllSubMeshesAsMiscDirty();
             }
-            defines.IMAGEPROCESSINGPOSTPROCESS = scene.imageProcessingConfiguration.applyByPostProcess;
-            PrepareAttributesForInstances(attribs, defines);
-            const uniforms = [
-                "projection",
-                "mainColor",
-                "lineColor",
-                "gridControl",
-                "gridOffset",
-                "vFogInfos",
-                "vFogColor",
-                "world",
-                "view",
-                "opacityMatrix",
-                "vOpacityInfos",
-                "visibility",
-                "logarithmicDepthConstant",
-                "gridThicknessModifier",
-            ];
-            if (defines.MULTI_SCALE) {
-                uniforms.push("minGridSpacing", "gridOctaves");
+            /**
+             * Texture to define opacity of the grid
+             */
+            get opacityTexture() { return __classPrivateFieldGet(this, _GridMaterial_opacityTexture_accessor_storage, "f"); }
+            set opacityTexture(value) { __classPrivateFieldSet(this, _GridMaterial_opacityTexture_accessor_storage, value, "f"); }
+            /**
+             * constructor
+             * @param name The name given to the material in order to identify it afterwards.
+             * @param scene The scene the material is used in.
+             * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+             */
+            constructor(name, scene, forceGLSL = false) {
+                super(name, scene, undefined, forceGLSL);
+                /**
+                 * Main color of the grid (e.g. between lines)
+                 */
+                this.mainColor = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _mainColor_initializers, Color3.Black()));
+                /**
+                 * Color of the grid lines.
+                 */
+                this.lineColor = (__runInitializers(this, _mainColor_extraInitializers), __runInitializers(this, _lineColor_initializers, Color3.Teal()));
+                /**
+                 * The scale of the grid compared to unit.
+                 */
+                this.gridRatio = (__runInitializers(this, _lineColor_extraInitializers), __runInitializers(this, _gridRatio_initializers, 1.0));
+                /**
+                 * Allows setting an offset for the grid lines.
+                 */
+                this.gridOffset = (__runInitializers(this, _gridRatio_extraInitializers), __runInitializers(this, _gridOffset_initializers, Vector3.Zero()));
+                /**
+                 * The frequency of thicker lines.
+                 */
+                this.majorUnitFrequency = (__runInitializers(this, _gridOffset_extraInitializers), __runInitializers(this, _majorUnitFrequency_initializers, 10));
+                /**
+                 * The visibility of minor units in the grid.
+                 */
+                this.minorUnitVisibility = (__runInitializers(this, _majorUnitFrequency_extraInitializers), __runInitializers(this, _minorUnitVisibility_initializers, 0.33));
+                /**
+                 * Overall mesh opacity. In linesOnly mode this also scales the maximum line alpha.
+                 */
+                this.opacity = (__runInitializers(this, _minorUnitVisibility_extraInitializers), __runInitializers(this, _opacity_initializers, 1.0));
+                /**
+                 * Whether to antialias the grid
+                 */
+                this.antialias = (__runInitializers(this, _opacity_extraInitializers), __runInitializers(this, _antialias_initializers, true));
+                this._belowLineColor = (__runInitializers(this, _antialias_extraInitializers), null);
+                /**
+                 * Enable multi-scale logarithmic grid LOD. Number of octaves is controlled by gridOctaves.
+                 */
+                this.useMultiScale = __runInitializers(this, _useMultiScale_initializers, false);
+                /**
+                 * World-unit spacing of the finest octave. Default 0.001.
+                 */
+                this.minGridSpacing = (__runInitializers(this, _useMultiScale_extraInitializers), __runInitializers(this, _minGridSpacing_initializers, 0.001));
+                /**
+                 * Number of logarithmic octaves rendered (1–8). Default 4.
+                 */
+                this.gridOctaves = (__runInitializers(this, _minGridSpacing_extraInitializers), __runInitializers(this, _gridOctaves_initializers, 4));
+                /**
+                 * Enable camera-distance-aware horizon (grazing-angle) fade.
+                 */
+                this.useHorizonFade = (__runInitializers(this, _gridOctaves_extraInitializers), __runInitializers(this, _useHorizonFade_initializers, false));
+                /**
+                 * Render an ultra-fine crosshair at the world origin.
+                 */
+                this.useOriginMarker = (__runInitializers(this, _useHorizonFade_extraInitializers), __runInitializers(this, _useOriginMarker_initializers, false));
+                this._linesOnly = (__runInitializers(this, _useOriginMarker_extraInitializers), false);
+                /**
+                 * Scales grid line width. Values \> 1 produce thicker lines. Default 1.0.
+                 */
+                this.gridThicknessModifier = __runInitializers(this, _gridThicknessModifier_initializers, 1.0);
+                /**
+                 * Determine RBG output is premultiplied by alpha value.
+                 */
+                this.preMultiplyAlpha = (__runInitializers(this, _gridThicknessModifier_extraInitializers), __runInitializers(this, _preMultiplyAlpha_initializers, false));
+                /**
+                 * Determines if the max line value will be used instead of the sum wherever grid lines intersect.
+                 */
+                this.useMaxLine = (__runInitializers(this, _preMultiplyAlpha_extraInitializers), __runInitializers(this, _useMaxLine_initializers, false));
+                this._opacityTexture = (__runInitializers(this, _useMaxLine_extraInitializers), __runInitializers(this, __opacityTexture_initializers, void 0));
+                _GridMaterial_opacityTexture_accessor_storage.set(this, (__runInitializers(this, __opacityTexture_extraInitializers), __runInitializers(this, _opacityTexture_initializers, void 0)));
+                this._gridControl = (__runInitializers(this, _opacityTexture_extraInitializers), new Vector4(this.gridRatio, this.majorUnitFrequency, this.minorUnitVisibility, this.opacity));
+                this._viewportSize = new Vector2();
+                this._shadersLoaded = false;
             }
-            if (defines.HORIZON_FADE || defines.BELOW_LINE_COLOR || defines.ORIGIN_MARKER) {
-                uniforms.push("cameraPosition", "viewportSize");
+            /**
+             * @returns whether or not the grid requires alpha blending.
+             */
+            needAlphaBlending() {
+                return this.linesOnly || this.opacity < 1.0 || (this._opacityTexture && this._opacityTexture.isReady());
             }
-            if (defines.BELOW_LINE_COLOR) {
-                uniforms.push("belowLineColor");
+            needAlphaBlendingForMesh(mesh) {
+                return mesh.visibility < 1.0 || this.needAlphaBlending();
             }
-            // Defines
-            const join = defines.toString();
-            AddClipPlaneUniforms(uniforms);
-            subMesh.setEffect(scene.getEngine().createEffect("grid", {
-                attributes: attribs,
-                uniformsNames: uniforms,
-                uniformBuffersNames: ["Scene"],
-                samplers: ["opacitySampler"],
-                defines: join,
-                fallbacks: null,
-                onCompiled: this.onCompiled,
-                onError: this.onError,
-                shaderLanguage: this._shaderLanguage,
-                extraInitializationsAsync: this._shadersLoaded
-                    ? undefined
-                    : async () => {
-                        if (this.shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
-                            await Promise.all([import("./wgsl/grid.vertex.js"), import("./wgsl/grid.fragment.js")]);
-                        }
-                        else {
-                            await Promise.all([import("./grid.vertex.js"), import("./grid.fragment.js")]);
+            isReadyForSubMesh(mesh, subMesh, useInstances) {
+                const drawWrapper = subMesh._drawWrapper;
+                if (this.isFrozen) {
+                    if (drawWrapper.effect && drawWrapper._wasPreviouslyReady && drawWrapper._wasPreviouslyUsingInstances === useInstances) {
+                        return true;
+                    }
+                }
+                if (!subMesh.materialDefines) {
+                    subMesh.materialDefines = new GridMaterialDefines();
+                }
+                const defines = subMesh.materialDefines;
+                const scene = this.getScene();
+                if (this._isReadyForSubMesh(subMesh)) {
+                    return true;
+                }
+                if (defines.LINES_ONLY !== this.linesOnly) {
+                    defines.LINES_ONLY = this.linesOnly;
+                    defines.markAsUnprocessed();
+                }
+                if (defines.PREMULTIPLYALPHA != this.preMultiplyAlpha) {
+                    defines.PREMULTIPLYALPHA = !defines.PREMULTIPLYALPHA;
+                    defines.markAsUnprocessed();
+                }
+                if (defines.MAX_LINE !== this.useMaxLine) {
+                    defines.MAX_LINE = !defines.MAX_LINE;
+                    defines.markAsUnprocessed();
+                }
+                if (defines.ANTIALIAS !== this.antialias) {
+                    defines.ANTIALIAS = this.antialias;
+                    defines.markAsUnprocessed();
+                }
+                if (defines.MULTI_SCALE !== this.useMultiScale) {
+                    defines.MULTI_SCALE = this.useMultiScale;
+                    defines.markAsUnprocessed();
+                }
+                if (defines.HORIZON_FADE !== this.useHorizonFade) {
+                    defines.HORIZON_FADE = this.useHorizonFade;
+                    defines.markAsUnprocessed();
+                }
+                const wantsBelowColor = this._belowLineColor !== null;
+                if (defines.BELOW_LINE_COLOR !== wantsBelowColor) {
+                    defines.BELOW_LINE_COLOR = wantsBelowColor;
+                    defines.markAsUnprocessed();
+                }
+                if (defines.ORIGIN_MARKER !== this.useOriginMarker) {
+                    defines.ORIGIN_MARKER = this.useOriginMarker;
+                    defines.markAsUnprocessed();
+                }
+                // Textures
+                if (defines._areTexturesDirty) {
+                    defines._needUVs = false;
+                    if (scene.texturesEnabled) {
+                        if (this._opacityTexture && MaterialFlags.OpacityTextureEnabled) {
+                            if (!this._opacityTexture.isReady()) {
+                                return false;
+                            }
+                            else {
+                                defines._needUVs = true;
+                                defines.OPACITY = true;
+                            }
                         }
-                        this._shadersLoaded = true;
-                    },
-            }, scene.getEngine()), defines, this._materialContext);
-        }
-        if (!subMesh.effect || !subMesh.effect.isReady()) {
-            return false;
-        }
-        defines._renderId = scene.getRenderId();
-        drawWrapper._wasPreviouslyReady = true;
-        drawWrapper._wasPreviouslyUsingInstances = !!useInstances;
-        return true;
-    }
-    bindForSubMesh(world, mesh, subMesh) {
-        const scene = this.getScene();
-        const defines = subMesh.materialDefines;
-        if (!defines) {
-            return;
-        }
-        const effect = subMesh.effect;
-        if (!effect) {
-            return;
-        }
-        this._activeEffect = effect;
-        this._activeEffect.setFloat("visibility", mesh.visibility);
-        // Matrices
-        if (!defines.INSTANCES || defines.THIN_INSTANCE) {
-            this.bindOnlyWorldMatrix(world);
-        }
-        this.bindView(effect);
-        this.bindViewProjection(effect);
-        // Uniforms
-        if (this._mustRebind(scene, effect, subMesh)) {
-            this._activeEffect.setColor3("mainColor", this.mainColor);
-            this._activeEffect.setColor3("lineColor", this.lineColor);
-            this._activeEffect.setVector3("gridOffset", this.gridOffset);
-            this._gridControl.x = this.gridRatio;
-            this._gridControl.y = Math.round(this.majorUnitFrequency);
-            this._gridControl.z = this.minorUnitVisibility;
-            this._gridControl.w = this.opacity;
-            this._activeEffect.setVector4("gridControl", this._gridControl);
-            this._activeEffect.setFloat("gridThicknessModifier", this.gridThicknessModifier);
-            if (defines.BELOW_LINE_COLOR && this._belowLineColor) {
-                this._activeEffect.setColor3("belowLineColor", this._belowLineColor);
+                    }
+                }
+                PrepareDefinesForMisc(mesh, scene, this._useLogarithmicDepth, false, this.fogEnabled, false, defines, undefined, undefined, undefined, this._isVertexOutputInvariant);
+                // Values that need to be evaluated on every frame
+                PrepareDefinesForFrameBoundValues(scene, scene.getEngine(), this, defines, !!useInstances);
+                // Get correct effect
+                if (defines.isDirty) {
+                    defines.markAsProcessed();
+                    scene.resetCachedMaterial();
+                    // Attributes
+                    PrepareDefinesForAttributes(mesh, defines, false, false);
+                    const attribs = [VertexBuffer.PositionKind, VertexBuffer.NormalKind];
+                    if (defines.UV1) {
+                        attribs.push(VertexBuffer.UVKind);
+                    }
+                    if (defines.UV2) {
+                        attribs.push(VertexBuffer.UV2Kind);
+                    }
+                    defines.IMAGEPROCESSINGPOSTPROCESS = scene.imageProcessingConfiguration.applyByPostProcess;
+                    PrepareAttributesForInstances(attribs, defines);
+                    const uniforms = [
+                        "projection",
+                        "mainColor",
+                        "lineColor",
+                        "gridControl",
+                        "gridOffset",
+                        "vFogInfos",
+                        "vFogColor",
+                        "world",
+                        "view",
+                        "opacityMatrix",
+                        "vOpacityInfos",
+                        "visibility",
+                        "logarithmicDepthConstant",
+                        "gridThicknessModifier",
+                    ];
+                    if (defines.MULTI_SCALE) {
+                        uniforms.push("minGridSpacing", "gridOctaves");
+                    }
+                    if (defines.HORIZON_FADE || defines.BELOW_LINE_COLOR || defines.ORIGIN_MARKER) {
+                        uniforms.push("cameraPosition", "viewportSize");
+                    }
+                    if (defines.BELOW_LINE_COLOR) {
+                        uniforms.push("belowLineColor");
+                    }
+                    // Defines
+                    const join = defines.toString();
+                    AddClipPlaneUniforms(uniforms);
+                    subMesh.setEffect(scene.getEngine().createEffect("grid", {
+                        attributes: attribs,
+                        uniformsNames: uniforms,
+                        uniformBuffersNames: ["Scene"],
+                        samplers: ["opacitySampler"],
+                        defines: join,
+                        fallbacks: null,
+                        onCompiled: this.onCompiled,
+                        onError: this.onError,
+                        shaderLanguage: this._shaderLanguage,
+                        extraInitializationsAsync: this._shadersLoaded
+                            ? undefined
+                            : async () => {
+                                if (this.shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
+                                    await Promise.all([import("./wgsl/grid.vertex.js"), import("./wgsl/grid.fragment.js")]);
+                                }
+                                else {
+                                    await Promise.all([import("./grid.vertex.js"), import("./grid.fragment.js")]);
+                                }
+                                this._shadersLoaded = true;
+                            },
+                    }, scene.getEngine()), defines, this._materialContext);
+                }
+                if (!subMesh.effect || !subMesh.effect.isReady()) {
+                    return false;
+                }
+                defines._renderId = scene.getRenderId();
+                drawWrapper._wasPreviouslyReady = true;
+                drawWrapper._wasPreviouslyUsingInstances = !!useInstances;
+                return true;
             }
-            if (defines.MULTI_SCALE) {
-                this._activeEffect.setFloat("minGridSpacing", this.minGridSpacing);
-                this._activeEffect.setFloat("gridOctaves", Math.max(1, Math.min(8, Math.round(this.gridOctaves))));
+            bindForSubMesh(world, mesh, subMesh) {
+                const scene = this.getScene();
+                const defines = subMesh.materialDefines;
+                if (!defines) {
+                    return;
+                }
+                const effect = subMesh.effect;
+                if (!effect) {
+                    return;
+                }
+                this._activeEffect = effect;
+                this._activeEffect.setFloat("visibility", mesh.visibility);
+                // Matrices
+                if (!defines.INSTANCES || defines.THIN_INSTANCE) {
+                    this.bindOnlyWorldMatrix(world);
+                }
+                this.bindView(effect);
+                this.bindViewProjection(effect);
+                // Uniforms
+                if (this._mustRebind(scene, effect, subMesh)) {
+                    this._activeEffect.setColor3("mainColor", this.mainColor);
+                    this._activeEffect.setColor3("lineColor", this.lineColor);
+                    this._activeEffect.setVector3("gridOffset", this.gridOffset);
+                    this._gridControl.x = this.gridRatio;
+                    this._gridControl.y = Math.round(this.majorUnitFrequency);
+                    this._gridControl.z = this.minorUnitVisibility;
+                    this._gridControl.w = this.opacity;
+                    this._activeEffect.setVector4("gridControl", this._gridControl);
+                    this._activeEffect.setFloat("gridThicknessModifier", this.gridThicknessModifier);
+                    if (defines.BELOW_LINE_COLOR && this._belowLineColor) {
+                        this._activeEffect.setColor3("belowLineColor", this._belowLineColor);
+                    }
+                    if (defines.MULTI_SCALE) {
+                        this._activeEffect.setFloat("minGridSpacing", this.minGridSpacing);
+                        this._activeEffect.setFloat("gridOctaves", Math.max(1, Math.min(8, Math.round(this.gridOctaves))));
+                    }
+                    if (this._opacityTexture && MaterialFlags.OpacityTextureEnabled) {
+                        this._activeEffect.setTexture("opacitySampler", this._opacityTexture);
+                        this._activeEffect.setFloat2("vOpacityInfos", this._opacityTexture.coordinatesIndex, this._opacityTexture.level);
+                        this._activeEffect.setMatrix("opacityMatrix", this._opacityTexture.getTextureMatrix());
+                    }
+                    // Clip plane
+                    BindClipPlane(effect, this, scene);
+                    // Log. depth
+                    if (this._useLogarithmicDepth) {
+                        BindLogDepth(defines, effect, scene);
+                    }
+                }
+                // Fog
+                BindFogParameters(scene, mesh, this._activeEffect);
+                // Camera uniforms — must be updated every frame
+                if (defines.HORIZON_FADE || defines.BELOW_LINE_COLOR || defines.ORIGIN_MARKER) {
+                    const cam = scene.activeCamera;
+                    if (cam) {
+                        this._activeEffect.setVector3("cameraPosition", cam.globalPosition);
+                        const engine = scene.getEngine();
+                        this._viewportSize.x = engine.getRenderWidth();
+                        this._viewportSize.y = engine.getRenderHeight();
+                        this._activeEffect.setVector2("viewportSize", this._viewportSize);
+                    }
+                }
+                this._afterBind(mesh, this._activeEffect, subMesh);
             }
-            if (this._opacityTexture && MaterialFlags.OpacityTextureEnabled) {
-                this._activeEffect.setTexture("opacitySampler", this._opacityTexture);
-                this._activeEffect.setFloat2("vOpacityInfos", this._opacityTexture.coordinatesIndex, this._opacityTexture.level);
-                this._activeEffect.setMatrix("opacityMatrix", this._opacityTexture.getTextureMatrix());
+            /**
+             * Dispose the material and its associated resources.
+             * @param forceDisposeEffect will also dispose the used effect when true
+             */
+            dispose(forceDisposeEffect) {
+                super.dispose(forceDisposeEffect);
             }
-            // Clip plane
-            BindClipPlane(effect, this, scene);
-            // Log. depth
-            if (this._useLogarithmicDepth) {
-                BindLogDepth(defines, effect, scene);
+            clone(name) {
+                return SerializationHelper.Clone(() => new _a(name, this.getScene()), this);
             }
-        }
-        // Fog
-        BindFogParameters(scene, mesh, this._activeEffect);
-        // Camera uniforms — must be updated every frame
-        if (defines.HORIZON_FADE || defines.BELOW_LINE_COLOR || defines.ORIGIN_MARKER) {
-            const cam = scene.activeCamera;
-            if (cam) {
-                this._activeEffect.setVector3("cameraPosition", cam.globalPosition);
-                const engine = scene.getEngine();
-                this._viewportSize.x = engine.getRenderWidth();
-                this._viewportSize.y = engine.getRenderHeight();
-                this._activeEffect.setVector2("viewportSize", this._viewportSize);
+            serialize() {
+                const serializationObject = super.serialize();
+                serializationObject.customType = "BABYLON.GridMaterial";
+                return serializationObject;
             }
-        }
-        this._afterBind(mesh, this._activeEffect, subMesh);
-    }
-    /**
-     * Dispose the material and its associated resources.
-     * @param forceDisposeEffect will also dispose the used effect when true
-     */
-    dispose(forceDisposeEffect) {
-        super.dispose(forceDisposeEffect);
-    }
-    clone(name) {
-        return SerializationHelper.Clone(() => new GridMaterial(name, this.getScene()), this);
-    }
-    serialize() {
-        const serializationObject = super.serialize();
-        serializationObject.customType = "BABYLON.GridMaterial";
-        return serializationObject;
-    }
-    getClassName() {
-        return "GridMaterial";
-    }
-    /**
-     * Parse a JSON input to create back a grid material.
-     * @param source the JSON data to parse
-     * @param scene defines the hosting scene
-     * @param rootUrl defines the root URL to use to load textures and relative dependencies
-     * @returns a new grid material
-     */
-    static Parse(source, scene, rootUrl) {
-        return SerializationHelper.Parse(() => new GridMaterial(source.name, scene), source, scene, rootUrl);
-    }
-}
-__decorate([
-    serializeAsColor3()
-], GridMaterial.prototype, "mainColor", void 0);
-__decorate([
-    serializeAsColor3()
-], GridMaterial.prototype, "lineColor", void 0);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "gridRatio", void 0);
-__decorate([
-    serializeAsVector3()
-], GridMaterial.prototype, "gridOffset", void 0);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "majorUnitFrequency", void 0);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "minorUnitVisibility", void 0);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "opacity", void 0);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "antialias", void 0);
-__decorate([
-    serializeAsColor3()
-], GridMaterial.prototype, "belowLineColor", null);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "useMultiScale", void 0);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "minGridSpacing", void 0);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "gridOctaves", void 0);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "useHorizonFade", void 0);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "useOriginMarker", void 0);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "linesOnly", null);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "gridThicknessModifier", void 0);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "preMultiplyAlpha", void 0);
-__decorate([
-    serialize()
-], GridMaterial.prototype, "useMaxLine", void 0);
-__decorate([
-    serializeAsTexture("opacityTexture")
-], GridMaterial.prototype, "_opacityTexture", void 0);
-__decorate([
-    expandToProperty("_markAllSubMeshesAsTexturesDirty")
-], GridMaterial.prototype, "opacityTexture", void 0);
+            getClassName() {
+                return "GridMaterial";
+            }
+            /**
+             * Parse a JSON input to create back a grid material.
+             * @param source the JSON data to parse
+             * @param scene defines the hosting scene
+             * @param rootUrl defines the root URL to use to load textures and relative dependencies
+             * @returns a new grid material
+             */
+            static Parse(source, scene, rootUrl) {
+                return SerializationHelper.Parse(() => new _a(source.name, scene), source, scene, rootUrl);
+            }
+        },
+        _GridMaterial_opacityTexture_accessor_storage = new WeakMap(),
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _mainColor_decorators = [serializeAsColor3()];
+            _lineColor_decorators = [serializeAsColor3()];
+            _gridRatio_decorators = [serialize()];
+            _gridOffset_decorators = [serializeAsVector3()];
+            _majorUnitFrequency_decorators = [serialize()];
+            _minorUnitVisibility_decorators = [serialize()];
+            _opacity_decorators = [serialize()];
+            _antialias_decorators = [serialize()];
+            _get_belowLineColor_decorators = [serializeAsColor3()];
+            _useMultiScale_decorators = [serialize()];
+            _minGridSpacing_decorators = [serialize()];
+            _gridOctaves_decorators = [serialize()];
+            _useHorizonFade_decorators = [serialize()];
+            _useOriginMarker_decorators = [serialize()];
+            _get_linesOnly_decorators = [serialize()];
+            _gridThicknessModifier_decorators = [serialize()];
+            _preMultiplyAlpha_decorators = [serialize()];
+            _useMaxLine_decorators = [serialize()];
+            __opacityTexture_decorators = [serializeAsTexture("opacityTexture")];
+            _opacityTexture_decorators = [expandToProperty("_markAllSubMeshesAsTexturesDirty")];
+            __esDecorate(_a, null, _get_belowLineColor_decorators, { kind: "getter", name: "belowLineColor", static: false, private: false, access: { has: obj => "belowLineColor" in obj, get: obj => obj.belowLineColor }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _get_linesOnly_decorators, { kind: "getter", name: "linesOnly", static: false, private: false, access: { has: obj => "linesOnly" in obj, get: obj => obj.linesOnly }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _opacityTexture_decorators, { kind: "accessor", name: "opacityTexture", static: false, private: false, access: { has: obj => "opacityTexture" in obj, get: obj => obj.opacityTexture, set: (obj, value) => { obj.opacityTexture = value; } }, metadata: _metadata }, _opacityTexture_initializers, _opacityTexture_extraInitializers);
+            __esDecorate(null, null, _mainColor_decorators, { kind: "field", name: "mainColor", static: false, private: false, access: { has: obj => "mainColor" in obj, get: obj => obj.mainColor, set: (obj, value) => { obj.mainColor = value; } }, metadata: _metadata }, _mainColor_initializers, _mainColor_extraInitializers);
+            __esDecorate(null, null, _lineColor_decorators, { kind: "field", name: "lineColor", static: false, private: false, access: { has: obj => "lineColor" in obj, get: obj => obj.lineColor, set: (obj, value) => { obj.lineColor = value; } }, metadata: _metadata }, _lineColor_initializers, _lineColor_extraInitializers);
+            __esDecorate(null, null, _gridRatio_decorators, { kind: "field", name: "gridRatio", static: false, private: false, access: { has: obj => "gridRatio" in obj, get: obj => obj.gridRatio, set: (obj, value) => { obj.gridRatio = value; } }, metadata: _metadata }, _gridRatio_initializers, _gridRatio_extraInitializers);
+            __esDecorate(null, null, _gridOffset_decorators, { kind: "field", name: "gridOffset", static: false, private: false, access: { has: obj => "gridOffset" in obj, get: obj => obj.gridOffset, set: (obj, value) => { obj.gridOffset = value; } }, metadata: _metadata }, _gridOffset_initializers, _gridOffset_extraInitializers);
+            __esDecorate(null, null, _majorUnitFrequency_decorators, { kind: "field", name: "majorUnitFrequency", static: false, private: false, access: { has: obj => "majorUnitFrequency" in obj, get: obj => obj.majorUnitFrequency, set: (obj, value) => { obj.majorUnitFrequency = value; } }, metadata: _metadata }, _majorUnitFrequency_initializers, _majorUnitFrequency_extraInitializers);
+            __esDecorate(null, null, _minorUnitVisibility_decorators, { kind: "field", name: "minorUnitVisibility", static: false, private: false, access: { has: obj => "minorUnitVisibility" in obj, get: obj => obj.minorUnitVisibility, set: (obj, value) => { obj.minorUnitVisibility = value; } }, metadata: _metadata }, _minorUnitVisibility_initializers, _minorUnitVisibility_extraInitializers);
+            __esDecorate(null, null, _opacity_decorators, { kind: "field", name: "opacity", static: false, private: false, access: { has: obj => "opacity" in obj, get: obj => obj.opacity, set: (obj, value) => { obj.opacity = value; } }, metadata: _metadata }, _opacity_initializers, _opacity_extraInitializers);
+            __esDecorate(null, null, _antialias_decorators, { kind: "field", name: "antialias", static: false, private: false, access: { has: obj => "antialias" in obj, get: obj => obj.antialias, set: (obj, value) => { obj.antialias = value; } }, metadata: _metadata }, _antialias_initializers, _antialias_extraInitializers);
+            __esDecorate(null, null, _useMultiScale_decorators, { kind: "field", name: "useMultiScale", static: false, private: false, access: { has: obj => "useMultiScale" in obj, get: obj => obj.useMultiScale, set: (obj, value) => { obj.useMultiScale = value; } }, metadata: _metadata }, _useMultiScale_initializers, _useMultiScale_extraInitializers);
+            __esDecorate(null, null, _minGridSpacing_decorators, { kind: "field", name: "minGridSpacing", static: false, private: false, access: { has: obj => "minGridSpacing" in obj, get: obj => obj.minGridSpacing, set: (obj, value) => { obj.minGridSpacing = value; } }, metadata: _metadata }, _minGridSpacing_initializers, _minGridSpacing_extraInitializers);
+            __esDecorate(null, null, _gridOctaves_decorators, { kind: "field", name: "gridOctaves", static: false, private: false, access: { has: obj => "gridOctaves" in obj, get: obj => obj.gridOctaves, set: (obj, value) => { obj.gridOctaves = value; } }, metadata: _metadata }, _gridOctaves_initializers, _gridOctaves_extraInitializers);
+            __esDecorate(null, null, _useHorizonFade_decorators, { kind: "field", name: "useHorizonFade", static: false, private: false, access: { has: obj => "useHorizonFade" in obj, get: obj => obj.useHorizonFade, set: (obj, value) => { obj.useHorizonFade = value; } }, metadata: _metadata }, _useHorizonFade_initializers, _useHorizonFade_extraInitializers);
+            __esDecorate(null, null, _useOriginMarker_decorators, { kind: "field", name: "useOriginMarker", static: false, private: false, access: { has: obj => "useOriginMarker" in obj, get: obj => obj.useOriginMarker, set: (obj, value) => { obj.useOriginMarker = value; } }, metadata: _metadata }, _useOriginMarker_initializers, _useOriginMarker_extraInitializers);
+            __esDecorate(null, null, _gridThicknessModifier_decorators, { kind: "field", name: "gridThicknessModifier", static: false, private: false, access: { has: obj => "gridThicknessModifier" in obj, get: obj => obj.gridThicknessModifier, set: (obj, value) => { obj.gridThicknessModifier = value; } }, metadata: _metadata }, _gridThicknessModifier_initializers, _gridThicknessModifier_extraInitializers);
+            __esDecorate(null, null, _preMultiplyAlpha_decorators, { kind: "field", name: "preMultiplyAlpha", static: false, private: false, access: { has: obj => "preMultiplyAlpha" in obj, get: obj => obj.preMultiplyAlpha, set: (obj, value) => { obj.preMultiplyAlpha = value; } }, metadata: _metadata }, _preMultiplyAlpha_initializers, _preMultiplyAlpha_extraInitializers);
+            __esDecorate(null, null, _useMaxLine_decorators, { kind: "field", name: "useMaxLine", static: false, private: false, access: { has: obj => "useMaxLine" in obj, get: obj => obj.useMaxLine, set: (obj, value) => { obj.useMaxLine = value; } }, metadata: _metadata }, _useMaxLine_initializers, _useMaxLine_extraInitializers);
+            __esDecorate(null, null, __opacityTexture_decorators, { kind: "field", name: "_opacityTexture", static: false, private: false, access: { has: obj => "_opacityTexture" in obj, get: obj => obj._opacityTexture, set: (obj, value) => { obj._opacityTexture = value; } }, metadata: _metadata }, __opacityTexture_initializers, __opacityTexture_extraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { GridMaterial };
 RegisterClass("BABYLON.GridMaterial", GridMaterial);
 //# sourceMappingURL=gridMaterial.js.map