@needle-tools/materialx 1.3.2 → 1.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/materialx",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",

package/src/loader/loader.three.d.ts

@@ -70,7 +70,7 @@ export declare function useNeedleMaterialX(
 
 export declare function createMaterialXMaterial(
     mtlx: string, 
-    materialNodeName: string, 
+    materialNodeName: string | number, 
     loaders: Callbacks, 
     options?: MaterialXLoaderOptions, 
     context?: MaterialXContext

package/src/loader/loader.three.js

@@ -199,22 +199,22 @@ async function load(mtlx) {
 
 /**
  * @param {string} mtlx
- * @param {string} materialNodeName
+ * @param {string | number} materialNodeNameOrIndex
  * @param {import('../materialx.helper.js').Callbacks} loaders
  * @param {MaterialXLoaderOptions} [options]
  * @param {import('../materialx.js').MaterialXContext} [context]
  * @returns {Promise<Material>}
  */
-export async function createMaterialXMaterial(mtlx, materialNodeName, loaders, options, context) {
+export async function createMaterialXMaterial(mtlx, materialNodeNameOrIndex, loaders, options, context) {
     try {
-        if (debug) console.log(`Creating MaterialX material: ${materialNodeName}`);
+        if (debug) console.log(`Creating MaterialX material: ${materialNodeNameOrIndex}`);
 
         const doc = await load(mtlx);
 
         if (!state.materialXModule || !state.materialXGenerator || !state.materialXGenContext) {
             console.warn("[MaterialX] WASM module not ready, returning fallback material");
             const fallbackMaterial = new MeshStandardMaterial();
-            fallbackMaterial.name = `MaterialX_Fallback_${materialNodeName}`;
+            fallbackMaterial.name = `MaterialX_Fallback_${materialNodeNameOrIndex}`;
             return fallbackMaterial;
         }
 
@@ -236,8 +236,8 @@ export async function createMaterialXMaterial(mtlx, materialNodeName, loaders, o
                 if (debug) console.log(`[MaterialX] Scan material[${i}]: ${name}`);
 
                 // Find the matching material
-                if (materialNodes.length === 1 || name == materialNodeName) {
-                    materialNodeName = name;
+                if (materialNodes.length === 1 || name == materialNodeNameOrIndex || i === materialNodeNameOrIndex) {
+                    materialNodeNameOrIndex = name;
                     renderableElement = materialNode;
                     foundRenderable = true;
                     if (debug) console.log(`[MaterialX] Use material node: '${name}'`);
@@ -294,10 +294,17 @@ export async function createMaterialXMaterial(mtlx, materialNodeName, loaders, o
         */
 
         if (!renderableElement) {
-            console.warn(`[MaterialX] No renderable element found in MaterialX document (${materialNodeName})`);
+            console.warn(`[MaterialX] No renderable element found in MaterialX document (${materialNodeNameOrIndex}) → Please provide a name or index. Options: ${materialNodes.map(n => n.getNamePath()).join(", ")}`);
             const fallbackMaterial = new MeshStandardMaterial();
             fallbackMaterial.color.set(0xff00ff);
-            fallbackMaterial.name = `MaterialX_NoRenderable_${materialNodeName}`;
+            fallbackMaterial.name = `MaterialX_NoRenderable_${materialNodeNameOrIndex}`;
+            return fallbackMaterial;
+        }
+        else if(typeof materialNodeNameOrIndex === "number") {
+            console.warn(`[MaterialX] Material node not found by index (${materialNodeNameOrIndex}), using first renderable element: ${renderableElement.getNamePath()}`);
+            const fallbackMaterial = new MeshStandardMaterial();
+            fallbackMaterial.color.set(0xff00ff);
+            fallbackMaterial.name = `MaterialX_NodeNotFound_${materialNodeNameOrIndex}`;
             return fallbackMaterial;
         }
 
@@ -314,7 +321,7 @@ export async function createMaterialXMaterial(mtlx, materialNodeName, loaders, o
         const shader = state.materialXGenerator.generate(elementName, renderableElement, state.materialXGenContext);
 
         const shaderMaterial = new MaterialXMaterial({
-            name: materialNodeName,
+            name: materialNodeNameOrIndex,
             shaderName: null, //shaderInfo?.originalName || shaderInfo?.name || null,
             shader,
             context: context || {},
@@ -331,11 +338,11 @@ export async function createMaterialXMaterial(mtlx, materialNodeName, loaders, o
 
     } catch (error) {
         // This is a wasm error (an int) that we need to resolve
-        console.error(`[MaterialX] Error creating MaterialX material (${materialNodeName}):`, error);
+        console.error(`[MaterialX] Error creating MaterialX material (${materialNodeNameOrIndex}):`, error);
         // Return a fallback material with stored MaterialX data
         const fallbackMaterial = new MeshStandardMaterial();
         fallbackMaterial.color.set(0xff00ff);
-        fallbackMaterial.name = `MaterialX_Error_${materialNodeName}`;
+        fallbackMaterial.name = `MaterialX_Error_${materialNodeNameOrIndex}`;
         return fallbackMaterial;
     }
 }