@needle-tools/materialx 1.0.1-next.2ca9014 → 1.0.1-next.31390e3

package/codegen/register_types.ts

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

package/index.ts

@@ -2,4 +2,4 @@ import { registerNeedleLoader } from "./src/loader/loader.needle.js";
 
 registerNeedleLoader();
 
-export { initializeMaterialX, getMaterialXEnvironment } from "./src/index.js";
+export { ready, getMaterialXEnvironment } from "./src/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/materialx",
-  "version": "1.0.1-next.2ca9014",
+  "version": "1.0.1-next.31390e3",
   "type": "module",
   "main": "index.ts",
   "exports": {
@@ -8,7 +8,11 @@
       "import": "./index.ts",
       "require": "./index.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./codegen/register_types.ts": {
+      "import": "./codegen/register_types.ts",
+      "require": "./codegen/register_types.js"
+    }
   },
   "peerDependencies": {
     "@needle-tools/engine": "4.x",

package/src/index.ts

@@ -1,5 +1,5 @@
-import { initializeMaterialX, state } from "./materialx.js";
+import { ready, state } from "./materialx.js";
 
 const getMaterialXEnvironment = () => state.materialXEnvironment;
 
-export { initializeMaterialX, getMaterialXEnvironment };
+export { ready, getMaterialXEnvironment };

package/src/loader/loader.needle.ts

@@ -68,7 +68,7 @@ export class MaterialXLoaderPlugin implements INeedleGLTFExtensionPlugin {
     };
 
     onLoaded = (url: string, gltf: GLTF, _context: Context) => {
-        if (debug) console.log("MaterialXLoaderPlugin: glTF loaded", url, gltf.scene);
+        if (debug) console.log("[MaterialX] MaterialXLoaderPlugin: glTF loaded", url, gltf.scene);
 
         // Set up onBeforeRender callbacks for objects with MaterialX materials
         // This ensures uniforms are updated properly during rendering
@@ -78,13 +78,13 @@ export class MaterialXLoaderPlugin implements INeedleGLTFExtensionPlugin {
                 const material = mesh.material as Material;
 
                 if (material?.userData?.updateUniforms) {
-                    if (debug) console.log("Adding MaterialX uniform update component to:", child.name);
+                    if (debug) console.log("[MaterialX] Adding MaterialX uniform update component to:", child.name);
                     child.addComponent(MaterialXUniformUpdate);
                 }
             }
         });
 
-        if (debug) console.log("Loaded: ", this.mtlxLoader);
+        if (debug) console.log("[MaterialX] Loaded: ", this.mtlxLoader);
 
         // Initialize MaterialX lighting system with scene data
         const environment = state.materialXEnvironment;
@@ -96,7 +96,7 @@ export class MaterialXLoaderPlugin implements INeedleGLTFExtensionPlugin {
     };
 
     onExport = (_exporter: GLTFExporter, _context: Context) => {
-        console.log("TODO: MaterialXLoaderPlugin: Setting up export extensions");
+        console.log("[MaterialX] TODO: MaterialXLoaderPlugin: Setting up export extensions");
         // TODO: Add MaterialX export functionality if needed
     };
 }

package/src/loader/loader.three.ts

@@ -2,7 +2,7 @@ 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 { initializeMaterialX, MaterialXEnvironment, state } from "../materialx.js";
+import { ready, MaterialXEnvironment, state } from "../materialx.js";
 import { debug } from "../utils.js";
 
 // TypeScript interfaces matching the C# data structures
