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

package/package.json

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

package/src/helper.js

@@ -291,22 +291,24 @@ export function findLights(doc)
     return lights;
 }
 
-let lightTypesBound = {};
-
 /**
  * Register lights in shader generation context
  * @param {Object} mx MaterialX Module
+ * @param {Array.<mx.Node>} lights Light nodes
  * @param {mx.GenContext} genContext Shader generation context
  * @returns {Array.<mx.Node>}
  */
-export async function registerLights(mx, genContext)
+export async function registerLights(mx, lights, genContext)
 {
-    lightTypesBound = {};
-    const maxLightCount = genContext.getOptions().hwMaxActiveLightSources;
-
     mx.HwShaderGenerator.unbindLightShaders(genContext);
+    // TODO Remove, not sure why we need that – something resets the value inbetween calls to registerLights
+    genContext.getOptions().hwMaxActiveLightSources = 4;
 
+    const lightTypesBound = {};
+    const lightData = [];
     let lightId = 1;
+    let lightCount = 0;
+    const maxLightCount = genContext.getOptions().hwMaxActiveLightSources;
 
     // All light types so that we have NodeDefs for them
     const defaultLightRigXml = `<?xml version="1.0"?>
@@ -331,8 +333,7 @@ export async function registerLights(mx, genContext)
     document.setDataLibrary(stdlib);
     document.importLibrary(lightRigDoc);
     const defaultLights = findLights(document);
-    // if (debug) 
-        console.log("Default lights in MaterialX document", defaultLights);
+    if (debug) console.log("Default lights in MaterialX document", defaultLights);
 
     // Loading a document seems to reset this option for some reason, so we set it again
     genContext.getOptions().hwMaxActiveLightSources = maxLightCount;
@@ -357,34 +358,52 @@ export async function registerLights(mx, genContext)
     }
 
     if (debug) console.log("Light types bound in MaterialX context", lightTypesBound);
-}
 
-// Converts Three.js light type to MaterialX node name
-function threeLightTypeToMaterialXNodeName(threeLightType) {
-    switch (threeLightType) {
-        case 'PointLight':
-            return 'ND_point_light';
-        case 'DirectionalLight':
-            return 'ND_directional_light';
-        case 'SpotLight':
-            return 'ND_spot_light';
-        default:
-            console.warn('MaterialX: Unsupported light type: ' + threeLightType);
-            return 'ND_point_light'; // Default to point light
+    // MaterialX light nodes
+    for (let light of lights)
+    {
+        // Skip if light does not have a node definition
+        if (!("getNodeDef" in light)) continue;
+
+        let nodeDef = light.getNodeDef();
+        let nodeName = nodeDef.getName();
+        if (!lightTypesBound[nodeName])
+        {
+            if (debug) console.log("bind light shader for node", { nodeName, lightId, nodeDef });
+            lightTypesBound[nodeName] = lightId;
+            mx.HwShaderGenerator.bindLightShader(nodeDef, lightId++, genContext);
+        }
+
+        const lightDirection = light.getValueElement("direction").getValue().getData().data();
+        const lightColor = light.getValueElement("color").getValue().getData().data();
+        const lightIntensity = light.getValueElement("intensity").getValue().getData();
+
+        let rotatedLightDirection = new THREE.Vector3(...lightDirection)
+        rotatedLightDirection.transformDirection(getLightRotation())
+
+        lightData.push({
+            type: lightTypesBound[nodeName],
+            direction: rotatedLightDirection,
+            color: new THREE.Vector3(...lightColor),
+            intensity: lightIntensity,
+        });
     }
-};
 
-/**
- * Update light data for shader uniforms
- * @param {Object} mx MaterialX Module
- * @param {Array.<mx.Node>} lights Light nodes
- * @param {mx.GenContext} genContext Shader generation context
- * @returns {{ lightData: Array<any>, lightCount: number }}
- */
-export function getLightData(mx, lights, genContext)
-{
-    const lightData = [];
-    const maxLightCount = genContext.getOptions().hwMaxActiveLightSources;
+    const threeLightTypeToMaterialXNodeName = (threeLightType) => {
+        switch (threeLightType) {
+            case 'PointLight':
+                return 'ND_point_light';
+            case 'DirectionalLight':
+                return 'ND_directional_light';
+            case 'SpotLight':
+                return 'ND_spot_light';
+            default:
+                console.warn('MaterialX: Unsupported light type: ' + threeLightType);
+                return 'ND_point_light'; // Default to point light
+        }
+    };
+
+    if (debug) console.log("Registering lights in MaterialX context", lights, lightData);
 
     // Three.js lights
     for (let light of lights) {
@@ -396,49 +415,48 @@ export function getLightData(mx, lights, genContext)
         const lightDefinitionName = threeLightTypeToMaterialXNodeName(light.type);
 
         if (!lightTypesBound[lightDefinitionName])
-            console.error("MaterialX: Light type not registered in context. Make sure to register light types before using them.", lightDefinitionName);
+        {
+            lightTypesBound[lightDefinitionName] = lightId;
+            const nodeDef = null;
+            mx.HwShaderGenerator.bindLightShader(nodeDef, lightId++, genContext);
+        }
 
         const wp = light.getWorldPosition(new THREE.Vector3());
         const wd = getWorldDirection(light, new THREE.Vector3(0,0,-1));
-
-        // console.log("Registering light", light.penumbra);
-
         lightData.push({
             type: lightTypesBound[lightDefinitionName],
             position: wp.clone(),
             direction: wd.clone(),
-            color: new THREE.Color().fromArray(light.color.toArray()),
-            // Luminous efficacy for converting radiant power in watts (W) to luminous flux in lumens (lm) at a wavelength of 555 nm.
-            // Also, three.js lights don't have PI scale baked in, but MaterialX does, so we need to divide by PI for point and spot lights.
-            intensity: light.intensity * (light.isPointLight ? 683.0 / 3.1415 : light.isSpotLight ? 683.0 / 3.1415: 1.0),
-            decay_rate: 2.0,
-            // Approximations for testing – the relevant light has 61.57986...129.4445 as inner/outer spot angle
-            inner_angle: 0.9,
-            outer_angle: 0.4,
+            color: new THREE.Vector3().fromArray(light.color.toArray()),
+            intensity: light.intensity, // Scale intensity for spot lights
+            decay_rate: 2.0, // physically-based default decay rate
+            inner_angle: 1.0,
+            outer_angle: 2.0,
         });
     }
 
     // Count the number of lights that are not empty
-    const lightCount = lightData.length;
+    lightCount = lightData.length;
 
     // If we don't have enough entries in lightData, fill with empty lights
-    while (lightData.length < maxLightCount) 
+    if (lightData.length < maxLightCount)
     {
         const emptyLight = {
             type: 0, // Default light type
             position: new THREE.Vector3(0, 0, 0),
             direction: new THREE.Vector3(0, 0, -1),
-            color: new THREE.Color(0, 0, 0),
-            intensity: 0.0,
-            decay_rate: 2.0,
-            inner_angle: 0.0,
-            outer_angle: 0.0,
+            color: new THREE.Vector3(0, 0, 0),
+            intensity: 0,
+            decay_rate: 2,
+            inner_angle: 0,
+            outer_angle: 0,
         };
-        lightData.push(emptyLight);
+        while (lightData.length < maxLightCount) {
+            lightData.push(emptyLight);
+        }
     }
 
-    if (debug) 
-        console.log("Registered lights in MaterialX context", lightTypesBound, lightData);
+    if (debug) console.log("Registered lights in MaterialX context", lightTypesBound, lightData);
 
     return { lightData, lightCount };
 }
@@ -450,12 +468,11 @@ export function getLightData(mx, lights, genContext)
  */
 export function getUniformValues(shaderStage, textureLoader, searchPath, flipY)
 {
-    const threeUniforms = {};
+    let threeUniforms = {};
 
     const uniformBlocks = Object.values(shaderStage.getUniformBlocks());
     uniformBlocks.forEach(uniforms =>
     {
-        // TODO Seems struct uniforms (like in LightData) end up here as well, we should filter those out.
         if (!uniforms.empty())
         {
             for (let i = 0; i < uniforms.size(); ++i)
@@ -463,7 +480,6 @@ export function getUniformValues(shaderStage, textureLoader, searchPath, flipY)
                 const variable = uniforms.get(i);
                 const value = variable.getValue()?.getData();
                 const name = variable.getVariable();
-                if (debug) console.log("Adding uniform", { name, value, type: variable.getType().getName() });
                 threeUniforms[name] = new THREE.Uniform(toThreeUniform(variable.getType().getName(), value, name, uniforms,
                     textureLoader, searchPath, flipY));
             }

package/src/loader/loader.needle.ts

@@ -38,8 +38,16 @@ export class MaterialXUniformUpdate extends Component {
 
         const camera = this.context.mainCamera;
         if (!camera) return;
-        
+
         MaterialXUniformUpdate.updateMaterial(material, gameObject, camera);
+
+        // If this is a Group, we need to update all direct children
+        if ((gameObject as any as Group).isGroup) {
+            gameObject.children.forEach((child: Object3D) => {
+                if (child instanceof Mesh && child.material)
+                    MaterialXUniformUpdate.updateMaterial(child.material, child, camera);
+            });
+        }
     }
 }
 
@@ -81,7 +89,6 @@ export class MaterialXLoaderPlugin implements INeedleGLTFExtensionPlugin {
         // Initialize MaterialX lighting system with scene data
         const environment = state.materialXEnvironment;
         environment.initializeFromContext(context).then(() => {
-            console.warn("[MaterialX] Environment initialized...");
             this.loader?.updateLightingFromEnvironment(environment);
         });
     };

package/src/loader/loader.three.ts

@@ -1,5 +1,5 @@
-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 { Context } from "@needle-tools/engine";
+import { ShaderMaterial, Material, MeshStandardMaterial, LoadingManager, TextureLoader, Texture, NearestFilter, Matrix4, GLSL3, AddEquation, OneMinusSrcAlphaFactor, SrcAlphaFactor, DoubleSide, Matrix3, Vector3, Object3D, Camera } from "three";
 import { GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader.js";
 import { getUniformValues } from "../helper.js";
 import { ready, MaterialXEnvironment, state } from "../materialx.js";
@@ -23,30 +23,63 @@ interface MaterialX_material_extension {
 export class MaterialXLoader implements GLTFLoaderPlugin {
     name = "NEEDLE_materials_mtlx";
 
-    // private rootMaterialXData: MaterialX_root_extension | null = null;
-    private _documentReadyPromise: Promise<any> | null = null;
+    private rootMaterialXData: MaterialX_root_extension | null = null;
+    private parsedDocument: any = null;
+    private documentParsePromise: Promise<any> | null = null;
+    private rootDataInitialized = false;
     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) {
         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) {
-            ready();
+        // Initialize MaterialX environment after MaterialX is ready
+        this.initializeEnvironment();
+    }
+
+    // Initialize MaterialX environment - called once after MaterialX is ready
+    private async initializeEnvironment(): Promise<void> {
+        if (this.environmentInitialized) return;
+
+        if (debug) console.log("[MaterialX] MaterialXLoader: Initializing MaterialX environment...");
+
+        // Ensure MaterialX is initialized first
+        await ready();
+
+        // Set up environment with context
+        const environment = state.materialXEnvironment;
+        // Initialize the environment from context (properly awaited)
+        try {
+            await environment.initializeFromContext(this.context);
+            this.environmentInitialized = true;
+            if (debug) console.log("[MaterialX] MaterialXLoader: Environment initialized successfully");
+        } catch (error) {
+            console.warn("[MaterialX] MaterialXLoader: Failed to initialize MaterialX environment:", error);
+        }
+    }
+
+    // Initialize root data from parser.json.extensions once
+    private initializeRootData(): void {
+        if (this.rootDataInitialized) return;
+
+        const gltfExtensions = this.parser.json.extensions;
+        if (gltfExtensions?.[this.name]) {
+            if (debug) console.log("[MaterialX] extension found in root:", gltfExtensions[this.name]);
+
+            const materialXExtension = gltfExtensions[this.name];
+            this.rootMaterialXData = materialXExtension as MaterialX_root_extension;
         }
+        this.rootDataInitialized = true;
     }
 
     // Parse the MaterialX document once and cache it
-    private async _materialXDocumentReady(): Promise<any> {
-        if (this._documentReadyPromise) {
-            return this._documentReadyPromise;
+    private async parseRootDocument(): Promise<any> {
+        if (this.documentParsePromise) {
+            return this.documentParsePromise;
         }
-        return this._documentReadyPromise = (async () => {
+
+        this.documentParsePromise = (async () => {
+            if (this.parsedDocument) return this.parsedDocument;
+
             if (debug) console.log("[MaterialX] Parsing MaterialX root document...");
 
             // Ensure MaterialX is initialized
@@ -61,15 +94,18 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             doc.setDataLibrary(state.materialXStdLib);
 
             // Parse all MaterialX XML strings from the root data
-            const root = this.materialX_root_data
-            if (root) {
-                if (debug) console.log(`[MaterialX] Parsing XML for: ${root.name}`);
-                await state.materialXModule.readFromXmlString(doc, root.mtlx, "");
+            if (this.rootMaterialXData) {
+                if (debug) console.log(`[MaterialX] Parsing XML for: ${this.rootMaterialXData.name}`);
+                await state.materialXModule.readFromXmlString(doc, this.rootMaterialXData.mtlx, "");
             }
 
             if (debug) console.log("[MaterialX] root document parsed successfully");
+
+            this.parsedDocument = doc;
             return doc;
         })();
+
+        return this.documentParsePromise;
     }
 
     loadMaterial(materialIndex: number): Promise<Material> | null {
@@ -83,6 +119,8 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
     }
 
     private async _loadMaterialAsync(materialIndex: number): Promise<Material> {
+        // Initialize root data first
+        this.initializeRootData();
 
         const materialDef = this.parser.json.materials?.[materialIndex];
         if (debug) console.log("[MaterialX] extension found in material:", materialDef.extensions[this.name]);
@@ -101,11 +139,18 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
         return fallbackMaterial;
     }
 
+    private rootDocument: Promise<any> | null = null;
     private async createMaterialXMaterial(materialXData: MaterialX_material_extension): Promise<Material> {
         try {
             if (debug) console.log(`Creating MaterialX material: ${materialXData.name}`);
 
-            const doc = await this._materialXDocumentReady();
+            // Ensure MaterialX is initialized and document is parsed
+            await ready();
+
+            if (!this.rootDocument) {
+                this.rootDocument = this.parseRootDocument();
+            }
+            const doc = await this.rootDocument;
 
             if (!state.materialXModule || !state.materialXGenerator || !state.materialXGenContext) {
                 console.warn("[MaterialX] WASM module not ready, returning fallback material");
@@ -201,7 +246,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             if (debug) console.log("[MaterialX] Using renderable element for shader generation");
 
             // Check transparency and set context options like the reference
-            const isTransparent = state.materialXModule.isTransparentSurface(renderableElement, state.materialXGenerator.getTarget());
+            let isTransparent = state.materialXModule.isTransparentSurface(renderableElement, state.materialXGenerator.getTarget());
             state.materialXGenContext.getOptions().hwTransparency = isTransparent;
 
             // Generate shaders using the element's name path
@@ -247,18 +292,9 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             // 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');
-
+            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,
                 `
@@ -280,8 +316,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
                 // Find the texture in the textures in the parser and load it from there
                 return url;
             });
