@needle-tools/materialx 1.0.1-next.b9467c8 → 1.0.1-next.c1bbe8d

package/src/loader/loader.three.ts

@@ -1,66 +1,46 @@
-import { Context } from "@needle-tools/engine";
-import { Material, MeshStandardMaterial, Texture, NearestFilter, CompressedTexture } from "three";
-import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { Context, GameObject } from "@needle-tools/engine";
+import { ShaderMaterial, Material, MeshStandardMaterial, LoadingManager, TextureLoader, Texture, NearestFilter, Matrix4, GLSL3, AddEquation, OneMinusSrcAlphaFactor, SrcAlphaFactor, DoubleSide, Matrix3, Vector3, Object3D, Camera, Uniform } from "three";
+import { GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { getUniformValues } from "../helper.js";
 import { ready, MaterialXEnvironment, state } from "../materialx.js";
 import { debug } from "../utils.js";
-import { MaterialXMaterial } from "../materialx.material.js";
 
 // TypeScript interfaces matching the C# data structures
-export type MaterialX_root_extension = {
+interface MaterialX_root_extension {
     /** e.g. 1.39 */
     version: string;
     /** e.g. "Material" */
     name: string;
     /** MaterialX xml content */
     mtlx: string;
-    /** MaterialX texture pointers */
-    textures: Array<{ name: string, pointer: string }>;
 }
 
-export type MaterialX_material_extension = {
+interface MaterialX_material_extension {
     name: string; // Material name reference
 }
 
 // MaterialX loader extension for js GLTFLoader
 export class MaterialXLoader implements GLTFLoaderPlugin {
-    readonly name = "NEEDLE_materials_mtlx";
-
-    private readonly _generatedMaterials: MaterialXMaterial[] = [];
+    name = "NEEDLE_materials_mtlx";
 
+    // private rootMaterialXData: MaterialX_root_extension | null = null;
     private _documentReadyPromise: Promise<any> | null = null;
+    private environmentInitialized = false;
+    private generatedMaterials: ShaderMaterial[] = [];
 
     get materialX_root_data() {
         return this.parser.json.extensions?.[this.name] as MaterialX_root_extension | null;
     }
 
-    /** Generated materialX materials */
-    get materials() {
-        return this._generatedMaterials;
-    }
-
     constructor(private parser: GLTFParser, private context: Context) {
         if (debug) console.log("MaterialXLoader created for parser");
         // Start loading of MaterialX environment if the root extension exists
-        if (this.materialX_root_data) {
+        const hasMaterialXExtension = this.parser.json.extensions?.[this.name] != null;
+        if (hasMaterialXExtension) {
             ready();
         }
     }
 
-    loadMaterial(materialIndex: number): Promise<Material> | null {
-        const materialDef = this.parser.json.materials?.[materialIndex];
-        if (!materialDef?.extensions?.[this.name]) {
-            return null;
-        }
-        // Wrap the async implementation
-        return this._loadMaterialAsync(materialIndex);
-    }
-
-    afterRoot = async (_gltf: GLTF) => {
-        // Initialize MaterialX lighting system with scene data
-        const environment = state.materialXEnvironment;
-        environment.initialize(this.context);
-    }
-
     // Parse the MaterialX document once and cache it
     private async _materialXDocumentReady(): Promise<any> {
         if (this._documentReadyPromise) {
@@ -92,6 +72,16 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
         })();
     }
 
+    loadMaterial(materialIndex: number): Promise<Material> | null {
+        const materialDef = this.parser.json.materials?.[materialIndex];
+        if (!materialDef?.extensions?.[this.name]) {
+            return null;
+        }
+
+        // Wrap the async implementation
+        return this._loadMaterialAsync(materialIndex);
+    }
+
     private async _loadMaterialAsync(materialIndex: number): Promise<Material> {
 
         const materialDef = this.parser.json.materials?.[materialIndex];
@@ -102,7 +92,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
 
         if (dataIndex) {
             // Create a new material and process MaterialX - AWAIT THIS!
-            return await this._createMaterialXMaterial(dataIndex);
+            return await this.createMaterialXMaterial(dataIndex);
         }
 
         // Return fallback material instead of null
@@ -111,22 +101,22 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
         return fallbackMaterial;
     }
 
-    private async _createMaterialXMaterial(material_extension: MaterialX_material_extension): Promise<Material> {
+    private async createMaterialXMaterial(materialXData: MaterialX_material_extension): Promise<Material> {
         try {
-            if (debug) console.log(`Creating MaterialX material: ${material_extension.name}`);
+            if (debug) console.log(`Creating MaterialX material: ${materialXData.name}`);
 
             const doc = await this._materialXDocumentReady();
 
             if (!state.materialXModule || !state.materialXGenerator || !state.materialXGenContext) {
                 console.warn("[MaterialX] WASM module not ready, returning fallback material");
                 const fallbackMaterial = new MeshStandardMaterial();
-                fallbackMaterial.userData.materialX = material_extension;
-                fallbackMaterial.name = `MaterialX_Fallback_${material_extension.name}`;
+                fallbackMaterial.userData.materialX = materialXData;
+                fallbackMaterial.name = `MaterialX_Fallback_${materialXData.name}`;
                 return fallbackMaterial;
             }
 
             // Find the renderable element following MaterialX example pattern exactly
-            let renderableElement: any = null;
+            let renderableElement = null;
             let foundRenderable = false;
 
             if (debug) console.log("[MaterialX] document", doc);
@@ -144,7 +134,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
                     if (debug) console.log('[MaterialX] Scan material: ', i, materialName);
 
                     // Find the matching material
-                    if (materialName == material_extension.name) {
+                    if (materialName == materialXData.name) {
                         renderableElement = materialNode;
                         foundRenderable = true;
                         if (debug) console.log('[MaterialX] -- add material: ', materialName);
@@ -203,8 +193,8 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             if (!renderableElement) {
                 console.warn("[MaterialX] No renderable element found in MaterialX document");
                 const fallbackMaterial = new MeshStandardMaterial();
-                fallbackMaterial.userData.materialX = material_extension;
-                fallbackMaterial.name = `MaterialX_NoRenderable_${material_extension.name}`;
+                fallbackMaterial.userData.materialX = materialXData;
+                fallbackMaterial.name = `MaterialX_NoRenderable_${materialXData.name}`;
                 return fallbackMaterial;
             }
 
@@ -219,84 +209,267 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             const elementName = (renderableElement as any).getNamePath ? (renderableElement as any).getNamePath() : (renderableElement as any).getName();
 
             const shader = state.materialXGenerator.generate(elementName, renderableElement, state.materialXGenContext);
-            const shaderMaterial = new MaterialXMaterial({
-                name: material_extension.name,
-                shader,
-                transparent: isTransparent,
-                loaders: {
-                    getTexture: url => {
-                        // Return a checkerboard texture for now
-                        const defaultTexture = new Texture();
-                        defaultTexture.image = new Image();
-                        defaultTexture.image.src = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAAG0lEQVR4nGJqWH9q9e8XjA/VrL8UfQIEAAD//zn2CCX5UcsdAAAAAElFTkSuQmCC";
-                        defaultTexture.needsUpdate = true;
-                        // Pixelated filtering
-                        defaultTexture.magFilter = NearestFilter;
-                        defaultTexture.minFilter = NearestFilter;
-                        new Promise(() => {
-                            // Find the index of the texture in the parser
-                            const filenameWithoutExt = url.split('/').pop()?.split('.').shift() || '';
-
-                            // Resolve the texture from the MaterialX root extension
-                            const ext = this.materialX_root_data;
-                            if (ext) {
-                                const textures = ext.textures || [];
-                                let index = -1;
-                                for (const texture of textures) {
-                                    // Find the texture by name and use the pointer string to get the index
-                                    if (texture.name === filenameWithoutExt) {
-                                        const ptr = texture.pointer;
-                                        const indexStr = ptr.substring("/textures/".length);
-                                        index = parseInt(indexStr);
-                                        
-                                        if (isNaN(index) || index < 0) {
-                                            console.error("[MaterialX] Invalid texture index in pointer:", ptr);
-                                            return;
-                                        }
-                                        else {
-                                            if (debug) console.log("[MaterialX] Texture index found:", index, "for", filenameWithoutExt);
-                                        }
-                                    }
-                                }
-
-                                if (index < 0) {
-                                    console.error("[MaterialX] Texture not found in parser:", filenameWithoutExt, this.parser.json);
-                                    return;
-                                }
-                                this.parser.getDependency("texture", index).then(tex => {
-                                    if (debug) console.log("[MaterialX] Texture loaded:" + tex.name, tex);
-
-                                    // update the default texture with the loaded texture
-                                    defaultTexture.image = tex.image;
-                                    defaultTexture.needsUpdate = true;
-                                    defaultTexture.userData = tex.userData || {}; // needed for LODs
-                                    defaultTexture.format = tex.format;
-                                    defaultTexture.source = tex.source || defaultTexture.source;
-                                    defaultTexture.type = tex.type;
-                                    defaultTexture.format = tex.format;
-                                    defaultTexture.magFilter = tex.magFilter;
-                                    defaultTexture.minFilter = tex.minFilter;
-                                    defaultTexture.wrapS = tex.wrapS;
-                                    defaultTexture.wrapT = tex.wrapT;
-                                    defaultTexture.generateMipmaps = tex.generateMipmaps;
-                                    defaultTexture.mipmaps = tex.mipmaps || defaultTexture.mipmaps;
-                                    defaultTexture.unpackAlignment = tex.unpackAlignment;
-
-                                    if (!(defaultTexture instanceof CompressedTexture) && tex instanceof CompressedTexture) {
-                                        (defaultTexture as any).isCompressedTexture = true;
-                                    }
-                                });
-                            }
-                        });
-                        return defaultTexture;
+
+            // Get vertex and fragment shader source, and remove #version directive for newer js. 
+            // It's added by three.js glslVersion.
+            let vertexShader = shader.getSourceCode("vertex").replace(/^#version.*$/gm, '').trim();
+            let fragmentShader = shader.getSourceCode("pixel").replace(/^#version.*$/gm, '').trim();
+
+            // MaterialX uses different attribute names than js defaults,
+            // so we patch the MaterialX shaders to match the js standard names.
+            // Otherwise, we'd have to modify the mesh attributes (see original MaterialX for reference).
+
+            // Patch vertexShader
+            vertexShader = vertexShader.replace(/\bi_position\b/g, 'position');
+            vertexShader = vertexShader.replace(/\bi_normal\b/g, 'normal');
+            vertexShader = vertexShader.replace(/\bi_texcoord_0\b/g, 'uv');
+            vertexShader = vertexShader.replace(/\bi_texcoord_1\b/g, 'uv1');
+            vertexShader = vertexShader.replace(/\bi_tangent\b/g, 'tangent');
+            vertexShader = vertexShader.replace(/\bi_color_0\b/g, 'color');
+
+            // Patch fragmentShader
+            fragmentShader = fragmentShader.replace(/\bi_position\b/g, 'position');
+            fragmentShader = fragmentShader.replace(/\bi_normal\b/g, 'normal');
+            fragmentShader = fragmentShader.replace(/\bi_texcoord_0\b/g, 'uv');
+            fragmentShader = fragmentShader.replace(/\bi_texcoord_1\b/g, 'uv1');
+            fragmentShader = fragmentShader.replace(/\bi_tangent\b/g, 'tangent');
+            fragmentShader = fragmentShader.replace(/\bi_color_0\b/g, 'color');
+
+            // Remove `in vec3 position;` and so on since they're already declared by ShaderMaterial
+            vertexShader = vertexShader.replace(/in\s+vec3\s+position;/g, '');
+            vertexShader = vertexShader.replace(/in\s+vec3\s+normal;/g, '');
+            vertexShader = vertexShader.replace(/in\s+vec3\s+uv;/g, '');
+            vertexShader = vertexShader.replace(/in\s+vec3\s+uv1;/g, '');
+            vertexShader = vertexShader.replace(/in\s+vec4\s+tangent;/g, '');
+            vertexShader = vertexShader.replace(/in\s+vec4\s+color;/g, '');
+
+            // Patch uv 2-component to 3-component (`texcoord_0 = uv;` needs to be replaced with `texcoord_0 = vec3(uv, 0.0);`)
+            // TODO what if we actually have a 3-component UV? Not sure what three.js does then
+            vertexShader = vertexShader.replace(/texcoord_0 = uv;/g, 'texcoord_0 = vec3(uv, 0.0);');
+
+            // Patch units – seems MaterialX uses different units and we end up with wrong light values?
+            // result.direction = light.position - position;
+            fragmentShader = fragmentShader.replace(
+                /result\.direction\s*=\s*light\.position\s*-\s*position;/g,
+                'result.direction = (light.position - position) * 10.0 / 1.0;');
+
+            // Add tonemapping and colorspace handling
+            // Replace `out vec4 out1;` with `out vec4 gl_FragColor;`
+            fragmentShader = fragmentShader.replace(
+                /out\s+vec4\s+out1;/,
+                'layout(location = 0) out vec4 pc_fragColor;\n#define gl_FragColor pc_fragColor');
+
+            // Replace `out1 = vec4(<CAPTURE>)` with `gl_FragColor = vec4(<CAPTURE>)` and tonemapping/colorspace handling
+            fragmentShader = fragmentShader.replace(/^\s*out1\s*=\s*vec4\((.*)\);/gm,
+                `
+    gl_FragColor = vec4($1);
+    #include <tonemapping_fragment>
+    #include <colorspace_fragment>`);
+
+            if (debug) {
+                console.group("[MaterialX]: ", materialXData.name);
+                console.log("Vertex shader length:", vertexShader.length, vertexShader);
+                console.log("Fragment shader length:", fragmentShader.length, fragmentShader);
+                console.groupEnd();
+            }
+
+            // Extract uniforms from both vertex and pixel stages
+            const loadingManager = new LoadingManager();
+            loadingManager.setURLModifier((url: string) => {
+                if (debug) console.log("Loading URL:", url);
+                // Find the texture in the textures in the parser and load it from there
+                return url;
+            });
+
+            const textureLoader = new TextureLoader(loadingManager);
+
+            // Override the textureLoader.load method to use the parser's loadTexture directly,
+            // since we want to load the textures from the glTF document and not from disk.
+            // That loader does its own caching too.
+            textureLoader.load = (url: string, onLoad?: (texture: Texture) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: Error) => void): Texture => {
+
+                // Return a checkerboard texture for now
+                const checkerboardTexture = new Texture();
+                checkerboardTexture.image = new Image();
+                checkerboardTexture.image.src = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAAG0lEQVR4nGJqWH9q9e8XjA/VrL8UfQIEAAD//zn2CCX5UcsdAAAAAElFTkSuQmCC";
+                checkerboardTexture.needsUpdate = true;
+                // Pixelated filtering
+                checkerboardTexture.magFilter = NearestFilter;
+                checkerboardTexture.minFilter = NearestFilter;
+
+                new Promise(() => {
+                    // Find the index of the texture in the parser
+                    const filenameWithoutExt = url.split('/').pop()?.split('.').shift() || '';
+
+                    // Find in the root extension; there's the textures dictionary:
+                    // a mapping from the texture name used in MaterialX to the glTF texture index
+                    const ext = this.parser.json.extensions?.[this.name];
+                    const textures = ext?.textures || [];
+
+                    const index = textures.findIndex(tex => {
+                        if (debug) console.log("[MaterialX] Checking texture:", tex.name, "against URL:", filenameWithoutExt);
+                        return tex.name === filenameWithoutExt;
+                    });
+
+                    if (index < 0) {
+                        console.warn("[MaterialX] Texture not found in parser:", filenameWithoutExt, this.parser.json);
+                        onError?.(new Error(`Texture not found: ${filenameWithoutExt}`));
+                        return;
                     }
+                    this.parser.getDependency("texture", index).then(tex => {
+                        if (debug) console.log("[MaterialX] Texture loaded:", tex);
+                        // update the checkerboard texture with the loaded texture
+                        checkerboardTexture.image = tex.image;
+                        checkerboardTexture.needsUpdate = true;
+                        onLoad?.(tex);
+                    }).catch(err => {
+                        onError?.(err);
+                    });
+                });
+
+                return checkerboardTexture;
+            };
+
+            const searchPath = ""; // Could be derived from the asset path if needed
+            const flipV = false; // Set based on your geometry requirements
+
+            const uniforms = {
+                ...getUniformValues(shader.getStage('vertex'), textureLoader, searchPath, flipV),
+                ...getUniformValues(shader.getStage('pixel'), textureLoader, searchPath, flipV),
+            };
+
+            // Get lighting and environment data from MaterialX environment
+            const environment = state.materialXEnvironment;
+            // const lights = environment.getLights() || [];
+            const lightData = environment.getLightData() || null;
+            const radianceTexture = environment.getRadianceTexture() || null;
+            const irradianceTexture = environment.getIrradianceTexture() || null;
+            const getLightRotation = () => {
+                // Placeholder for light rotation logic, if needed
+                return new Matrix4();
+            };
+
+            if (debug) console.log("Lights", { lightData, radianceTexture, irradianceTexture });
+
+            if (debug) {
+                const mips = Math.trunc(Math.log2(Math.max(radianceTexture?.width ?? 0, radianceTexture?.height ?? 0))) + 1;
+                console.log("[MaterialX] Radiance texture mips:", mips, "for texture size:", radianceTexture?.width, "x", radianceTexture?.height);
+            }
+            Object.assign(uniforms, {
+                u_envMatrix: { value: getLightRotation() },
+                u_envRadiance: { value: radianceTexture, type: 't' },
+                u_envRadianceMips: { value: 8, type: 'i' },
+                // TODO we need to figure out how we can set a PMREM here... doing many texture samples is prohibitively expensive
+                u_envRadianceSamples: { value: 8, type: 'i' },
+                u_envIrradiance: { value: irradianceTexture, type: 't' },
+                u_refractionEnv: { value: true },
+                u_lightData: { value: [] },
+            });
+
+            // console.log("NEW MATERIAL UNIFORMS", uniforms);
+
+            // Debug: Log the actual shaders to see what we're working with
+            // console.log("Generated vertex shader:", vertexShader.substring(0, 500) + "...");
+            // console.log("Generated fragment shader:", fragmentShader.substring(0, 500) + "...");
+
+            // Create js RawShaderMaterial (with GLSL3 for MaterialX compatibility)
+            const shaderMaterial = new ShaderMaterial({
+                uniforms: uniforms,
+                vertexShader: vertexShader,
+                fragmentShader: fragmentShader,
+                glslVersion: GLSL3,
+                transparent: isTransparent,
+                // Only set blend settings if actually transparent
+                ...(isTransparent && {
+                    blendEquation: AddEquation,
+                    blendSrc: OneMinusSrcAlphaFactor,
+                    blendDst: SrcAlphaFactor,
+                }),
+                side: DoubleSide,
+                // Add some debug settings
+                depthTest: true,
+                depthWrite: !isTransparent
+            });
+
+            // Add helper matrices for uniform updates (similar to MaterialX example)
+            const normalMat = new Matrix3();
+            const viewProjMat = new Matrix4();
+            const worldViewPos = new Vector3();
+
+            // Store helper objects on the material for uniform updates
+            shaderMaterial.userData.materialX = materialXData;
+            shaderMaterial.userData.updateUniforms = (object: Object3D, camera: Camera) => {
+                const uniforms = shaderMaterial.uniforms;
+
+                if (!uniforms) return;
+
+                // TODO remove. Not sure why this is needed, but without it
+                // we currently get some "swimming" where matrices are not up to date.
+                camera.updateMatrixWorld(true);
+
+                // Update standard transformation matrices
+                if (uniforms.u_worldMatrix) {
+                    if (!uniforms.u_worldMatrix.value?.isMatrix4) uniforms.u_worldMatrix.value = new Matrix4();
+                    uniforms.u_worldMatrix.value = object.matrixWorld;
+                }
+
+                if (uniforms.u_viewProjectionMatrix) {
+                    if (!uniforms.u_viewProjectionMatrix.value?.isMatrix4) uniforms.u_viewProjectionMatrix.value = new Matrix4();
+                    uniforms.u_viewProjectionMatrix.value.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+                }
+
+                if (uniforms.u_viewPosition) {
+                    if (!uniforms.u_viewPosition.value?.isVector3) uniforms.u_viewPosition.value = new Vector3();
+                    uniforms.u_viewPosition.value.copy(camera.getWorldPosition(worldViewPos));
+                }
+
+                if (uniforms.u_worldInverseTransposeMatrix) {
+                    if (!uniforms.u_worldInverseTransposeMatrix.value?.isMatrix4) uniforms.u_worldInverseTransposeMatrix.value = new Matrix4();
+                    uniforms.u_worldInverseTransposeMatrix.value.setFromMatrix3(normalMat.getNormalMatrix(object.matrixWorld));
+                }
+
+                // Update time uniforms
+                const time = performance.now() / 1000.0;
+                if (uniforms.u_time) {
+                    uniforms.u_time.value = time;
                 }
+                if (uniforms.u_frame) {
+                    uniforms.u_frame.value = time;
+                }
+
+                // Update light uniforms
+                const environment = state.materialXEnvironment;
+                const lightData = environment.getLightData() || null;
+                const lightCount = environment.getLightCount() || 0;
+                if (uniforms.u_numActiveLightSources) {
+                    uniforms.u_numActiveLightSources.value = lightCount;
+                }
+
+                if (lightData && uniforms.u_lightData) {
+                    uniforms.u_lightData.value = lightData;
+                    if (debug) console.log("Updating light data for material", shaderMaterial.name, lightData, shaderMaterial.uniforms);
+                }
+
+                // Mark uniforms as needing update
+                shaderMaterial.uniformsNeedUpdate = true;
+            };
+
+            this.context.pre_update_callbacks.push(() => {
+                const environment = state.materialXEnvironment;
+                environment.updateLighting(false);
             });
-            // Track this material for later lighting updates
-            this._generatedMaterials.push(shaderMaterial);
+
+            shaderMaterial.name = `MaterialX_Generated_${materialXData.name}`;
 
             // Add debugging to see if the material compiles correctly
-            if (debug) console.log("[MaterialX]  material created:", shaderMaterial.name);
+            if (debug) console.log("[MaterialX]  material created successfully:", shaderMaterial.name);
+            // if (debug) console.log("Material uniforms keys:", Object.keys(shaderMaterial.uniforms || {}));
+            // if (debug) console.log("Material transparent:", shaderMaterial.transparent);
+            // if (debug) console.log("Material side:", shaderMaterial.side);
+
+            // Track this material for later lighting updates
+            this.generatedMaterials.push(shaderMaterial);
+
             return shaderMaterial;
 
         } catch (error) {
@@ -304,9 +477,65 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             console.error("[MaterialX] Error creating MaterialX material:", error);
             // Return a fallback material with stored MaterialX data
             const fallbackMaterial = new MeshStandardMaterial();
-            fallbackMaterial.userData.materialX = material_extension;
-            fallbackMaterial.name = `MaterialX_Error_${material_extension.name}`;
+            fallbackMaterial.userData.materialX = materialXData;
+            fallbackMaterial.name = `MaterialX_Error_${materialXData.name}`;
             return fallbackMaterial;
         }
     }
+
+    private identityMatrix: Matrix4 = new Matrix4().identity();
+    // Update lighting uniforms for all generated MaterialX materials
+    updateLightingFromEnvironment(environment: MaterialXEnvironment): void {
+
+        // Get lighting data from environment
+        const lightData = environment.getLightData() || null;
+        const lightCount = environment.getLightCount() || 0;
+        const radianceTexture = environment.getRadianceTexture() || null;
+        const irradianceTexture = environment.getIrradianceTexture() || null;
+
+        if (debug) {
+            console.log(`[MaterialX] Updating lighting for ${this.generatedMaterials.length} MaterialX materials`, {
+                lightData, radianceTexture, irradianceTexture,
+            });
+        }
+
+        // Update each generated material's lighting uniforms
+        this.generatedMaterials.forEach((material, _index) => {
+            if (!material.uniforms) return;
+
+            console.warn(material.name, material.uniforms, lightCount)
+
+            // Update light count
+            if (material.uniforms.u_numActiveLightSources && lightCount >= 0) {
+                material.uniforms.u_numActiveLightSources.value = lightCount;
+            }
+
+            // Update light data if we have lights
+            if (lightData) {
+                material.uniforms.u_lightData ??= new Uniform(null)
+                material.uniforms.u_lightData.value = lightData;
+                if (debug) console.log("[MaterialX] Updated light data for material", material.name, lightData, material.uniforms,);
+            }
+            else if (debug) console.warn("[MaterialX] No light data available to update uniforms for material", material.name);
+
+            // Update environment uniforms
+            if (material.uniforms.u_envMatrix) {
+                material.uniforms.u_envMatrix.value = this.identityMatrix;
+            }
+            if (material.uniforms.u_envRadiance) {
+                material.uniforms.u_envRadiance.value = radianceTexture;
+            }
+            if (material.uniforms.u_envRadianceMips) {
+                material.uniforms.u_envRadianceMips.value = Math.trunc(Math.log2(Math.max(radianceTexture?.source.data.width ?? 0, radianceTexture?.source.data.height ?? 0))) + 1;
+            }
+            if (material.uniforms.u_envIrradiance) {
+                material.uniforms.u_envIrradiance.value = irradianceTexture;
+            }
+
+            // Mark uniforms as needing update
+            // console.log("Light data in uniforms", material.uniforms, material.fragmentShader);
+            material.uniformsNeedUpdate = true;
+            console.log(material)
+        });
+    }
 }