@babylonjs/core 9.8.0 → 9.9.1

package/Materials/Textures/texture.pure.js

@@ -70,22 +70,7 @@ export class Texture extends BaseTexture {
      * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)
      * @param forcedExtension defines the extension to use to pick the right loader
      */
-    constructor(
-        url,
-        sceneOrEngine,
-        noMipmapOrOptions,
-        invertY,
-        samplingMode = Texture.TRILINEAR_SAMPLINGMODE,
-        onLoad = null,
-        onError = null,
-        buffer = null,
-        deleteBuffer = false,
-        format,
-        mimeType,
-        loaderOptions,
-        creationFlags,
-        forcedExtension
-    ) {
+    constructor(url, sceneOrEngine, noMipmapOrOptions, invertY, samplingMode = Texture.TRILINEAR_SAMPLINGMODE, onLoad = null, onError = null, buffer = null, deleteBuffer = false, format, mimeType, loaderOptions, creationFlags, forcedExtension) {
         super(sceneOrEngine);
         /**
          * Define the url of the texture.
@@ -212,7 +197,8 @@ export class Texture extends BaseTexture {
             internalTexture = noMipmapOrOptions.internalTexture ?? null;
             gammaSpace = noMipmapOrOptions.gammaSpace ?? gammaSpace;
             forcedExtension = noMipmapOrOptions.forcedExtension ?? forcedExtension;
-        } else {
+        }
+        else {
             noMipmap = !!noMipmapOrOptions;
         }
         this._gammaSpace = gammaSpace;
@@ -282,39 +268,27 @@ export class Texture extends BaseTexture {
         if (!this._texture) {
             if (!scene || !scene.useDelayedTextureLoading) {
                 try {
-                    this._texture = engine.createTexture(
-                        this.url,
-                        noMipmap,
-                        this._invertY,
-                        scene,
-                        samplingMode,
-                        load,
-                        errorHandler,
-                        this._buffer,
-                        undefined,
-                        this._format,
-                        this._forcedExtension,
-                        mimeType,
-                        loaderOptions,
-                        creationFlags,
-                        useSRGBBuffer
-                    );
-                } catch (e) {
+                    this._texture = engine.createTexture(this.url, noMipmap, this._invertY, scene, samplingMode, load, errorHandler, this._buffer, undefined, this._format, this._forcedExtension, mimeType, loaderOptions, creationFlags, useSRGBBuffer);
+                }
+                catch (e) {
                     errorHandler("error loading", e);
                     throw e;
                 }
                 if (deleteBuffer) {
                     this._buffer = null;
                 }
-            } else {
+            }
+            else {
                 this.delayLoadState = 4;
                 this._delayedOnLoad = load;
                 this._delayedOnError = errorHandler;
             }
-        } else {
+        }
+        else {
             if (this._texture.isReady) {
                 TimingTools.SetImmediate(() => load());
-            } else {
+            }
+            else {
                 const loadObserver = this._texture.onLoadedObservable.add(load);
                 this._texture.onErrorObservable.add((e) => {
                     errorHandler(e.message, e.exception);
@@ -348,7 +322,8 @@ export class Texture extends BaseTexture {
         const load = () => {
             if (existingOnLoad) {
                 existingOnLoad();
-            } else if (this.onLoadObservable.hasObservers()) {
+            }
+            else if (this.onLoadObservable.hasObservers()) {
                 this.onLoadObservable.notifyObservers(this);
             }
             if (onLoad) {
@@ -382,31 +357,17 @@ export class Texture extends BaseTexture {
         if (!this._texture) {
             this._texture = scene
                 .getEngine()
-                .createTexture(
-                    url,
-                    this._noMipmap,
-                    this._invertY,
-                    scene,
-                    this.samplingMode,
-                    this._delayedOnLoad,
-                    this._delayedOnError,
-                    this._buffer,
-                    null,
-                    this._format,
-                    this._forcedExtension,
-                    this._mimeType,
-                    this._loaderOptions,
-                    this._creationFlags,
-                    this._useSRGBBuffer
-                );
+                .createTexture(url, this._noMipmap, this._invertY, scene, this.samplingMode, this._delayedOnLoad, this._delayedOnError, this._buffer, null, this._format, this._forcedExtension, this._mimeType, this._loaderOptions, this._creationFlags, this._useSRGBBuffer);
             if (this._deleteBuffer) {
                 this._buffer = null;
             }
-        } else {
+        }
+        else {
             if (this._delayedOnLoad) {
                 if (this._texture.isReady) {
                     TimingTools.SetImmediate(this._delayedOnLoad);
-                } else {
+                }
+                else {
                     this._texture.onLoadedObservable.add(this._delayedOnLoad);
                 }
             }
@@ -431,8 +392,7 @@ export class Texture extends BaseTexture {
      * @returns the transform matrix of the texture.
      */
     getTextureMatrix(uBase = 1) {
-        if (
-            this.uOffset === this._cachedUOffset &&
+        if (this.uOffset === this._cachedUOffset &&
             this.vOffset === this._cachedVOffset &&
             this.uScale * uBase === this._cachedUScale &&
             this.vScale === this._cachedVScale &&
@@ -442,8 +402,7 @@ export class Texture extends BaseTexture {
             this.uRotationCenter === this._cachedURotationCenter &&
             this.vRotationCenter === this._cachedVRotationCenter &&
             this.wRotationCenter === this._cachedWRotationCenter &&
-            this.homogeneousRotationInUVTransform === this._cachedHomogeneousRotationInUVTransform
-        ) {
+            this.homogeneousRotationInUVTransform === this._cachedHomogeneousRotationInUVTransform) {
             return this._cachedTextureMatrix;
         }
         this._cachedUOffset = this.uOffset;
@@ -476,31 +435,14 @@ export class Texture extends BaseTexture {
             this._cachedTextureMatrix.multiplyToRef(TmpVectors.Matrix[3], this._cachedTextureMatrix);
             // copy the translation row to the 3rd row of the matrix so that we don't need to update the shaders (which expects the translation to be on the 3rd row)
             this._cachedTextureMatrix.setRowFromFloats(2, this._cachedTextureMatrix.m[12], this._cachedTextureMatrix.m[13], this._cachedTextureMatrix.m[14], 1);
-        } else {
+        }
+        else {
             this._prepareRowForTextureGeneration(0, 0, 0, this._t0);
             this._prepareRowForTextureGeneration(1.0, 0, 0, this._t1);
             this._prepareRowForTextureGeneration(0, 1.0, 0, this._t2);
             this._t1.subtractInPlace(this._t0);
             this._t2.subtractInPlace(this._t0);
-            Matrix.FromValuesToRef(
-                this._t1.x,
-                this._t1.y,
-                this._t1.z,
-                0.0,
-                this._t2.x,
-                this._t2.y,
-                this._t2.z,
-                0.0,
-                this._t0.x,
-                this._t0.y,
-                this._t0.z,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                1.0,
-                this._cachedTextureMatrix
-            );
+            Matrix.FromValuesToRef(this._t1.x, this._t1.y, this._t1.z, 0.0, this._t2.x, this._t2.y, this._t2.z, 0.0, this._t0.x, this._t0.y, this._t0.z, 0.0, 0.0, 0.0, 0.0, 1.0, this._cachedTextureMatrix);
         }
         const scene = this.getScene();
         if (!scene) {
@@ -526,18 +468,17 @@ export class Texture extends BaseTexture {
         if (!scene) {
             return this._cachedReflectionTextureMatrix;
         }
-        if (
-            this.uOffset === this._cachedReflectionUOffset &&
+        if (this.uOffset === this._cachedReflectionUOffset &&
             this.vOffset === this._cachedReflectionVOffset &&
             this.uScale === this._cachedReflectionUScale &&
             this.vScale === this._cachedReflectionVScale &&
-            this.coordinatesMode === this._cachedReflectionCoordinatesMode
-        ) {
+            this.coordinatesMode === this._cachedReflectionCoordinatesMode) {
             if (this.coordinatesMode === Texture.PROJECTION_MODE) {
                 if (this._cachedReflectionProjectionMatrixId === scene.getProjectionMatrix().updateFlag) {
                     return this._cachedReflectionTextureMatrix;
                 }
-            } else {
+            }
+            else {
                 return this._cachedReflectionTextureMatrix;
             }
         }
@@ -627,10 +568,12 @@ export class Texture extends BaseTexture {
             if (typeof this._buffer === "string" && this._buffer.startsWith("data:")) {
                 serializationObject.base64String = this._buffer;
                 serializationObject.name = serializationObject.name.replace("data:", "");
-            } else if (this.url && this.url.startsWith("data:") && this._buffer instanceof Uint8Array) {
+            }
+            else if (this.url && this.url.startsWith("data:") && this._buffer instanceof Uint8Array) {
                 const mimeType = this.mimeType || "image/png";
                 serializationObject.base64String = `data:${mimeType};base64,${EncodeArrayBufferToBase64(this._buffer)}`;
-            } else if (Texture.ForceSerializeBuffers || (this.url && this.url.startsWith("blob:")) || this._forceSerialize) {
+            }
+            else if (Texture.ForceSerializeBuffers || (this.url && this.url.startsWith("blob:")) || this._forceSerialize) {
                 serializationObject.base64String =
                     !this._engine || this._engine._features.supportSyncTextureRead ? GenerateBase64StringFromTexture(this) : GenerateBase64StringFromTextureAsync(this);
             }
@@ -731,104 +674,92 @@ export class Texture extends BaseTexture {
                 texture._texture.label = parsedTexture.internalTextureLabel;
             }
         };
-        const texture = SerializationHelper.Parse(
-            () => {
-                let generateMipMaps = true;
-                if (parsedTexture.noMipmap) {
-                    generateMipMaps = false;
-                }
-                if (parsedTexture.mirrorPlane) {
-                    const mirrorTexture = Texture._CreateMirror(parsedTexture.name, parsedTexture.renderTargetSize, scene, generateMipMaps);
-                    mirrorTexture._waitingRenderList = parsedTexture.renderList;
-                    mirrorTexture.mirrorPlane = Plane.FromArray(parsedTexture.mirrorPlane);
-                    onLoaded(mirrorTexture);
-                    return mirrorTexture;
-                } else if (parsedTexture.isRenderTarget && !parsedTexture.base64String) {
-                    // if base64string is set it means the original RTT was baked
-                    let renderTargetTexture = null;
-                    if (parsedTexture.isCube) {
-                        // Search for an existing reflection probe (which contains a cube render target texture)
-                        if (scene.reflectionProbes) {
-                            for (let index = 0; index < scene.reflectionProbes.length; index++) {
-                                const probe = scene.reflectionProbes[index];
-                                if (probe.name === parsedTexture.name) {
-                                    return probe.cubeTexture;
-                                }
+        const texture = SerializationHelper.Parse(() => {
+            let generateMipMaps = true;
+            if (parsedTexture.noMipmap) {
+                generateMipMaps = false;
+            }
+            if (parsedTexture.mirrorPlane) {
+                const mirrorTexture = Texture._CreateMirror(parsedTexture.name, parsedTexture.renderTargetSize, scene, generateMipMaps);
+                mirrorTexture._waitingRenderList = parsedTexture.renderList;
+                mirrorTexture.mirrorPlane = Plane.FromArray(parsedTexture.mirrorPlane);
+                onLoaded(mirrorTexture);
+                return mirrorTexture;
+            }
+            else if (parsedTexture.isRenderTarget && !parsedTexture.base64String) {
+                // if base64string is set it means the original RTT was baked
+                let renderTargetTexture = null;
+                if (parsedTexture.isCube) {
+                    // Search for an existing reflection probe (which contains a cube render target texture)
+                    if (scene.reflectionProbes) {
+                        for (let index = 0; index < scene.reflectionProbes.length; index++) {
+                            const probe = scene.reflectionProbes[index];
+                            if (probe.name === parsedTexture.name) {
+                                return probe.cubeTexture;
                             }
                         }
-                    } else {
-                        renderTargetTexture = Texture._CreateRenderTargetTexture(
-                            parsedTexture.name,
-                            parsedTexture.renderTargetSize,
-                            scene,
-                            generateMipMaps,
-                            parsedTexture._creationFlags ?? 0
-                        );
-                        renderTargetTexture._waitingRenderList = parsedTexture.renderList;
                     }
-                    onLoaded(renderTargetTexture);
-                    return renderTargetTexture;
-                } else if (parsedTexture.isVideo) {
-                    const texture = Texture._CreateVideoTexture(
-                        rootUrl + (parsedTexture.url || parsedTexture.name),
-                        rootUrl + (parsedTexture.src || parsedTexture.url),
-                        scene,
-                        generateMipMaps,
-                        parsedTexture.invertY,
-                        parsedTexture.samplingMode,
-                        parsedTexture.settings || {}
-                    );
-                    onLoaded(texture);
-                    return texture;
-                } else {
-                    let texture;
-                    if (typeof parsedTexture.base64String === "string" && parsedTexture.base64String && !internalTexture) {
-                        const options = {
-                            buffer: parsedTexture.base64String,
-                            noMipmap: !generateMipMaps,
-                            invertY: parsedTexture.invertY,
-                            samplingMode: parsedTexture.samplingMode,
-                            useSRGBBuffer: parsedTexture._useSRGBBuffer ?? false,
-                            creationFlags: parsedTexture._creationFlags ?? 0,
-                            onLoad: () => {
-                                onLoaded(texture);
-                            },
-                        };
-                        // use the base64 string as the texture name for caching; the actual payload comes from options.buffer
-                        const base64String = parsedTexture.base64String;
-                        const noPrefixBase64String = base64String.startsWith("data:") ? base64String.substring(5) : base64String;
-                        texture = Texture.CreateFromBase64String("", noPrefixBase64String, scene, options);
-                        // prettier name to fit with the loaded data
-                        texture.name = parsedTexture.name;
-                    } else {
-                        let url;
-                        if (parsedTexture.name && (parsedTexture.name.indexOf("://") > 0 || parsedTexture.name.startsWith("data:"))) {
-                            url = parsedTexture.name;
-                        } else {
-                            url = rootUrl + parsedTexture.name;
-                        }
-                        if (parsedTexture.url && (parsedTexture.url.startsWith("data:") || Texture.UseSerializedUrlIfAny)) {
-                            url = parsedTexture.url;
-                        }
-                        const options = {
-                            noMipmap: !generateMipMaps,
-                            invertY: parsedTexture.invertY,
-                            samplingMode: parsedTexture.samplingMode,
-                            useSRGBBuffer: parsedTexture._useSRGBBuffer ?? false,
-                            creationFlags: parsedTexture._creationFlags ?? 0,
-                            onLoad: () => {
-                                onLoaded(texture);
-                            },
-                            internalTexture,
-                        };
-                        texture = new Texture(url, scene, options);
+                }
+                else {
+                    renderTargetTexture = Texture._CreateRenderTargetTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene, generateMipMaps, parsedTexture._creationFlags ?? 0);
+                    renderTargetTexture._waitingRenderList = parsedTexture.renderList;
+                }
+                onLoaded(renderTargetTexture);
+                return renderTargetTexture;
+            }
+            else if (parsedTexture.isVideo) {
+                const texture = Texture._CreateVideoTexture(rootUrl + (parsedTexture.url || parsedTexture.name), rootUrl + (parsedTexture.src || parsedTexture.url), scene, generateMipMaps, parsedTexture.invertY, parsedTexture.samplingMode, parsedTexture.settings || {});
+                onLoaded(texture);
+                return texture;
+            }
+            else {
+                let texture;
+                if (typeof parsedTexture.base64String === "string" && parsedTexture.base64String && !internalTexture) {
+                    const options = {
+                        buffer: parsedTexture.base64String,
+                        noMipmap: !generateMipMaps,
+                        invertY: parsedTexture.invertY,
+                        samplingMode: parsedTexture.samplingMode,
+                        useSRGBBuffer: parsedTexture._useSRGBBuffer ?? false,
+                        creationFlags: parsedTexture._creationFlags ?? 0,
+                        onLoad: () => {
+                            onLoaded(texture);
+                        },
+                    };
+                    // use the base64 string as the texture name for caching; the actual payload comes from options.buffer
+                    const base64String = parsedTexture.base64String;
+                    const noPrefixBase64String = base64String.startsWith("data:") ? base64String.substring(5) : base64String;
+                    texture = Texture.CreateFromBase64String("", noPrefixBase64String, scene, options);
+                    // prettier name to fit with the loaded data
+                    texture.name = parsedTexture.name;
+                }
+                else {
+                    let url;
+                    if (parsedTexture.name && (parsedTexture.name.indexOf("://") > 0 || parsedTexture.name.startsWith("data:"))) {
+                        url = parsedTexture.name;
                     }
-                    return texture;
+                    else {
+                        url = rootUrl + parsedTexture.name;
+                    }
+                    if (parsedTexture.url && (parsedTexture.url.startsWith("data:") || Texture.UseSerializedUrlIfAny)) {
+                        url = parsedTexture.url;
+                    }
+                    const options = {
+                        noMipmap: !generateMipMaps,
+                        invertY: parsedTexture.invertY,
+                        samplingMode: parsedTexture.samplingMode,
+                        useSRGBBuffer: parsedTexture._useSRGBBuffer ?? false,
+                        creationFlags: parsedTexture._creationFlags ?? 0,
+                        onLoad: () => {
+                            onLoaded(texture);
+                        },
+                        internalTexture,
+                    };
+                    texture = new Texture(url, scene, options);
                 }
-            },
-            parsedTexture,
-            scene
-        );
+                return texture;
+            }
+        }, parsedTexture, scene);
         return texture;
     }
     /**
@@ -846,35 +777,8 @@ export class Texture extends BaseTexture {
      * @param forcedExtension defines the extension to use to pick the right loader
      * @returns the created texture
      */
-    static CreateFromBase64String(
-        data,
-        name,
-        scene,
-        noMipmapOrOptions,
-        invertY,
-        samplingMode = Texture.TRILINEAR_SAMPLINGMODE,
-        onLoad = null,
-        onError = null,
-        format = 5,
-        creationFlags,
-        forcedExtension
-    ) {
-        return new Texture(
-            "data:" + name,
-            scene,
-            noMipmapOrOptions,
-            invertY,
-            samplingMode,
-            onLoad,
-            onError,
-            data,
-            false,
-            format,
-            undefined,
-            undefined,
-            creationFlags,
-            forcedExtension
-        );
+    static CreateFromBase64String(data, name, scene, noMipmapOrOptions, invertY, samplingMode = Texture.TRILINEAR_SAMPLINGMODE, onLoad = null, onError = null, format = 5, creationFlags, forcedExtension) {
+        return new Texture("data:" + name, scene, noMipmapOrOptions, invertY, samplingMode, onLoad, onError, data, false, format, undefined, undefined, creationFlags, forcedExtension);
     }
     /**
      * Creates a texture from its data: representation. (data: will be added in case only the payload has been passed in)
@@ -892,39 +796,11 @@ export class Texture extends BaseTexture {
      * @param forcedExtension defines the extension to use to pick the right loader
      * @returns the created texture
      */
-    static LoadFromDataString(
-        name,
-        buffer,
-        scene,
-        deleteBuffer = false,
-        noMipmapOrOptions,
-        invertY = true,
-        samplingMode = Texture.TRILINEAR_SAMPLINGMODE,
-        onLoad = null,
-        onError = null,
-        format = 5,
-        creationFlags,
-        forcedExtension
-    ) {
+    static LoadFromDataString(name, buffer, scene, deleteBuffer = false, noMipmapOrOptions, invertY = true, samplingMode = Texture.TRILINEAR_SAMPLINGMODE, onLoad = null, onError = null, format = 5, creationFlags, forcedExtension) {
         if (name.substring(0, 5) !== "data:") {
             name = "data:" + name;
         }
-        return new Texture(
-            name,
-            scene,
-            noMipmapOrOptions,
-            invertY,
-            samplingMode,
-            onLoad,
-            onError,
-            buffer,
-            deleteBuffer,
-            format,
-            undefined,
-            undefined,
-            creationFlags,
-            forcedExtension
-        );
+        return new Texture(name, scene, noMipmapOrOptions, invertY, samplingMode, onLoad, onError, buffer, deleteBuffer, format, undefined, undefined, creationFlags, forcedExtension);
     }
 }
 /**
@@ -1023,19 +899,45 @@ Texture.MIRROR_ADDRESSMODE = 2;
  * Gets or sets a boolean which defines if the texture url must be build from the serialized URL instead of just using the name and loading them side by side with the scene file
  */
 Texture.UseSerializedUrlIfAny = false;
-__decorate([serialize()], Texture.prototype, "url", void 0);
-__decorate([serialize()], Texture.prototype, "uOffset", void 0);
-__decorate([serialize()], Texture.prototype, "vOffset", void 0);
-__decorate([serialize()], Texture.prototype, "uScale", void 0);
-__decorate([serialize()], Texture.prototype, "vScale", void 0);
-__decorate([serialize()], Texture.prototype, "uAng", void 0);
-__decorate([serialize()], Texture.prototype, "vAng", void 0);
-__decorate([serialize()], Texture.prototype, "wAng", void 0);
-__decorate([serialize()], Texture.prototype, "uRotationCenter", void 0);
-__decorate([serialize()], Texture.prototype, "vRotationCenter", void 0);
-__decorate([serialize()], Texture.prototype, "wRotationCenter", void 0);
-__decorate([serialize()], Texture.prototype, "homogeneousRotationInUVTransform", void 0);
-__decorate([serialize()], Texture.prototype, "isBlocking", null);
+__decorate([
+    serialize()
+], Texture.prototype, "url", void 0);
+__decorate([
+    serialize()
+], Texture.prototype, "uOffset", void 0);
+__decorate([
+    serialize()
+], Texture.prototype, "vOffset", void 0);
+__decorate([
+    serialize()
+], Texture.prototype, "uScale", void 0);
+__decorate([
+    serialize()
+], Texture.prototype, "vScale", void 0);
+__decorate([
+    serialize()
+], Texture.prototype, "uAng", void 0);
+__decorate([
+    serialize()
+], Texture.prototype, "vAng", void 0);
+__decorate([
+    serialize()
+], Texture.prototype, "wAng", void 0);
+__decorate([
+    serialize()
+], Texture.prototype, "uRotationCenter", void 0);
+__decorate([
+    serialize()
+], Texture.prototype, "vRotationCenter", void 0);
+__decorate([
+    serialize()
+], Texture.prototype, "wRotationCenter", void 0);
+__decorate([
+    serialize()
+], Texture.prototype, "homogeneousRotationInUVTransform", void 0);
+__decorate([
+    serialize()
+], Texture.prototype, "isBlocking", null);
 let _Registered = false;
 /**
  * Register side effects for texture.
@@ -1050,4 +952,4 @@ export function RegisterTexture() {
     RegisterClass("BABYLON.Texture", Texture);
     SerializationHelper._TextureParser = Texture.Parse;
 }
-//# sourceMappingURL=texture.pure.js.map
+//# sourceMappingURL=texture.pure.js.map

package/Materials/index.d.ts

@@ -39,6 +39,7 @@ export * from "./meshDebugPluginMaterial.js";
 export * from "./GaussianSplatting/gaussianSplattingMaterial.js";
 export * from "./GaussianSplatting/gaussianSplattingSolidColorMaterialPlugin.js";
 export * from "./GaussianSplatting/gaussianSplattingGpuPickingMaterialPlugin.js";
+export * from "./GaussianSplatting/gaussianSplattingDebugMaterialPlugin.js";
 export * from "./materialHelper.functions.js";
 export * from "./materialHelper.geometryrendering.js";
 export * from "./materialStencilState.js";
@@ -53,4 +54,33 @@ export * from "../Shaders/greasedLine.fragment.js";
 export * from "../Shaders/greasedLine.vertex.js";
 export * from "../ShadersWGSL/greasedLine.fragment.js";
 export * from "../ShadersWGSL/greasedLine.vertex.js";
+export * from "../Shaders/ShadersInclude/bakedVertexAnimation.js";
+export * from "../Shaders/ShadersInclude/bakedVertexAnimationDeclaration.js";
+export * from "../Shaders/ShadersInclude/depthPrePass.js";
+export * from "../Shaders/ShadersInclude/fogFragment.js";
+export * from "../Shaders/ShadersInclude/fogVertex.js";
+export * from "../Shaders/ShadersInclude/fogVertexDeclaration.js";
+export * from "../Shaders/ShadersInclude/imageProcessingCompatibility.js";
+export * from "../Shaders/ShadersInclude/instancesDeclaration.js";
+export * from "../Shaders/ShadersInclude/instancesVertex.js";
+export * from "../Shaders/ShadersInclude/logDepthFragment.js";
+export * from "../Shaders/ShadersInclude/logDepthVertex.js";
+export * from "../Shaders/ShadersInclude/sceneFragmentDeclaration.js";
+export * from "../Shaders/ShadersInclude/sceneUboDeclaration.js";
+export * from "../Shaders/ShadersInclude/sceneVertexDeclaration.js";
+export * from "../Shaders/ShadersInclude/vertexColorMixing.js";
+export * from "../ShadersWGSL/ShadersInclude/bakedVertexAnimation.js";
+export * from "../ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration.js";
+export * from "../ShadersWGSL/ShadersInclude/depthPrePass.js";
+export * from "../ShadersWGSL/ShadersInclude/fogFragment.js";
+export * from "../ShadersWGSL/ShadersInclude/fogVertex.js";
+export * from "../ShadersWGSL/ShadersInclude/fogVertexDeclaration.js";
+export * from "../ShadersWGSL/ShadersInclude/imageProcessingCompatibility.js";
+export * from "../ShadersWGSL/ShadersInclude/instancesDeclaration.js";
+export * from "../ShadersWGSL/ShadersInclude/instancesVertex.js";
+export * from "../ShadersWGSL/ShadersInclude/lightVxFragmentDeclaration.js";
+export * from "../ShadersWGSL/ShadersInclude/logDepthFragment.js";
+export * from "../ShadersWGSL/ShadersInclude/logDepthVertex.js";
+export * from "../ShadersWGSL/ShadersInclude/sceneUboDeclaration.js";
+export * from "../ShadersWGSL/ShadersInclude/vertexColorMixing.js";
 import "./material.decalMap.js";

package/Materials/index.js

@@ -40,6 +40,7 @@ export * from "./meshDebugPluginMaterial.js";
 export * from "./GaussianSplatting/gaussianSplattingMaterial.js";
 export * from "./GaussianSplatting/gaussianSplattingSolidColorMaterialPlugin.js";
 export * from "./GaussianSplatting/gaussianSplattingGpuPickingMaterialPlugin.js";
+export * from "./GaussianSplatting/gaussianSplattingDebugMaterialPlugin.js";
 export * from "./materialHelper.functions.js";
 export * from "./materialHelper.geometryrendering.js";
 export * from "./materialStencilState.js";
@@ -57,5 +58,35 @@ export * from "../Shaders/greasedLine.fragment.js";
 export * from "../Shaders/greasedLine.vertex.js";
 export * from "../ShadersWGSL/greasedLine.fragment.js";
 export * from "../ShadersWGSL/greasedLine.vertex.js";
+// Shared shader includes used by external material packages in UMD builds
+export * from "../Shaders/ShadersInclude/bakedVertexAnimation.js";
+export * from "../Shaders/ShadersInclude/bakedVertexAnimationDeclaration.js";
+export * from "../Shaders/ShadersInclude/depthPrePass.js";
+export * from "../Shaders/ShadersInclude/fogFragment.js";
+export * from "../Shaders/ShadersInclude/fogVertex.js";
+export * from "../Shaders/ShadersInclude/fogVertexDeclaration.js";
+export * from "../Shaders/ShadersInclude/imageProcessingCompatibility.js";
+export * from "../Shaders/ShadersInclude/instancesDeclaration.js";
+export * from "../Shaders/ShadersInclude/instancesVertex.js";
+export * from "../Shaders/ShadersInclude/logDepthFragment.js";
+export * from "../Shaders/ShadersInclude/logDepthVertex.js";
+export * from "../Shaders/ShadersInclude/sceneFragmentDeclaration.js";
+export * from "../Shaders/ShadersInclude/sceneUboDeclaration.js";
+export * from "../Shaders/ShadersInclude/sceneVertexDeclaration.js";
+export * from "../Shaders/ShadersInclude/vertexColorMixing.js";
+export * from "../ShadersWGSL/ShadersInclude/bakedVertexAnimation.js";
+export * from "../ShadersWGSL/ShadersInclude/bakedVertexAnimationDeclaration.js";
+export * from "../ShadersWGSL/ShadersInclude/depthPrePass.js";
+export * from "../ShadersWGSL/ShadersInclude/fogFragment.js";
+export * from "../ShadersWGSL/ShadersInclude/fogVertex.js";
+export * from "../ShadersWGSL/ShadersInclude/fogVertexDeclaration.js";
+export * from "../ShadersWGSL/ShadersInclude/imageProcessingCompatibility.js";
+export * from "../ShadersWGSL/ShadersInclude/instancesDeclaration.js";
+export * from "../ShadersWGSL/ShadersInclude/instancesVertex.js";
+export * from "../ShadersWGSL/ShadersInclude/lightVxFragmentDeclaration.js";
+export * from "../ShadersWGSL/ShadersInclude/logDepthFragment.js";
+export * from "../ShadersWGSL/ShadersInclude/logDepthVertex.js";
+export * from "../ShadersWGSL/ShadersInclude/sceneUboDeclaration.js";
+export * from "../ShadersWGSL/ShadersInclude/vertexColorMixing.js";
 import "./material.decalMap.js";
 //# sourceMappingURL=index.js.map