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

package/codegen/register_types.ts

@@ -2,7 +2,9 @@
 import { TypeStore } from "@needle-tools/engine"
 
 // Import types
+import { MaterialXMaterial } from "../src/materialx.material.js";
 import { MaterialXUniformUpdate } from "../src/loader/loader.needle.js";
 
 // Register types
+TypeStore.add("MaterialXMaterial", MaterialXMaterial);
 TypeStore.add("MaterialXUniformUpdate", MaterialXUniformUpdate);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/materialx",
-  "version": "1.0.1-next.c1bbe8d",
+  "version": "1.0.1-next.c315a2f",
   "type": "module",
   "main": "index.ts",
   "exports": {

package/src/loader/loader.needle.ts

@@ -6,40 +6,39 @@ import type { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
 import type { GLTFExporter } from "three/examples/jsm/exporters/GLTFExporter.js";
 import { MaterialXLoader } from "./loader.three.js";
 import { debug } from "../utils.js";
-import { state } from "../materialx.js";
+import { MaterialXEnvironment, state } from "../materialx.js";
+import { MaterialXMaterial } from "../materialx.material.js";
 
 //@dont-generate-component
 export class MaterialXUniformUpdate extends Component {
 
-    static updateMaterial(mat: Material | Material[], object: Object3D, camera: Camera) {
-        if (Array.isArray(mat)) {
-            mat.forEach(m => {
-                if (m.userData?.updateUniforms) {
-                    m.userData.updateUniforms(object, camera);
-                }
-            });
-        } else if (mat.userData?.updateUniforms) {
-            mat.userData.updateUniforms(object, camera);
-        }
-    }
-
     onEnable(): void {
-        this.context.addBeforeRenderListener(this.gameObject, this._onBeforeRender);
+        this.context.addBeforeRenderListener(this.gameObject, this.onBeforeRenderThree);
     }
 
     onDisable(): void {
-        this.context.removeBeforeRenderListener(this.gameObject, this._onBeforeRender);
+        this.context.removeBeforeRenderListener(this.gameObject, this.onBeforeRenderThree);
     }
 
-    _onBeforeRender = () => {
+    onBeforeRenderThree = () => {
         // Update uniforms or perform any pre-render logic here
         const gameObject = this.gameObject as any as Mesh;
         const material = gameObject?.material;
 
         const camera = this.context.mainCamera;
         if (!camera) return;
-        
-        MaterialXUniformUpdate.updateMaterial(material, gameObject, camera);
+
+        const env = state.materialXEnvironment;
+
+        if (Array.isArray(material)) {
+            for (const entry of material) {
+                if (entry && entry instanceof MaterialXMaterial) {
+                    entry.updateUniforms(this.context, env, this.gameObject, camera);
+                }
+            }
+        } else if (material instanceof MaterialXMaterial) {
+            material.updateUniforms(this.context, env, this.gameObject, camera);
+        }
     }
 }
 
@@ -54,14 +53,18 @@ export class MaterialXLoaderPlugin implements INeedleGLTFExtensionPlugin {
         // Register the MaterialX loader extension
         // Environment initialization is now handled in the MaterialXLoader constructor
         loader.register(p => {
-            this.loader = new MaterialXLoader(p, context);
+            this.loader = new MaterialXLoader(p, url, context);
             return this.loader;
         });
     };
 
-    onLoaded = (url: string, gltf: GLTF, context: Context) => {
-        if (debug) console.log("[MaterialX] MaterialXLoaderPlugin: glTF loaded", url, gltf.scene);
+    onLoaded = (url: string, gltf: GLTF, _context: Context) => {
+        if (debug) console.log("[MaterialX] MaterialXLoaderPlugin: glTF loaded", { url, scene: gltf.scene, materialX_root_data: this.loader?.materialX_root_data });
 
+        // If we don't have MaterialX data in the loaded glTF we don't need to do anything else here
+        if (!this.loader?.materialX_root_data) {
+            return;
+        }
         // Set up onBeforeRender callbacks for objects with MaterialX materials
         // This ensures uniforms are updated properly during rendering
         gltf.scene.traverse((child) => {
@@ -69,7 +72,7 @@ export class MaterialXLoaderPlugin implements INeedleGLTFExtensionPlugin {
                 const mesh = child as Mesh;
                 const material = mesh.material as Material;
 
-                if (material?.userData?.updateUniforms) {
+                if (material instanceof MaterialXMaterial) {
                     if (debug) console.log("[MaterialX] Adding MaterialX uniform update component to:", child.name);
                     child.addComponent(MaterialXUniformUpdate);
                 }
@@ -77,13 +80,6 @@ export class MaterialXLoaderPlugin implements INeedleGLTFExtensionPlugin {
         });
 
         if (debug) console.log("[MaterialX] Loaded: ", this.loader);
-
-        // Initialize MaterialX lighting system with scene data
-        const environment = state.materialXEnvironment;
-        environment.initializeFromContext(context).then(() => {
-            console.warn("[MaterialX] Environment initialized...");
-            this.loader?.updateLightingFromEnvironment(environment);
-        });
     };
 
     onExport = (_exporter: GLTFExporter, _context: Context) => {

package/src/loader/loader.three.ts

@@ -1,46 +1,72 @@
-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 { 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 { ready, MaterialXEnvironment, state } from "../materialx.js";
 import { debug } from "../utils.js";
+import { MaterialXMaterial } from "../materialx.material.js";
 
 // TypeScript interfaces matching the C# data structures
-interface MaterialX_root_extension {
+export type 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 }>;
 }
 
-interface MaterialX_material_extension {
+export type MaterialX_material_extension = {
     name: string; // Material name reference
 }
 
 // MaterialX loader extension for js GLTFLoader
 export class MaterialXLoader implements GLTFLoaderPlugin {
-    name = "NEEDLE_materials_mtlx";
+    readonly name = "NEEDLE_materials_mtlx";
+
+    private readonly _generatedMaterials: MaterialXMaterial[] = [];
 
-    // 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;
     }
 
-    constructor(private parser: GLTFParser, private context: Context) {
+    /** Generated materialX materials */
+    get materials() {
+        return this._generatedMaterials;
+    }
+
+    /**
+     * MaterialXLoader constructor
+     * @param parser The GLTFParser instance
+     * @param url The URL of the GLTF file
+     * @param context The context for the GLTF loading process
+     */
+    constructor(private parser: GLTFParser, private url: string, private context: Context) {
         if (debug) console.log("MaterialXLoader created for parser");
         // Start loading of MaterialX environment if the root extension exists
-        const hasMaterialXExtension = this.parser.json.extensions?.[this.name] != null;
-        if (hasMaterialXExtension) {
+        if (this.materialX_root_data) {
             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) {
@@ -72,16 +98,6 @@ 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];
@@ -92,7 +108,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
@@ -101,22 +117,22 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
         return fallbackMaterial;
     }
 
-    private async createMaterialXMaterial(materialXData: MaterialX_material_extension): Promise<Material> {
+    private async _createMaterialXMaterial(material_extension: MaterialX_material_extension): Promise<Material> {
         try {
-            if (debug) console.log(`Creating MaterialX material: ${materialXData.name}`);
+            if (debug) console.log(`Creating MaterialX material: ${material_extension.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 = materialXData;
-                fallbackMaterial.name = `MaterialX_Fallback_${materialXData.name}`;
+                fallbackMaterial.userData.materialX = material_extension;
+                fallbackMaterial.name = `MaterialX_Fallback_${material_extension.name}`;
                 return fallbackMaterial;
             }
 
             // Find the renderable element following MaterialX example pattern exactly
-            let renderableElement = null;
+            let renderableElement: any = null;
             let foundRenderable = false;
 
             if (debug) console.log("[MaterialX] document", doc);
@@ -134,7 +150,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
                     if (debug) console.log('[MaterialX] Scan material: ', i, materialName);
 
                     // Find the matching material
-                    if (materialName == materialXData.name) {
+                    if (materialName == material_extension.name) {
                         renderableElement = materialNode;
                         foundRenderable = true;
                         if (debug) console.log('[MaterialX] -- add material: ', materialName);
@@ -193,8 +209,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 = materialXData;
-                fallbackMaterial.name = `MaterialX_NoRenderable_${materialXData.name}`;
+                fallbackMaterial.userData.materialX = material_extension;
+                fallbackMaterial.name = `MaterialX_NoRenderable_${material_extension.name}`;
                 return fallbackMaterial;
             }
 
@@ -209,267 +225,56 @@ 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);
-
-            // 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,
+            const shaderMaterial = new MaterialXMaterial({
+                name: material_extension.name,
+                shader,
                 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;
-                }
+                loaders: {
+                    cacheKey: this.url,
+                    getTexture: async url => {
+                        // 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 (lightData && uniforms.u_lightData) {
-                    uniforms.u_lightData.value = lightData;
-                    if (debug) console.log("Updating light data for material", shaderMaterial.name, lightData, shaderMaterial.uniforms);
+                            if (index < 0) {
+                                console.error("[MaterialX] Texture not found in parser:", filenameWithoutExt, this.parser.json);
+                                return;
+                            }
+                            return this.parser.getDependency("texture", index).then(tex => {
+                                if (debug) console.log("[MaterialX] Texture loaded:" + tex.name, tex);
+                                return tex;
+                            });
+                        }
+                        return null;
+                    }
                 }
-
-                // Mark uniforms as needing update
-                shaderMaterial.uniformsNeedUpdate = true;
-            };
-
-            this.context.pre_update_callbacks.push(() => {
-                const environment = state.materialXEnvironment;
-                environment.updateLighting(false);
             });
-
-            shaderMaterial.name = `MaterialX_Generated_${materialXData.name}`;
-
-            // Add debugging to see if the material compiles correctly
-            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);
+            this._generatedMaterials.push(shaderMaterial);
 
+            // Add debugging to see if the material compiles correctly
+            if (debug) console.log("[MaterialX]  material created:", shaderMaterial.name);
             return shaderMaterial;
 
         } catch (error) {
@@ -477,65 +282,9 @@ 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 = materialXData;
-            fallbackMaterial.name = `MaterialX_Error_${materialXData.name}`;
+            fallbackMaterial.userData.materialX = material_extension;
+            fallbackMaterial.name = `MaterialX_Error_${material_extension.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)
-        });
-    }
 }