-
-            const textureLoader = new TextureLoader(loadingManager);
+            let 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.
@@ -333,7 +368,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             const searchPath = ""; // Could be derived from the asset path if needed
             const flipV = false; // Set based on your geometry requirements
 
-            const uniforms = {
+            let uniforms = {
                 ...getUniformValues(shader.getStage('vertex'), textureLoader, searchPath, flipV),
                 ...getUniformValues(shader.getStage('pixel'), textureLoader, searchPath, flipV),
             };
@@ -349,12 +384,20 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
                 return new Matrix4();
             };
 
-            if (debug) console.log("Lights", { lightData, radianceTexture, irradianceTexture });
+            if (debug) console.log({ 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_numActiveLightSources: { value: lightData?.length || 0, type: 'i' },
+            });
+
+            if (lightData?.length) {
+                Object.assign(uniforms, {
+                    u_lightData: { value: lightData, type: 'v4v' },
+                });
             }
+
+            const mips = Math.trunc(Math.log2(Math.max(radianceTexture?.width ?? 0, radianceTexture?.height ?? 0))) + 1;
+            if (debug) 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' },
@@ -363,7 +406,6 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
                 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);
@@ -437,28 +479,10 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
                     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);
-            });
-
             shaderMaterial.name = `MaterialX_Generated_${materialXData.name}`;
 
             // Add debugging to see if the material compiles correctly
