babylonjs-materials 9.4.0 → 9.5.0

package/babylonjs.materials.module.d.ts

@@ -30,8 +30,6 @@ import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
 import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
-import "babylonjs-materials/water/water.fragment";
-import "babylonjs-materials/water/water.vertex";
 import "babylonjs/Rendering/boundingBoxRenderer";
 export class WaterMaterial extends PushMaterial {
     renderTargetSize: Vector2;
@@ -123,6 +121,7 @@ export class WaterMaterial extends PushMaterial {
     private _offsetMirror;
     private _tempPlane;
     private _lastTime;
+    private _shadersLoaded;
     private _lastDeltaTime;
     private _waitingRenderList;
     private _imageProcessingConfiguration;
@@ -136,8 +135,9 @@ export class WaterMaterial extends PushMaterial {
      * @param name
      * @param scene
      * @param renderTargetSize
+     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
      */
-    constructor(name: string, scene?: Scene, renderTargetSize?: Vector2);
+    constructor(name: string, scene?: Scene, renderTargetSize?: Vector2, forceGLSL?: boolean);
     get refractionTexture(): Nullable<RenderTargetTexture>;
     get reflectionTexture(): Nullable<RenderTargetTexture>;
     addToRenderList(node: any): void;
@@ -212,6 +212,51 @@ export const waterPixelShader: {
 declare module "babylonjs-materials/water/index" {
 export * from "babylonjs-materials/water/waterMaterial";
 
+}
+declare module "babylonjs-materials/water/wgsl/water.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimation";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/vertexColorMixing";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+/** @internal */
+export const waterVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/water/wgsl/water.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/helperFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+/** @internal */
+export const waterPixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 declare module "babylonjs-materials/triPlanar/triplanar.vertex" {
 import "babylonjs/Shaders/ShadersInclude/helperFunctions";
@@ -271,8 +316,6 @@ import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
 import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
-import "babylonjs-materials/triPlanar/triplanar.fragment";
-import "babylonjs-materials/triPlanar/triplanar.vertex";
 export class TriPlanarMaterial extends PushMaterial {
     mixTexture: BaseTexture;
     private _diffuseTextureX;
@@ -295,7 +338,14 @@ export class TriPlanarMaterial extends PushMaterial {
     disableLighting: boolean;
     private _maxSimultaneousLights;
     maxSimultaneousLights: number;
-    constructor(name: string, scene?: Scene);
+    private _shadersLoaded;
+    /**
+     * Instantiates a TriPlanar Material in the given scene
+     * @param name The friendly name of the material
+     * @param scene The scene to add the material to
+     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+     */
+    constructor(name: string, scene?: Scene, forceGLSL?: boolean);
     needAlphaBlending(): boolean;
     needAlphaTesting(): boolean;
     getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -315,6 +365,52 @@ export class TriPlanarMaterial extends PushMaterial {
 declare module "babylonjs-materials/triPlanar/index" {
 export * from "babylonjs-materials/triPlanar/triPlanarMaterial";
 
+}
+declare module "babylonjs-materials/triPlanar/wgsl/triplanar.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/helperFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimation";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/vertexColorMixing";
+/** @internal */
+export const triplanarVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/triPlanar/wgsl/triplanar.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/helperFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/depthPrePass";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingCompatibility";
+/** @internal */
+export const triplanarPixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 declare module "babylonjs-materials/terrain/terrainMaterial" {
 import { Nullable } from "babylonjs/types";
@@ -328,8 +424,6 @@ import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
 import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
-import "babylonjs-materials/terrain/terrain.fragment";
-import "babylonjs-materials/terrain/terrain.vertex";
 export class TerrainMaterial extends PushMaterial {
     private _mixTexture;
     mixTexture: BaseTexture;
@@ -352,7 +446,14 @@ export class TerrainMaterial extends PushMaterial {
     disableLighting: boolean;
     private _maxSimultaneousLights;
     maxSimultaneousLights: number;
-    constructor(name: string, scene?: Scene);
+    private _shadersLoaded;
+    /**
+     * Instantiates a Terrain Material in the given scene
+     * @param name The friendly name of the material
+     * @param scene The scene to add the material to
+     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+     */
+    constructor(name: string, scene?: Scene, forceGLSL?: boolean);
     needAlphaBlending(): boolean;
     needAlphaTesting(): boolean;
     getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -418,6 +519,51 @@ export const terrainPixelShader: {
 declare module "babylonjs-materials/terrain/index" {
 export * from "babylonjs-materials/terrain/terrainMaterial";
 
+}
+declare module "babylonjs-materials/terrain/wgsl/terrain.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimation";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/vertexColorMixing";
+/** @internal */
+export const terrainVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/terrain/wgsl/terrain.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/helperFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/depthPrePass";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingCompatibility";
+/** @internal */
+export const terrainPixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 declare module "babylonjs-materials/sky/skyMaterial" {
 import { Nullable } from "babylonjs/types";
@@ -429,8 +575,6 @@ import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
 import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
-import "babylonjs-materials/sky/sky.fragment";
-import "babylonjs-materials/sky/sky.vertex";
 /**
  * This is the sky material which allows to create dynamic and texture free effects for skyboxes.
  * @see https://doc.babylonjs.com/toolsAndResources/assetLibraries/materialsLibrary/skyMat
@@ -495,6 +639,7 @@ export class SkyMaterial extends PushMaterial {
     dithering: boolean;
     private _cameraPosition;
     private _skyOrientation;
+    private _shadersLoaded;
     /**
      * Instantiates a new sky material.
      * This material allows to create dynamic and texture free
@@ -502,8 +647,9 @@ export class SkyMaterial extends PushMaterial {
      * @see https://doc.babylonjs.com/toolsAndResources/assetLibraries/materialsLibrary/skyMat
      * @param name Define the name of the material in the scene
      * @param scene Define the scene the material belong to
+     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
      */
-    constructor(name: string, scene?: Scene);
+    constructor(name: string, scene?: Scene, forceGLSL?: boolean);
     /**
      * Specifies if the material will require alpha blending
      * @returns a boolean specifying if alpha blending is needed
@@ -605,6 +751,36 @@ export const skyPixelShader: {
 declare module "babylonjs-materials/sky/index" {
 export * from "babylonjs-materials/sky/skyMaterial";
 
+}
+declare module "babylonjs-materials/sky/wgsl/sky.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+/** @internal */
+export const skyVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/sky/wgsl/sky.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/helperFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingCompatibility";
+/** @internal */
+export const skyPixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 declare module "babylonjs-materials/simple/simpleMaterial" {
 import { Nullable } from "babylonjs/types";
@@ -617,8 +793,6 @@ import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
 import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
-import "babylonjs-materials/simple/simple.fragment";
-import "babylonjs-materials/simple/simple.vertex";
 export class SimpleMaterial extends PushMaterial {
     private _diffuseTexture;
     diffuseTexture: BaseTexture;
@@ -627,7 +801,14 @@ export class SimpleMaterial extends PushMaterial {
     disableLighting: boolean;
     private _maxSimultaneousLights;
     maxSimultaneousLights: number;
-    constructor(name: string, scene?: Scene);
+    private _shadersLoaded;
+    /**
+     * Instantiates a Simple Material in the given scene
+     * @param name The friendly name of the material
+     * @param scene The scene to add the material to
+     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+     */
+    constructor(name: string, scene?: Scene, forceGLSL?: boolean);
     needAlphaBlending(): boolean;
     needAlphaTesting(): boolean;
     getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -693,6 +874,51 @@ export const simplePixelShader: {
 declare module "babylonjs-materials/simple/index" {
 export * from "babylonjs-materials/simple/simpleMaterial";
 
+}
+declare module "babylonjs-materials/simple/wgsl/simple.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimation";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/vertexColorMixing";
+/** @internal */
+export const simpleVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/simple/wgsl/simple.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/helperFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/depthPrePass";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingCompatibility";
+/** @internal */
+export const simplePixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 declare module "babylonjs-materials/shadowOnly/shadowOnlyMaterial" {
 import { Nullable } from "babylonjs/types";
@@ -705,12 +931,17 @@ import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
 import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
-import "babylonjs-materials/shadowOnly/shadowOnly.fragment";
-import "babylonjs-materials/shadowOnly/shadowOnly.vertex";
 export class ShadowOnlyMaterial extends PushMaterial {
     private _activeLight;
     private _needAlphaBlending;
-    constructor(name: string, scene?: Scene);
+    private _shadersLoaded;
+    /**
+     * Instantiates a ShadowOnly Material in the given scene
+     * @param name The friendly name of the material
+     * @param scene The scene to add the material to
+     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+     */
+    constructor(name: string, scene?: Scene, forceGLSL?: boolean);
     shadowColor: Color3;
     needAlphaBlending(): boolean;
     needAlphaTesting(): boolean;
@@ -778,6 +1009,50 @@ export const shadowOnlyPixelShader: {
 declare module "babylonjs-materials/shadowOnly/index" {
 export * from "babylonjs-materials/shadowOnly/shadowOnlyMaterial";
 
+}
+declare module "babylonjs-materials/shadowOnly/wgsl/shadowOnly.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/sceneUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimation";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsVertex";
+/** @internal */
+export const shadowOnlyVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/shadowOnly/wgsl/shadowOnly.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/sceneUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/helperFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+/** @internal */
+export const shadowOnlyPixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 declare module "babylonjs-materials/normal/normalMaterial" {
 import { Nullable } from "babylonjs/types";
@@ -790,8 +1065,6 @@ import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
 import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
-import "babylonjs-materials/normal/normal.fragment";
-import "babylonjs-materials/normal/normal.vertex";
 export class NormalMaterial extends PushMaterial {
     private _diffuseTexture;
     diffuseTexture: BaseTexture;
@@ -800,7 +1073,14 @@ export class NormalMaterial extends PushMaterial {
     disableLighting: boolean;
     private _maxSimultaneousLights;
     maxSimultaneousLights: number;
-    constructor(name: string, scene?: Scene);
+    private _shadersLoaded;
+    /**
+     * Instantiates a Normal Material in the given scene
+     * @param name The friendly name of the material
+     * @param scene The scene to add the material to
+     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+     */
+    constructor(name: string, scene?: Scene, forceGLSL?: boolean);
     needAlphaBlending(): boolean;
     needAlphaBlendingForMesh(mesh: AbstractMesh): boolean;
     needAlphaTesting(): boolean;
@@ -866,6 +1146,50 @@ export const normalPixelShader: {
 declare module "babylonjs-materials/normal/index" {
 export * from "babylonjs-materials/normal/normalMaterial";
 
+}
+declare module "babylonjs-materials/normal/wgsl/normal.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimation";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsVertex";
+/** @internal */
+export const normalVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/normal/wgsl/normal.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/helperFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/depthPrePass";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingCompatibility";
+/** @internal */
+export const normalPixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 declare module "babylonjs-materials/mix/mixMaterial" {
 import { Nullable } from "babylonjs/types";
@@ -879,8 +1203,6 @@ import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
 import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
-import "babylonjs-materials/mix/mix.fragment";
-import "babylonjs-materials/mix/mix.vertex";
 export class MixMaterial extends PushMaterial {
     /**
      * Mix textures
@@ -918,7 +1240,14 @@ export class MixMaterial extends PushMaterial {
     disableLighting: boolean;
     private _maxSimultaneousLights;
     maxSimultaneousLights: number;
-    constructor(name: string, scene?: Scene);
+    private _shadersLoaded;
+    /**
+     * Instantiates a Mix Material in the given scene
+     * @param name The friendly name of the material
+     * @param scene The scene to add the material to
+     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+     */
+    constructor(name: string, scene?: Scene, forceGLSL?: boolean);
     needAlphaBlending(): boolean;
     needAlphaTesting(): boolean;
     getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -984,6 +1313,51 @@ export const mixPixelShader: {
 declare module "babylonjs-materials/mix/index" {
 export * from "babylonjs-materials/mix/mixMaterial";
 
+}
+declare module "babylonjs-materials/mix/wgsl/mix.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimation";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/vertexColorMixing";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+/** @internal */
+export const mixVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/mix/wgsl/mix.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/helperFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/depthPrePass";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingCompatibility";
+/** @internal */
+export const mixPixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 declare module "babylonjs-materials/legacy/legacy" {
 export * from "babylonjs-materials/index";
@@ -1060,8 +1434,6 @@ import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
 import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
-import "babylonjs-materials/lava/lava.fragment";
-import "babylonjs-materials/lava/lava.vertex";
 export class LavaMaterial extends PushMaterial {
     private _diffuseTexture;
     diffuseTexture: BaseTexture;
@@ -1080,7 +1452,14 @@ export class LavaMaterial extends PushMaterial {
     private _maxSimultaneousLights;
     maxSimultaneousLights: number;
     private _scaledDiffuse;
-    constructor(name: string, scene?: Scene);
+    private _shadersLoaded;
+    /**
+     * Instantiates a Lava Material in the given scene
+     * @param name The friendly name of the material
+     * @param scene The scene to add the material to
+     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+     */
+    constructor(name: string, scene?: Scene, forceGLSL?: boolean);
     needAlphaBlending(): boolean;
     needAlphaTesting(): boolean;
     getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -1146,6 +1525,51 @@ export const lavaPixelShader: {
 declare module "babylonjs-materials/lava/index" {
 export * from "babylonjs-materials/lava/lavaMaterial";
 
+}
+declare module "babylonjs-materials/lava/wgsl/lava.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimation";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/vertexColorMixing";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+/** @internal */
+export const lavaVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/lava/wgsl/lava.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/helperFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/depthPrePass";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingCompatibility";
+/** @internal */
+export const lavaPixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 declare module "babylonjs-materials/grid/index" {
 export * from "babylonjs-materials/grid/gridMaterial";
@@ -1160,8 +1584,6 @@ import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
 import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
-import "babylonjs-materials/grid/grid.fragment";
-import "babylonjs-materials/grid/grid.vertex";
 /**
  * The grid materials allows you to wrap any shape with a grid.
  * Colors are customizable.
@@ -1217,8 +1639,10 @@ export class GridMaterial extends PushMaterial {
      * 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: string, scene?: Scene);
+    constructor(name: string, scene?: Scene, forceGLSL?: boolean);
+    private _shadersLoaded;
     /**
      * @returns whether or not the grid requires alpha blending.
      */
@@ -1270,6 +1694,38 @@ export const gridPixelShader: {
     shader: string;
 };
 
+}
+declare module "babylonjs-materials/grid/wgsl/grid.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/sceneUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+/** @internal */
+export const gridVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/grid/wgsl/grid.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingCompatibility";
+/** @internal */
+export const gridPixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 declare module "babylonjs-materials/gradient/index" {
 export * from "babylonjs-materials/gradient/gradientMaterial";
@@ -1286,8 +1742,6 @@ import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
 import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
-import "babylonjs-materials/gradient/gradient.fragment";
-import "babylonjs-materials/gradient/gradient.vertex";
 export class GradientMaterial extends PushMaterial {
     private _maxSimultaneousLights;
     maxSimultaneousLights: number;
@@ -1300,7 +1754,14 @@ export class GradientMaterial extends PushMaterial {
     smoothness: number;
     private _disableLighting;
     disableLighting: boolean;
-    constructor(name: string, scene?: Scene);
+    private _shadersLoaded;
+    /**
+     * Instantiates a Gradient Material in the given scene
+     * @param name The friendly name of the material
+     * @param scene The scene to add the material to
+     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+     */
+    constructor(name: string, scene?: Scene, forceGLSL?: boolean);
     needAlphaBlending(): boolean;
     needAlphaTesting(): boolean;
     getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -1360,6 +1821,51 @@ export const gradientPixelShader: {
     shader: string;
 };
 
+}
+declare module "babylonjs-materials/gradient/wgsl/gradient.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimation";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/vertexColorMixing";
+/** @internal */
+export const gradientVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/gradient/wgsl/gradient.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/helperFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/depthPrePass";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingCompatibility";
+/** @internal */
+export const gradientPixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 declare module "babylonjs-materials/fur/index" {
 export * from "babylonjs-materials/fur/furMaterial";
@@ -1377,8 +1883,6 @@ import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
 import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
-import "babylonjs-materials/fur/fur.fragment";
-import "babylonjs-materials/fur/fur.vertex";
 export class FurMaterial extends PushMaterial {
     private _diffuseTexture;
     diffuseTexture: BaseTexture;
@@ -1402,7 +1906,14 @@ export class FurMaterial extends PushMaterial {
     highLevelFur: boolean;
     _meshes: AbstractMesh[];
     private _furTime;
-    constructor(name: string, scene?: Scene);
+    private _shadersLoaded;
+    /**
+     * Instantiates a Fur Material in the given scene
+     * @param name The friendly name of the material
+     * @param scene The scene to add the material to
+     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+     */
+    constructor(name: string, scene?: Scene, forceGLSL?: boolean);
     get furTime(): number;
     set furTime(furTime: number);
     needAlphaBlending(): boolean;
@@ -1469,6 +1980,51 @@ export const furPixelShader: {
     shader: string;
 };
 
+}
+declare module "babylonjs-materials/fur/wgsl/fur.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimation";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/vertexColorMixing";
+/** @internal */
+export const furVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/fur/wgsl/fur.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/helperFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/depthPrePass";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingCompatibility";
+/** @internal */
+export const furPixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 declare module "babylonjs-materials/fire/index" {
 export * from "babylonjs-materials/fire/fireMaterial";
@@ -1485,8 +2041,6 @@ import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
 import { IAnimatable } from "babylonjs/Animations/animatable.interface";
-import "babylonjs-materials/fire/fire.fragment";
-import "babylonjs-materials/fire/fire.vertex";
 export class FireMaterial extends PushMaterial {
     private _diffuseTexture;
     diffuseTexture: Nullable<BaseTexture>;
@@ -1498,7 +2052,14 @@ export class FireMaterial extends PushMaterial {
     speed: number;
     private _scaledDiffuse;
     private _lastTime;
-    constructor(name: string, scene?: Scene);
+    private _shadersLoaded;
+    /**
+     * Instantiates a Fire Material in the given scene
+     * @param name The friendly name of the material
+     * @param scene The scene to add the material to
+     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+     */
+    constructor(name: string, scene?: Scene, forceGLSL?: boolean);
     needAlphaBlending(): boolean;
     needAlphaTesting(): boolean;
     getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -1551,6 +2112,43 @@ export const firePixelShader: {
     shader: string;
 };
 
+}
+declare module "babylonjs-materials/fire/wgsl/fire.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimation";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/vertexColorMixing";
+/** @internal */
+export const fireVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/fire/wgsl/fire.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/depthPrePass";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingCompatibility";
+/** @internal */
+export const firePixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 declare module "babylonjs-materials/custom/pbrCustomMaterial" {
 import { Texture } from "babylonjs/Materials/Textures/texture";
@@ -2157,8 +2755,6 @@ import { SubMesh } from "babylonjs/Meshes/subMesh";
 import { Mesh } from "babylonjs/Meshes/mesh";
 import { Scene } from "babylonjs/scene";
 import { IAnimatable } from "babylonjs/Animations/animatable.interface";
-import "babylonjs-materials/cell/cell.fragment";
-import "babylonjs-materials/cell/cell.vertex";
 export class CellMaterial extends PushMaterial {
     private _diffuseTexture;
     diffuseTexture: BaseTexture;
@@ -2169,7 +2765,14 @@ export class CellMaterial extends PushMaterial {
     disableLighting: boolean;
     private _maxSimultaneousLights;
     maxSimultaneousLights: number;
-    constructor(name: string, scene?: Scene);
+    private _shadersLoaded;
+    /**
+     * Instantiates a Cell Material in the given scene
+     * @param name The friendly name of the material
+     * @param scene The scene to add the material to
+     * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+     */
+    constructor(name: string, scene?: Scene, forceGLSL?: boolean);
     needAlphaBlending(): boolean;
     needAlphaTesting(): boolean;
     getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -2231,6 +2834,51 @@ export const cellPixelShader: {
     shader: string;
 };
 
+}
+declare module "babylonjs-materials/cell/wgsl/cell.vertex" {
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertexDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightVxUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/instancesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bonesVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/bakedVertexAnimation";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsVertex";
+import "babylonjs/ShadersWGSL/ShadersInclude/vertexColorMixing";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthVertex";
+/** @internal */
+export const cellVertexShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-materials/cell/wgsl/cell.fragment" {
+import "babylonjs/ShadersWGSL/ShadersInclude/helperFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightUboDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/shadowsFragmentFunctions";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragmentDeclaration";
+import "babylonjs/ShadersWGSL/ShadersInclude/clipPlaneFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/depthPrePass";
+import "babylonjs/ShadersWGSL/ShadersInclude/lightFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/logDepthFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/fogFragment";
+import "babylonjs/ShadersWGSL/ShadersInclude/imageProcessingCompatibility";
+/** @internal */
+export const cellPixelShaderWGSL: {
+    name: string;
+    shader: string;
+};
+
 }
 
 declare module "babylonjs-materials" {
@@ -2331,6 +2979,7 @@ declare namespace BABYLON {
         private _offsetMirror;
         private _tempPlane;
         private _lastTime;
+        private _shadersLoaded;
         private _lastDeltaTime;
         private _waitingRenderList;
         private _imageProcessingConfiguration;
@@ -2344,8 +2993,9 @@ declare namespace BABYLON {
          * @param name
          * @param scene
          * @param renderTargetSize
+         * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
          */
-        constructor(name: string, scene?: Scene, renderTargetSize?: Vector2);
+        constructor(name: string, scene?: Scene, renderTargetSize?: Vector2, forceGLSL?: boolean);
         get refractionTexture(): Nullable<RenderTargetTexture>;
         get reflectionTexture(): Nullable<RenderTargetTexture>;
         addToRenderList(node: any): void;
@@ -2387,6 +3037,20 @@ declare namespace BABYLON {
 
 
 
+    /** @internal */
+    export var waterVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var waterPixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
     /** @internal */
     export var triplanarVertexShader: {
         name: string;
@@ -2423,7 +3087,14 @@ declare namespace BABYLON {
         disableLighting: boolean;
         private _maxSimultaneousLights;
         maxSimultaneousLights: number;
-        constructor(name: string, scene?: Scene);
+        private _shadersLoaded;
+        /**
+         * Instantiates a TriPlanar Material in the given scene
+         * @param name The friendly name of the material
+         * @param scene The scene to add the material to
+         * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+         */
+        constructor(name: string, scene?: Scene, forceGLSL?: boolean);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -2442,6 +3113,20 @@ declare namespace BABYLON {
 
 
 
+    /** @internal */
+    export var triplanarVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var triplanarPixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
     export class TerrainMaterial extends PushMaterial {
         private _mixTexture;
         mixTexture: BaseTexture;
@@ -2464,7 +3149,14 @@ declare namespace BABYLON {
         disableLighting: boolean;
         private _maxSimultaneousLights;
         maxSimultaneousLights: number;
-        constructor(name: string, scene?: Scene);
+        private _shadersLoaded;
+        /**
+         * Instantiates a Terrain Material in the given scene
+         * @param name The friendly name of the material
+         * @param scene The scene to add the material to
+         * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+         */
+        constructor(name: string, scene?: Scene, forceGLSL?: boolean);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -2497,6 +3189,20 @@ declare namespace BABYLON {
 
 
 
+    /** @internal */
+    export var terrainVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var terrainPixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
     /**
      * This is the sky material which allows to create dynamic and texture free effects for skyboxes.
      * @see https://doc.babylonjs.com/toolsAndResources/assetLibraries/materialsLibrary/skyMat
@@ -2561,6 +3267,7 @@ declare namespace BABYLON {
         dithering: boolean;
         private _cameraPosition;
         private _skyOrientation;
+        private _shadersLoaded;
         /**
          * Instantiates a new sky material.
          * This material allows to create dynamic and texture free
@@ -2568,8 +3275,9 @@ declare namespace BABYLON {
          * @see https://doc.babylonjs.com/toolsAndResources/assetLibraries/materialsLibrary/skyMat
          * @param name Define the name of the material in the scene
          * @param scene Define the scene the material belong to
+         * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
          */
-        constructor(name: string, scene?: Scene);
+        constructor(name: string, scene?: Scene, forceGLSL?: boolean);
         /**
          * Specifies if the material will require alpha blending
          * @returns a boolean specifying if alpha blending is needed
@@ -2654,6 +3362,20 @@ declare namespace BABYLON {
 
 
 
+    /** @internal */
+    export var skyVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var skyPixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
     export class SimpleMaterial extends PushMaterial {
         private _diffuseTexture;
         diffuseTexture: BaseTexture;
@@ -2662,7 +3384,14 @@ declare namespace BABYLON {
         disableLighting: boolean;
         private _maxSimultaneousLights;
         maxSimultaneousLights: number;
-        constructor(name: string, scene?: Scene);
+        private _shadersLoaded;
+        /**
+         * Instantiates a Simple Material in the given scene
+         * @param name The friendly name of the material
+         * @param scene The scene to add the material to
+         * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+         */
+        constructor(name: string, scene?: Scene, forceGLSL?: boolean);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -2695,10 +3424,31 @@ declare namespace BABYLON {
 
 
 
+    /** @internal */
+    export var simpleVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var simplePixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
     export class ShadowOnlyMaterial extends PushMaterial {
         private _activeLight;
         private _needAlphaBlending;
-        constructor(name: string, scene?: Scene);
+        private _shadersLoaded;
+        /**
+         * Instantiates a ShadowOnly Material in the given scene
+         * @param name The friendly name of the material
+         * @param scene The scene to add the material to
+         * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+         */
+        constructor(name: string, scene?: Scene, forceGLSL?: boolean);
         shadowColor: Color3;
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
@@ -2731,6 +3481,20 @@ declare namespace BABYLON {
 
 
 
+    /** @internal */
+    export var shadowOnlyVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var shadowOnlyPixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
     export class NormalMaterial extends PushMaterial {
         private _diffuseTexture;
         diffuseTexture: BaseTexture;
@@ -2739,7 +3503,14 @@ declare namespace BABYLON {
         disableLighting: boolean;
         private _maxSimultaneousLights;
         maxSimultaneousLights: number;
-        constructor(name: string, scene?: Scene);
+        private _shadersLoaded;
+        /**
+         * Instantiates a Normal Material in the given scene
+         * @param name The friendly name of the material
+         * @param scene The scene to add the material to
+         * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+         */
+        constructor(name: string, scene?: Scene, forceGLSL?: boolean);
         needAlphaBlending(): boolean;
         needAlphaBlendingForMesh(mesh: AbstractMesh): boolean;
         needAlphaTesting(): boolean;
@@ -2773,6 +3544,20 @@ declare namespace BABYLON {
 
 
 
+    /** @internal */
+    export var normalVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var normalPixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
     export class MixMaterial extends PushMaterial {
         /**
          * Mix textures
@@ -2810,7 +3595,14 @@ declare namespace BABYLON {
         disableLighting: boolean;
         private _maxSimultaneousLights;
         maxSimultaneousLights: number;
-        constructor(name: string, scene?: Scene);
+        private _shadersLoaded;
+        /**
+         * Instantiates a Mix Material in the given scene
+         * @param name The friendly name of the material
+         * @param scene The scene to add the material to
+         * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+         */
+        constructor(name: string, scene?: Scene, forceGLSL?: boolean);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -2843,6 +3635,20 @@ declare namespace BABYLON {
 
 
 
+    /** @internal */
+    export var mixVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var mixPixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
 
 
 
@@ -2891,7 +3697,14 @@ declare namespace BABYLON {
         private _maxSimultaneousLights;
         maxSimultaneousLights: number;
         private _scaledDiffuse;
-        constructor(name: string, scene?: Scene);
+        private _shadersLoaded;
+        /**
+         * Instantiates a Lava Material in the given scene
+         * @param name The friendly name of the material
+         * @param scene The scene to add the material to
+         * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+         */
+        constructor(name: string, scene?: Scene, forceGLSL?: boolean);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -2924,6 +3737,20 @@ declare namespace BABYLON {
 
 
 
+    /** @internal */
+    export var lavaVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var lavaPixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
 
 
     /**
@@ -2981,8 +3808,10 @@ declare namespace BABYLON {
          * 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: string, scene?: Scene);
+        constructor(name: string, scene?: Scene, forceGLSL?: boolean);
+        private _shadersLoaded;
         /**
          * @returns whether or not the grid requires alpha blending.
          */
@@ -3016,6 +3845,20 @@ declare namespace BABYLON {
     };
 
 
+    /** @internal */
+    export var gridVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var gridPixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
 
 
     export class GradientMaterial extends PushMaterial {
@@ -3030,7 +3873,14 @@ declare namespace BABYLON {
         smoothness: number;
         private _disableLighting;
         disableLighting: boolean;
-        constructor(name: string, scene?: Scene);
+        private _shadersLoaded;
+        /**
+         * Instantiates a Gradient Material in the given scene
+         * @param name The friendly name of the material
+         * @param scene The scene to add the material to
+         * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+         */
+        constructor(name: string, scene?: Scene, forceGLSL?: boolean);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -3059,6 +3909,20 @@ declare namespace BABYLON {
     };
 
 
+    /** @internal */
+    export var gradientVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var gradientPixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
 
 
     export class FurMaterial extends PushMaterial {
@@ -3084,7 +3948,14 @@ declare namespace BABYLON {
         highLevelFur: boolean;
         _meshes: AbstractMesh[];
         private _furTime;
-        constructor(name: string, scene?: Scene);
+        private _shadersLoaded;
+        /**
+         * Instantiates a Fur Material in the given scene
+         * @param name The friendly name of the material
+         * @param scene The scene to add the material to
+         * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+         */
+        constructor(name: string, scene?: Scene, forceGLSL?: boolean);
         get furTime(): number;
         set furTime(furTime: number);
         needAlphaBlending(): boolean;
@@ -3120,6 +3991,20 @@ declare namespace BABYLON {
     };
 
 
+    /** @internal */
+    export var furVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var furPixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
 
 
     export class FireMaterial extends PushMaterial {
@@ -3133,7 +4018,14 @@ declare namespace BABYLON {
         speed: number;
         private _scaledDiffuse;
         private _lastTime;
-        constructor(name: string, scene?: Scene);
+        private _shadersLoaded;
+        /**
+         * Instantiates a Fire Material in the given scene
+         * @param name The friendly name of the material
+         * @param scene The scene to add the material to
+         * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+         */
+        constructor(name: string, scene?: Scene, forceGLSL?: boolean);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -3164,6 +4056,20 @@ declare namespace BABYLON {
     };
 
 
+    /** @internal */
+    export var fireVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var firePixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
     /**
      * Albedo parts of the shader
      */
@@ -3740,7 +4646,14 @@ declare namespace BABYLON {
         disableLighting: boolean;
         private _maxSimultaneousLights;
         maxSimultaneousLights: number;
-        constructor(name: string, scene?: Scene);
+        private _shadersLoaded;
+        /**
+         * Instantiates a Cell Material in the given scene
+         * @param name The friendly name of the material
+         * @param scene The scene to add the material to
+         * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
+         */
+        constructor(name: string, scene?: Scene, forceGLSL?: boolean);
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;
@@ -3771,6 +4684,20 @@ declare namespace BABYLON {
     };
 
 
+    /** @internal */
+    export var cellVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var cellPixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
 
 }