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

package/src/loader/loader.needle.ts

@@ -6,21 +6,32 @@ 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 { MaterialXEnvironment, state } from "../materialx.js";
-import { MaterialXMaterial } from "../materialx.material.js";
+import { state } from "../materialx.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.onBeforeRenderThree);
+        this.context.addBeforeRenderListener(this.gameObject, this._onBeforeRender);
     }
 
     onDisable(): void {
-        this.context.removeBeforeRenderListener(this.gameObject, this.onBeforeRenderThree);
+        this.context.removeBeforeRenderListener(this.gameObject, this._onBeforeRender);
     }
 
-    onBeforeRenderThree = () => {
+    _onBeforeRender = () => {
         // Update uniforms or perform any pre-render logic here
         const gameObject = this.gameObject as any as Mesh;
         const material = gameObject?.material;
@@ -28,24 +39,22 @@ export class MaterialXUniformUpdate extends Component {
         const camera = this.context.mainCamera;
         if (!camera) return;
 
-        const env = state.materialXEnvironment;
+        MaterialXUniformUpdate.updateMaterial(material, gameObject, camera);
 
-        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);
+        // 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);
+            });
         }
     }
 }
 
 export class MaterialXLoaderPlugin implements INeedleGLTFExtensionPlugin {
-    readonly name = "MaterialXLoaderPlugin";
+    name = "MaterialXLoaderPlugin";
 
-    private loader: MaterialXLoader | null = null;
+    mtlxLoader: MaterialXLoader | null = null;
 
     onImport = (loader: GLTFLoader, url: string, context: Context) => {
         if (debug) console.log("MaterialXLoaderPlugin: Registering MaterialX extension for", url);
@@ -53,18 +62,14 @@ 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);
-            return this.loader;
+            this.mtlxLoader = new MaterialXLoader(p, context);
+            return this.mtlxLoader;
         });
     };
 
     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 (debug) console.log("MaterialXLoaderPlugin: glTF loaded", url, gltf.scene);
 
-        // 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) => {
@@ -72,18 +77,26 @@ export class MaterialXLoaderPlugin implements INeedleGLTFExtensionPlugin {
                 const mesh = child as Mesh;
                 const material = mesh.material as Material;
 
-                if (material instanceof MaterialXMaterial) {
-                    if (debug) console.log("[MaterialX] Adding MaterialX uniform update component to:", child.name);
+                if (material?.userData?.updateUniforms) {
+                    if (debug) console.log("Adding MaterialX uniform update component to:", child.name);
                     child.addComponent(MaterialXUniformUpdate);
                 }
             }
         });
 
-        if (debug) console.log("[MaterialX] Loaded: ", this.loader);
+        if (debug) console.log("Loaded: ", this.mtlxLoader);
+
+        // Initialize MaterialX lighting system with scene data
+        const environment = state.materialXEnvironment;
+        environment.initializeFromContext().then(() => {
+            if (this.mtlxLoader) {
+                this.mtlxLoader.updateLightingFromEnvironment(environment);
+            }
+        });
     };
 
     onExport = (_exporter: GLTFExporter, _context: Context) => {
-        console.log("[MaterialX] TODO: MaterialXLoaderPlugin: Setting up export extensions");
+        console.log("TODO: MaterialXLoaderPlugin: Setting up export extensions");
         // TODO: Add MaterialX export functionality if needed
     };
 }