@needle-tools/materialx 1.1.0 → 1.1.1-next.623fc20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/materialx",
-  "version": "1.1.0",
+  "version": "1.1.1-next.623fc20",
   "type": "module",
   "main": "index.ts",
   "exports": {
@@ -42,4 +42,4 @@
     "mtlx",
     "rendering"
   ]
-}
+}

package/src/loader/loader.three.ts

@@ -14,10 +14,19 @@ export type MaterialX_root_extension = {
     mtlx: string;
     /** MaterialX texture pointers */
     textures: Array<{ name: string, pointer: string }>;
+    shaders?: Array<{
+        /** The materialx node name */
+        name: string,
+        /** The original name of the shader */
+        originalName: string,
+    }>,
 }
 
 export type MaterialX_material_extension = {
-    name: string; // Material name reference
+    /** The MaterialX material name */
+    name: string;
+    /** The index of the shader in the shaders array of the root extension. */
+    shader?: number;
 }
 
 type MaterialDefinition = {
@@ -239,13 +248,23 @@ 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);
+
+            const rootExtension = this.materialX_root_data;
+
+            const shaderInfo = rootExtension && material_extension.shader !== undefined && material_extension.shader >= 0
+                ? rootExtension.shaders?.[material_extension.shader]
+                : null;
+
             const shaderMaterial = new MaterialXMaterial({
                 name: material_extension.name,
+                shaderName: shaderInfo?.originalName || shaderInfo?.name || null,
                 shader,
-                transparent: isTransparent,
-                side: material_def.doubleSided ? DoubleSide : FrontSide,
                 context: this.context,
-                precision: this.options.parameters?.precision,
+                parameters: {
+                    transparent: isTransparent,
+                    side: material_def.doubleSided ? DoubleSide : FrontSide,
+                    ...this.options.parameters,
+                },
                 loaders: {
                     cacheKey: this.options.cacheKey || "",
                     getTexture: async url => {
@@ -253,9 +272,8 @@ export class MaterialXLoader implements GLTFLoaderPlugin {
                         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 || [];
+                        if (rootExtension) {
+                            const textures = rootExtension.textures || [];
                             let index = -1;
                             for (const texture of textures) {
                                 // Find the texture by name and use the pointer string to get the index

package/src/materialx.helper.ts

@@ -466,12 +466,57 @@ export function getUniformValues(shaderStage: MaterialX.ShaderStage, loaders: Lo
             for (let i = 0; i < uniforms.size(); ++i) {
                 const variable = uniforms.get(i);
                 const value = variable.getValue()?.getData();
-                const name = variable.getVariable();
-                if (debug) console.log("Adding uniform", { path: variable.getPath(), name: name, value: value, type: variable.getType().getName() });
-                threeUniforms[name] = toThreeUniform(uniforms, variable.getType().getName(), value, name, loaders, searchPath);
+                const uniformName = variable.getVariable();
+                const type = variable.getType().getName();
+                if (debug) console.log("Adding uniform", { path: variable.getPath(), name: uniformName, value: value, type: type });
+                threeUniforms[uniformName] = toThreeUniform(uniforms, type, value, uniformName, loaders, searchPath);
             }
         }
     }
 
     return threeUniforms;
 }
+
+export function generateMaterialPropertiesForUniforms(material: THREE.ShaderMaterial, shaderStage: MaterialX.ShaderStage) {
+
+    const uniformBlocks = shaderStage.getUniformBlocks()
+    for (const [blockName, uniforms] of Object.entries(uniformBlocks)) {
+        // Seems struct uniforms (like in LightData) end up here as well, we should filter those out.
+        if (blockName === "LightData") continue;
+
+        if (!uniforms.empty()) {
+            for (let i = 0; i < uniforms.size(); ++i) {
+                const variable = uniforms.get(i);
+                const uniformName = variable.getVariable();
+                let key = variable.getPath().split('/').pop();
+                switch (key) {
+                    case "_Color":
+                        key = "color";
+                        break;
+                    case "_Roughness":
+                        key = "roughness";
+                        break;
+                    case "_Metallic":
+                        key = "metalness";
+                        break;
+                }
+                if (key) {
+                    Object.defineProperty(material, key, {
+                        get: function () {
+                            return this.uniforms?.[uniformName].value
+                        },
+                        set: function (v) {
+                            const uniforms = this.uniforms;
+                            if (!uniforms || !uniforms[uniformName]) {
+                                console.warn(`[MaterialX] Uniform ${uniformName} not found in ${this.name} uniforms`);
+                                return;
+                            }
+                            this.uniforms[uniformName].value = v;
+                            this.uniformsNeedUpdate = true;
+                        }
+                    });
+                }
+            }
+        }
+    }
+}

package/src/materialx.material.ts

@@ -1,7 +1,8 @@
 import { BufferGeometry, Camera, FrontSide, GLSL3, Group, IUniform, MaterialParameters, Matrix3, Matrix4, Object3D, Scene, ShaderMaterial, Texture, Vector3, WebGLRenderer } from "three";
 import { debug, getFrame, getTime } from "./utils.js";
 import { MaterialXContext, MaterialXEnvironment } from "./materialx.js";
-import { getUniformValues, Loaders } from "./materialx.helper.js";
+import { generateMaterialPropertiesForUniforms, getUniformValues, Loaders } from "./materialx.helper.js";
+import { cloneUniforms, cloneUniformsGroups } from "three/src/renderers/shaders/UniformsUtils.js";
 
 
 // Add helper matrices for uniform updates (similar to MaterialX example)
@@ -10,13 +11,12 @@ const worldViewPos = new Vector3();
 
 declare type MaterialXMaterialInitParameters = {
     name: string,
+    shaderName?: string | null, // Optional name of the shader
     shader: any,
     loaders: Loaders,
     context: MaterialXContext,
     // Optional parameters
-    transparent?: boolean,
-    side?: MaterialParameters['side'],
-    precision?: MaterialParameters['precision'],
+    parameters?: MaterialParameters,
 }
 
 type Uniforms = Record<string, IUniform & { needsUpdate?: boolean }>;
@@ -24,13 +24,25 @@ type Precision = "highp" | "mediump" | "lowp";
 
 export class MaterialXMaterial extends ShaderMaterial {
 
+    /** The original name of the shader */
+    readonly shaderName : string | null = null;
+
     copy(source: MaterialXMaterial): this {
         super.copy(source);
         this._context = source._context;
+        this._shader = source._shader;
+        this.uniforms = cloneUniforms(source.uniforms) as Uniforms;
+        this.uniformsGroups = cloneUniformsGroups(source.uniformsGroups);
+        this.envMapIntensity = source.envMapIntensity;
+        this.envMap = source.envMap;
+        generateMaterialPropertiesForUniforms(this, this._shader.getStage('pixel'));
+        generateMaterialPropertiesForUniforms(this, this._shader.getStage('vertex'));
+        this.needsUpdate = true;
         return this;
     }
 
     private _context: MaterialXContext | null = null;
+    private _shader: any;
 
     constructor(init?: MaterialXMaterialInitParameters) {
 
@@ -63,7 +75,7 @@ export class MaterialXMaterial extends ShaderMaterial {
         vertexShader = vertexShader.replace(/\bi_color_0\b/g, 'color');
 
         // Patch fragmentShader
-        const precision = init.precision || "highp" as Precision;
+        const precision = init.parameters?.precision || "highp" as Precision;
         fragmentShader = fragmentShader.replace(/precision mediump float;/g, `precision ${precision} float;`);
         fragmentShader = fragmentShader.replace(/#define M_FLOAT_EPS 1e-8/g, precision === "highp" ? `#define M_FLOAT_EPS 1e-8` : `#define M_FLOAT_EPS 1e-3`);
 
@@ -124,19 +136,21 @@ export class MaterialXMaterial extends ShaderMaterial {
         if (hasColor) defines['USE_COLOR'] = '';
 
         const searchPath = ""; // Could be derived from the asset path if needed
-        const isTransparent = init.transparent ?? false;
+        const isTransparent = init.parameters?.transparent ?? false;
         super({
             name: init.name,
             uniforms: {},
             vertexShader: vertexShader,
             fragmentShader: fragmentShader,
             glslVersion: GLSL3,
-            transparent: isTransparent,
-            side: init.side ? init.side : FrontSide,
             depthTest: true,
             depthWrite: !isTransparent,
             defines: defines,
+            ...init.parameters, // Spread any additional parameters passed to the material
         });
+        this._context = init.context;
+        this._shader = init.shader;
+        this.shaderName = init.shaderName || null;
 
         Object.assign(this.uniforms, {
             ...getUniformValues(init.shader.getStage('vertex'), init.loaders, searchPath),
@@ -158,7 +172,9 @@ export class MaterialXMaterial extends ShaderMaterial {
             u_lightData: { value: [], needsUpdate: false }, // Array of light data. We need to set needsUpdate to false until we actually update it
         });
 
-        this._context = init.context;
+        generateMaterialPropertiesForUniforms(this, init.shader.getStage('pixel'));
+        generateMaterialPropertiesForUniforms(this, init.shader.getStage('vertex'));
+
 
         if (debug) {
             // Get lighting and environment data from MaterialX environment
@@ -216,7 +232,7 @@ export class MaterialXMaterial extends ShaderMaterial {
             if (frame === undefined) frame = getFrame();
             uniforms.u_frame.value = frame;
         }
-        
+
         // Update light uniforms
         this.updateEnvironmentUniforms(environment);