@@ -493,18 +517,14 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
         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,
-            });
-        }
+        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;
@@ -512,11 +532,13 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
 
             // Update light data if we have lights
             if (lightData) {
-                material.uniforms.u_lightData ??= new Uniform(null)
+                if (!material.uniforms.u_lightData) {
+                    material.uniforms.u_lightData = { value: 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);
+            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) {
@@ -535,7 +557,14 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             // Mark uniforms as needing update
             // console.log("Light data in uniforms", material.uniforms, material.fragmentShader);
             material.uniformsNeedUpdate = true;
-            console.log(material)
         });
+
+        /* TODO not working yet
+        this.generatedMaterials.forEach((material, index) => {
+            console.log("Regenerating shaders for MaterialX material:", index, material.name);
+            material.userData.regenerateShaders();
+            resetShaders(this.context);
+        });
+        */
     }
 }

package/src/materialx.ts

@@ -3,7 +3,7 @@ import MaterialX from "../bin/JsMaterialXGenShader.js";
 import { debug } from "./utils.js";
 import { renderPMREMToEquirect } from "./textureHelper.js";
 import { Light, MeshBasicMaterial, Object3D, PMREMGenerator, Texture } from "three";
-import { registerLights, getLightData } from "./helper.js";
+import { registerLights } from "./helper.js";
 
 
 export const state = new class {
@@ -71,6 +71,7 @@ export async function ready(): Promise<void> {
             tempDoc.setDataLibrary(state.materialXStdLib);
 
             // TODO ShaderInterfaceType.SHADER_INTERFACE_REDUCED would be better, but doesn't actually seem to be supported in the MaterialX javascript bindings
+            const options = state.materialXGenContext.getOptions();
             state.materialXGenContext.getOptions().shaderInterfaceType = state.materialXModule.ShaderInterfaceType.SHADER_INTERFACE_COMPLETE;
 
             // SPECULAR_ENVIRONMENT_NONE: Do not use specular environment maps.
@@ -94,8 +95,7 @@ export async function ready(): Promise<void> {
             state.materialXGenContext.getOptions().hwMaxActiveLightSources = 4;
 
             // This prewarms the shader generation context to have all light types
-            await registerLights(state.materialXModule, state.materialXGenContext);
-            // getLightData(state.materialXModule, [], state.materialXGenContext);
+            await registerLights(state.materialXModule, [], state.materialXGenContext);
 
             if (debug) console.log("[MaterialX]  generator initialized successfully");
         } catch (error) {
@@ -108,7 +108,6 @@ export async function ready(): Promise<void> {
 // MaterialX Environment Manager - handles lighting and environment setup
 export class MaterialXEnvironment {
     private _context: Context | null = null;
-    private _lights: Array<Light> = [];
     private _lightData: any = null;
     private _lightCount: number = 0;
     private _radianceTexture: Texture | null = null;
@@ -121,28 +120,45 @@ export class MaterialXEnvironment {
 
     // Initialize with Needle Engine context
     async initializeFromContext(context: Context): Promise<boolean> {
+
+        // Prevent multiple initializations
         if (this._initializePromise) {
+            if (debug) console.log("[MaterialX] environment already initialized, skipping");
             return this._initializePromise;
         }
+
         return this._initializePromise = this._initialize(context);
     }
 
     getLightData() { return this._lightData; }
     getLightCount() { return this._lightCount; }
-
+    
     setRadianceTexture(texture: Texture) { this._radianceTexture = texture; }
     getRadianceTexture() { return this._radianceTexture; }
 
     getIrradianceTexture() { return this._irradianceTexture; }
     setIrradianceTexture(texture: Texture) { this._irradianceTexture = texture; }
 
+    // Reset the environment to allow re-initialization
+    reset() {
+        if (debug) console.log("[MaterialX] Resetting environment");
+        if (this._radianceTexture) {
+            this._radianceTexture.dispose();
+            this._radianceTexture = null;
+        }
+        if (this._irradianceTexture) {
+            this._irradianceTexture.dispose();
+            this._irradianceTexture = null;
+        }
+        this._initializePromise = null;
+        // this.lights = [];
+        this._lightData = null;
+    }
+
     private _initialize: (context: Context) => Promise<boolean> = async (context: Context) => {
 
         this._context = context;
 
-        // Get renderer from context
-        const renderer = context.renderer;
-
         // Clean up previous textures if they exist
         if (this._radianceTexture) {
             if (debug) console.log("[MaterialX] Disposing previous radiance texture");
@@ -155,17 +171,22 @@ export class MaterialXEnvironment {
             this._irradianceTexture = null;
         }
 
+        // Get renderer from context
+        const renderer = this._context.renderer;
+
         // TODO remove this delay; we should wait for the scene lighting to be ready
         // and then update the uniforms
-        let envMap = context.scene.environment;
+        let envMap = this._context.scene.environment;
         while (!envMap) {
-            await delay(1000);
-            envMap = context.scene.environment;
+            await delay(200);
+            envMap = this._context.scene.environment;
         }
-        const pmrem = new PMREMGenerator(renderer);
+        var pmrem = new PMREMGenerator(renderer);
         const target = pmrem.fromEquirectangular(envMap);
+
         const radianceRenderTarget = renderPMREMToEquirect(renderer, target.texture, 0.0, 1024, 512, target.height);
         const irradianceRenderTarget = renderPMREMToEquirect(renderer, target.texture, 1.0, 32, 16, target.height);
+
         this._radianceTexture = radianceRenderTarget.texture;
         this._irradianceTexture = irradianceRenderTarget.texture;
 
@@ -184,50 +205,24 @@ export class MaterialXEnvironment {
             const irradianceMat = unlitMat.clone();
             irradianceMat.map = this._irradianceTexture;
             const irradianceCube = ObjectUtils.createPrimitive("Quad", { material: irradianceMat });
-            context.scene.add(radianceCube);
-            context.scene.add(irradianceCube);
+            this._context.scene.add(radianceCube);
+            this._context.scene.add(irradianceCube);
             radianceCube.position.set(2, 0, 0);
             irradianceCube.position.set(-2, 0, 0);
+            // await this.initializeLighting(defaultLightRigXml, renderer);
             console.log("[MaterialX] environment initialized from Needle context", this, this._context.scene);
         }
 
-        this.updateLighting(true);
-
-        // Mark as initialized
-        return true;
-    }
-
-    updateLighting(collectLights: boolean) {
-        if (!this._context) return;
-
         // Find lights in scene
-        if (collectLights) {
-            const lights = new Array<Light>();
-            this._context.scene.traverse((object: Object3D) => {
-                if ((object as Light).isLight && GameObject.isActiveInHierarchy(object))
-                    lights.push(object as Light);
-            });
-            this._lights = lights;
-        }
+        let lights = new Array<Light>();
+        this._context.scene.traverse((object: Object3D) => {
+            if ((object as Light).isLight && GameObject.isActiveInHierarchy(object))
+                lights.push(object as Light);
+        });
 
-        const { lightData, lightCount } = getLightData(state.materialXModule, this._lights, state.materialXGenContext);
+        const { lightData, lightCount } = await registerLights(state.materialXModule, lights, state.materialXGenContext);
         this._lightData = lightData;
         this._lightCount = lightCount;
-    }
-
-    // Reset the environment to allow re-initialization
-    reset() {
-        if (debug) console.log("[MaterialX] Resetting environment");
-        if (this._radianceTexture) {
-            this._radianceTexture.dispose();
-            this._radianceTexture = null;
-        }
-        if (this._irradianceTexture) {
-            this._irradianceTexture.dispose();
-            this._irradianceTexture = null;
-        }
-        this._initializePromise = null;
-        this._lights = [];
-        this._lightData = null;
+        return true;
     }
 }