@@ -37,22 +37,22 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
     private async initializeEnvironment(): Promise<void> {
         if (this.environmentInitialized) return;
 
-        if (debug) console.log("MaterialXLoader: Initializing MaterialX environment...");
+        if (debug) console.log("[MaterialX] MaterialXLoader: Initializing MaterialX environment...");
 
         // Ensure MaterialX is initialized first
-        await initializeMaterialX();
+        await ready();
 
         // Set up environment with context
         const environment = state.materialXEnvironment;
-        environment.setContext(this.context);
+        environment.context = this.context;
 
         // Initialize the environment from context (properly awaited)
         try {
             await environment.initializeFromContext();
             this.environmentInitialized = true;
-            if (debug) console.log("MaterialXLoader: Environment initialized successfully");
+            if (debug) console.log("[MaterialX] MaterialXLoader: Environment initialized successfully");
         } catch (error) {
-            console.warn("MaterialXLoader: Failed to initialize MaterialX environment:", error);
+            console.warn("[MaterialX] MaterialXLoader: Failed to initialize MaterialX environment:", error);
         }
     }
 
@@ -62,7 +62,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
 
         const gltfExtensions = this.parser.json.extensions;
         if (gltfExtensions?.[this.name]) {
-            if (debug) console.log("MaterialX extension found in root:", gltfExtensions[this.name]);
+            if (debug) console.log("[MaterialX] extension found in root:", gltfExtensions[this.name]);
 
             const materialXExtension = gltfExtensions[this.name];
             this.rootMaterialXData = materialXExtension as MaterialXData;
@@ -79,13 +79,13 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
         this.documentParsePromise = (async () => {
             if (this.parsedDocument) return this.parsedDocument;
 
-            if (debug) console.log("Parsing MaterialX root document...");
+            if (debug) console.log("[MaterialX] Parsing MaterialX root document...");
 
             // Ensure MaterialX is initialized
-            await initializeMaterialX();
+            await ready();
 
             if (!state.materialXModule) {
-                throw new Error("MaterialX module failed to initialize");
+                throw new Error("[MaterialX] module failed to initialize");
             }
 
             // Create MaterialX document and parse ALL the XML data from root
@@ -94,11 +94,11 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
 
             // Parse all MaterialX XML strings from the root data
             if (this.rootMaterialXData) {
-                if (debug) console.log(`Parsing MaterialX XML for: ${this.rootMaterialXData.name}`);
+                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");
+            if (debug) console.log("[MaterialX] root document parsed successfully");
 
             this.parsedDocument = doc;
             return doc;
@@ -122,7 +122,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
         this.initializeRootData();
 
         const materialDef = this.parser.json.materials?.[materialIndex];
-        if (debug) console.log("MaterialX extension found in material:", materialDef.extensions[this.name]);
+        if (debug) console.log("[MaterialX] extension found in material:", materialDef.extensions[this.name]);
 
         // Handle different types of MaterialX data
         const dataIndex = materialDef.extensions[this.name] as MaterialXDataIndex;
@@ -144,7 +144,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             if (debug) console.log(`Creating MaterialX material: ${materialXData.name}`);
 
             // Ensure MaterialX is initialized and document is parsed
-            await initializeMaterialX();
+            await ready();
 
             if (!this.rootDocument) {
                 this.rootDocument = this.parseRootDocument();
@@ -152,7 +152,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             const doc = await this.rootDocument;
 
             if (!state.materialXModule || !state.materialXGenerator || !state.materialXGenContext) {
-                console.warn("MaterialX WASM module not ready, returning fallback material");
+                console.warn("[MaterialX] WASM module not ready, returning fallback material");
                 const fallbackMaterial = new MeshStandardMaterial();
                 fallbackMaterial.userData.materialX = materialXData;
                 fallbackMaterial.name = `MaterialX_Fallback_${materialXData.name}`;
@@ -163,11 +163,11 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             let renderableElement = null;
             let foundRenderable = false;
 
-            if (debug) console.log("Mtlx doc", doc);
+            if (debug) console.log("[MaterialX] document", doc);
 
             // Search for material nodes first (following the reference pattern)
             const materialNodes = doc.getMaterialNodes();
-            if (debug) console.log(`Found ${materialNodes.length} material nodes in document`, materialNodes);
+            if (debug) console.log(`[MaterialX] Found ${materialNodes.length} material nodes in document`, materialNodes);
 
             // Handle both array and vector-like APIs
             const materialNodesLength = materialNodes.length;
@@ -175,13 +175,13 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
                 const materialNode = materialNodes[i];
                 if (materialNode) {
                     const materialName = materialNode.getNamePath();
-                    if (debug) console.log('Scan material: ', i, materialName);
+                    if (debug) console.log('[MaterialX] Scan material: ', i, materialName);
 
                     // Find the matching material
                     if (materialName == materialXData.name) {
                         renderableElement = materialNode;
                         foundRenderable = true;
-                        if (debug) console.log('-- add material: ', materialName);
+                        if (debug) console.log('[MaterialX] -- add material: ', materialName);
                         break;
                     }
                 }
@@ -235,21 +235,21 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             */
 
             if (!renderableElement) {
-                console.warn("No renderable element found in MaterialX document");
+                console.warn("[MaterialX] No renderable element found in MaterialX document");
                 const fallbackMaterial = new MeshStandardMaterial();
                 fallbackMaterial.userData.materialX = materialXData;
                 fallbackMaterial.name = `MaterialX_NoRenderable_${materialXData.name}`;
                 return fallbackMaterial;
             }
 
-            if (debug) console.log("Using renderable element for shader generation");
+            if (debug) console.log("[MaterialX] Using renderable element for shader generation");
 
             // Check transparency and set context options like the reference
             let isTransparent = state.materialXModule.isTransparentSurface(renderableElement, state.materialXGenerator.getTarget());
             state.materialXGenContext.getOptions().hwTransparency = isTransparent;
             
             // Generate shaders using the element's name path
-            if (debug) console.log("Generating MaterialX shaders...");
+            if (debug) console.log("[MaterialX] Generating MaterialX shaders...");
             const elementName = (renderableElement as any).getNamePath ? (renderableElement as any).getNamePath() : (renderableElement as any).getName();
 
             const shader = state.materialXGenerator.generate(elementName, renderableElement, state.materialXGenContext);
@@ -302,7 +302,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
     #include <colorspace_fragment>`);
 
             if (debug) {
-                console.group("Material: ", materialXData.name);
+                console.group("[MaterialX]: ", materialXData.name);
                 console.log("Vertex shader length:", vertexShader.length, vertexShader);
                 console.log("Fragment shader length:", fragmentShader.length, fragmentShader);
                 console.groupEnd();
@@ -341,17 +341,17 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
                     const textures = ext?.textures || [];
 
                     const index = textures.findIndex(tex => {
-                        if (debug) console.log("Checking texture:", tex.name, "against URL:", filenameWithoutExt);
+                        if (debug) console.log("[MaterialX] Checking texture:", tex.name, "against URL:", filenameWithoutExt);
                         return tex.name === filenameWithoutExt;
                     });
 
                     if (index < 0) {
-                        console.warn("Texture not found in parser:", filenameWithoutExt, this.parser.json);
+                        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("Texture loaded:", tex);
+                        if (debug) console.log("[MaterialX] Texture loaded:", tex);
                         // update the checkerboard texture with the loaded texture
                         checkerboardTexture.image = tex.image;
                         checkerboardTexture.needsUpdate = true;
@@ -396,7 +396,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             }
 
             const mips = Math.trunc(Math.log2(Math.max(radianceTexture?.width ?? 0, radianceTexture?.height ?? 0))) + 1;
-            if (debug) console.log("Radiance texture mips:", mips, "for texture size:", radianceTexture?.width, "x", radianceTexture?.height);
+            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' },
@@ -485,7 +485,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
             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("[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);
@@ -497,7 +497,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
 
         } catch (error) {
             // This is a wasm error (an int) that we need to resolve
-            console.error("Error creating MaterialX material:", error);
+            console.error("[MaterialX] Error creating MaterialX material:", error);
             // Return a fallback material with stored MaterialX data
             const fallbackMaterial = new MeshStandardMaterial();
             fallbackMaterial.userData.materialX = materialXData;
@@ -516,7 +516,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
         const radianceTexture = environment.getRadianceTexture() || null;
         const irradianceTexture = environment.getIrradianceTexture() || null;
 
-        if (debug) console.log(`Updating lighting for ${this.generatedMaterials.length} MaterialX materials`, {
+        if (debug) console.log(`[MaterialX] Updating lighting for ${this.generatedMaterials.length} MaterialX materials`, {
             lightData, radianceTexture, irradianceTexture,
         });
 
@@ -535,7 +535,7 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
                     material.uniforms.u_lightData = { value: null };
                 }
                 material.uniforms.u_lightData.value = lightData;
-                if (debug) console.log("Updated light data for material", material.name, lightData, material.uniforms, );
+                if (debug) console.log("[MaterialX] Updated light data for material", material.name, lightData, material.uniforms, );
             }
 
             // Update environment uniforms

package/src/materialx.ts

@@ -8,7 +8,7 @@ import { registerLights } from "./helper.js";
 
 // Global MaterialX module instance - initialized lazily
 export const state = new class {
-    materialXModule: any = null;
+    materialXModule: typeof MaterialX | null = null;
     materialXGenerator: any = null;
     materialXGenContext: any = null;
     materialXStdLib: any = null;
@@ -23,13 +23,13 @@ export const state = new class {
 }
 
 // Initialize MaterialX WASM module lazily
-export async function initializeMaterialX(): Promise<void> {
+export async function ready(): Promise<void> {
     if (state.materialXInitPromise) {
         return state.materialXInitPromise;
     }
     return state.materialXInitPromise = (async () => {
         if (state.materialXModule) return; // Already initialized
-        if (debug) console.log("Initializing MaterialX WASM module...");
+        if (debug) console.log("[MaterialX] Initializing WASM module...");
         try {
 
             const urls: Array<string> = await Promise.all([
@@ -44,7 +44,7 @@ export async function initializeMaterialX(): Promise<void> {
 
             const module = await MaterialX({
                 locateFile: (path: string, scriptDirectory: string) => {
-                    if (debug) console.debug("MaterialX locateFile called:", { path, scriptDirectory });
+                    if (debug) console.debug("[MaterialX]  locateFile called:", { path, scriptDirectory });
 
                     if (path.includes("JsMaterialXCore.wasm")) {
                         return JsMaterialXCore; // Use the URL for the core WASM file
@@ -59,7 +59,7 @@ export async function initializeMaterialX(): Promise<void> {
                     return scriptDirectory + path;
                 },
             });
-            if (debug) console.log("MaterialXLoader module loaded", module);
+            if (debug) console.log("[MaterialX] module loaded", module);
             state.materialXModule = module;
 
             // Initialize shader generator and context
@@ -74,12 +74,12 @@ export async function initializeMaterialX(): Promise<void> {
             // 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.
             // SPECULAR_ENVIRONMENT_FIS: Use Filtered Importance Sampling for specular environment/indirect lighting.
             // SPECULAR_ENVIRONMENT_PREFILTER: Use pre-filtered environment maps for specular environment/indirect lighting.
             state.materialXGenContext.getOptions().hwSpecularEnvironmentMethod = state.materialXModule.HwSpecularEnvironmentMethod.SPECULAR_ENVIRONMENT_FIS;
-            
+
             // TRANSMISSION_REFRACTION: Use a refraction approximation for transmission rendering.
             // TRANSMISSION_OPACITY: Use opacity for transmission rendering.
             // state.materialXGenContext.getOptions().hwTransmissionRenderMethod = state.materialXModule.HwTransmissionRenderMethod.TRANSMISSION_REFRACTION;
@@ -98,9 +98,9 @@ export async function initializeMaterialX(): Promise<void> {
             // This prewarms the shader generation context to have all light types
             await registerLights(state.materialXModule, [], state.materialXGenContext);
 
-            if (debug) console.log("MaterialX generator initialized successfully");
+            if (debug) console.log("[MaterialX]  generator initialized successfully");
         } catch (error) {
-            console.error("Failed to load MaterialX module:", error);
+            console.error("[MaterialX] Failed to load MaterialX module:", error);
             throw error;
         }
     })();
@@ -108,42 +108,39 @@ export async function initializeMaterialX(): Promise<void> {
 
 // MaterialX Environment Manager - handles lighting and environment setup
 export class MaterialXEnvironment {
+    context: Context | null = null;
+
     private lightData: any = null;
     private lightCount: number = 0;
     private radianceTexture: any = null;
     private irradianceTexture: any = null;
-    private context: Context | null = null;
     private initialized: boolean = false;
 
     constructor() {
-        if (debug) console.log("MaterialX Environment created");
-    }
-
-    setContext(context: Context) {
-        this.context = context;
+        if (debug) console.log("[MaterialX] Environment created");
     }
 
     // Initialize with Needle Engine context
     async initializeFromContext(): Promise<void> {
         if (!this.context) {
-            console.warn("No Needle context available for MaterialX environment initialization");
+            console.warn("[MaterialX] No Needle context available for environment initialization");
             return;
         }
 
         // Prevent multiple initializations
         if (this.initialized) {
-            if (debug) console.log("MaterialX environment already initialized, skipping");
+            if (debug) console.log("[MaterialX] environment already initialized, skipping");
             return;
         }
 
         // Clean up previous textures if they exist
         if (this.radianceTexture) {
-            if (debug) console.log("Disposing previous radiance texture");
+            if (debug) console.log("[MaterialX] Disposing previous radiance texture");
             this.radianceTexture.dispose();
             this.radianceTexture = null;
         }
         if (this.irradianceTexture) {
-            if (debug) console.log("Disposing previous irradiance texture");
+            if (debug) console.log("[MaterialX] Disposing previous irradiance texture");
             this.irradianceTexture.dispose();
             this.irradianceTexture = null;
         }
@@ -175,20 +172,19 @@ export class MaterialXEnvironment {
             console.log({ radiance: this.radianceTexture, irradiance: this.irradianceTexture });
             // Show both of them on cubes in the scene
             const unlitMat = new MeshBasicMaterial();
+            unlitMat.side = 2;
             const radianceMat = unlitMat.clone();
             radianceMat.map = this.radianceTexture;
-            const radianceCube = ObjectUtils.createPrimitive("Cube", { material: radianceMat });
+            const radianceCube = ObjectUtils.createPrimitive("Quad", { material: radianceMat });
             const irradianceMat = unlitMat.clone();
             irradianceMat.map = this.irradianceTexture;
-            const irradianceCube = ObjectUtils.createPrimitive("Cube", { material: irradianceMat });
+            const irradianceCube = ObjectUtils.createPrimitive("Quad", { material: irradianceMat });
             this.context.scene.add(radianceCube);
             this.context.scene.add(irradianceCube);
             radianceCube.position.set(2, 0, 0);
-            radianceCube.scale.y = 0.00001;
             irradianceCube.position.set(-2, 0, 0);
-            irradianceCube.scale.y = 0.00001;
             // await this.initializeLighting(defaultLightRigXml, renderer);
-            console.log("MaterialX environment initialized from Needle context", this, this.context.scene);
+            console.log("[MaterialX] environment initialized from Needle context", this, this.context.scene);
         }
 
         // Find lights in scene
@@ -216,7 +212,7 @@ export class MaterialXEnvironment {
 
     // Reset the environment to allow re-initialization
     reset() {
-        if (debug) console.log("Resetting MaterialX environment");
+        if (debug) console.log("[MaterialX] Resetting environment");
         if (this.radianceTexture) {
             this.radianceTexture.dispose();
             this.radianceTexture = null;