@needle-tools/materialx 1.4.2 → 1.4.3

package/bin/revision.json

@@ -0,0 +1,5 @@
+{
+  "commit": "309ccca5d7788f90d773248c88498ddc203dc260",
+  "version": "1.39.4",
+  "buildDate": "2026-02-27 14:35:28"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/materialx",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -24,6 +24,9 @@
   "peerDependencies": {
     "three": ">=0.160.0"
   },
+  "scripts": {
+    "test": "node --test tests/unit/**/*.test.js"
+  },
   "devDependencies": {
     "@needle-tools/engine": "4.x",
     "@types/three": "0.169.0",

package/src/index.d.ts

@@ -1,4 +1,5 @@
 export { ready, type MaterialXContext, preloadWasm } from "./materialx.js";
+export { MaterialXEnvironment } from "./materialx.js";
 export { MaterialXMaterial } from "./materialx.material.js";
 export { MaterialXLoader } from "./loader/loader.three.js";
 

package/src/index.js

@@ -1,6 +1,7 @@
 import { createMaterialXMaterial } from "./loader/loader.three.js";
 
 export { ready, preloadWasm } from "./materialx.js";
+export { MaterialXEnvironment } from "./materialx.js";
 export { MaterialXMaterial } from "./materialx.material.js";
 export { MaterialXLoader } from "./loader/loader.three.js";
 

package/src/materialx.d.ts

@@ -1,6 +1,29 @@
 import { Light, Scene, Texture, WebGLRenderer } from "three";
 import type { MaterialX as MX } from "./materialx.types.js";
 
+/**
+ * Override the base URL for MaterialX WASM files.
+ * Set this global **before** any MaterialX code runs to load WASM from a custom location.
+ * 
+ * Special values:
+ * - `"package"`: Use local files bundled with the npm package
+ * - `"/custom/path/"`: Use a custom base URL (must end with `/`)
+ * - `undefined`: Use default CDN
+ * 
+ * @default `https://cdn.needle.tools/static/materialx/<version>/`
+ * @example
+ * ```js
+ * // Use package-local files (same as "bin/")
+ * globalThis.NEEDLE_MATERIALX_LOCATION = "package";
+ * 
+ * // Use custom CDN or self-hosted files
+ * globalThis.NEEDLE_MATERIALX_LOCATION = "/assets/materialx/";
+ * ```
+ */
+declare global {
+    var NEEDLE_MATERIALX_LOCATION: string | undefined;
+}
+
 export function preloadWasm(trigger: "immediately" | "network_idle"): Promise<void>;
 
 export type MaterialXContext = {
@@ -47,6 +70,11 @@ export declare class MaterialXEnvironment {
     initialize(renderer: WebGLRenderer): Promise<boolean>;
     update(frame: number, scene: Scene, renderer: WebGLRenderer): void;
     reset(): void;
+    /**
+     * Re-collect lights from the scene and rebuild light data.
+     * Call this after adding/removing lights, toggling visibility, or changing light properties.
+     */
+    refreshLights(): void;
 
     get lights(): Array<Light>;
     get lightData(): any[] | null;

package/src/materialx.helper.d.ts

@@ -22,6 +22,8 @@ export function getLightRotation(): THREE.Matrix4;
 
 export function findLights(doc: any): Array<any>;
 
+export function getLightTypeIds(): { directional: number, point: number, spot: number };
+
 export function registerLights(mx: any, genContext: any): Promise<void>;
 
 export function getLightData(lights: Array<THREE.Light>, genContext: any): { lightData: LightData[], lightCount: number };

package/src/materialx.helper.js

@@ -211,6 +211,9 @@ function toThreeUniform(uniforms, type, value, name, loaders, searchPath) {
                     if (checkCache) addToCache(cacheKey, promise);
 
                     promise?.then(res => {
+                        // Replace Promise cache entry with the resolved texture value.
+                        // This avoids keeping long-lived promise/closure graphs in THREE.Cache.
+                        if (checkCache && res) addToCache(cacheKey, res);
                         if (res) uniform.value = /** @type {any} */ (res);
                         else console.warn(`[MaterialX] Failed to load texture ${name} '${texturePath}'`);
                     });
@@ -313,6 +316,19 @@ export function findLights(doc) {
 /** @type {Object<string, number>} */
 let lightTypesBound = {};
 
+/**
+ * Returns the current mapping of MaterialX light definition names to their type IDs.
+ * These IDs are used in the shader's LightData.type field.
+ * @returns {{ directional: number, point: number, spot: number }}
+ */
+export function getLightTypeIds() {
+    return {
+        directional: lightTypesBound['ND_directional_light'] || 1,
+        point: lightTypesBound['ND_point_light'] || 2,
+        spot: lightTypesBound['ND_spot_light'] || 3,
+    };
+}
+
 /**
  * Register lights in shader generation context
  * @param {any} mx - MaterialX Module
@@ -373,6 +389,19 @@ export async function registerLights(mx, genContext) {
 }
 
 const _lightTypeWarnings = {}
+const _emptyLightPosition = new THREE.Vector3(0, 0, 0);
+const _emptyLightDirection = new THREE.Vector3(0, 0, -1);
+const _emptyLightColor = new THREE.Color(0, 0, 0);
+const _emptyLight = Object.freeze({
+    type: 0,
+    position: _emptyLightPosition,
+    direction: _emptyLightDirection,
+    color: _emptyLightColor,
+    intensity: 0.0,
+    decay_rate: 2.0,
+    inner_angle: 0.0,
+    outer_angle: 0.0,
+});
 /**
  * Converts Three.js light type to MaterialX node name
  * @param {string} threeLightType
@@ -434,8 +463,21 @@ export function getLightData(lights, genContext) {
         }
 
         const wp = light.getWorldPosition(new THREE.Vector3());
-        const wq = light.getWorldQuaternion(new THREE.Quaternion());
-        const wd = new THREE.Vector3(0, 0, -1).applyQuaternion(wq);
+        // For target-based lights (SpotLight, DirectionalLight), compute direction from position to target.
+        // Using getWorldQuaternion() doesn't work because Three.js target-based lights don't set rotation.
+        let wd;
+        const directionalOrSpot = (/** @type {THREE.DirectionalLight | THREE.SpotLight | null} */ (
+            (/** @type {THREE.DirectionalLight} */ (light)).isDirectionalLight || (/** @type {THREE.SpotLight} */ (light)).isSpotLight
+                ? light
+                : null
+        ));
+        if (directionalOrSpot) {
+            const targetPos = directionalOrSpot.target.getWorldPosition(new THREE.Vector3());
+            wd = targetPos.sub(wp).normalize();
+        } else {
+            const wq = light.getWorldQuaternion(new THREE.Quaternion());
+            wd = new THREE.Vector3(0, 0, -1).applyQuaternion(wq);
+        }
 
         // Shader math from the generated MaterialX shader:
         // float low = min(light.inner_angle, light.outer_angle);
@@ -452,7 +494,7 @@ export function getLightData(lights, genContext) {
             type: lightTypesBound[lightDefinitionName],
             position: wp.clone(),
             direction: wd.clone(),
-            color: new THREE.Color().fromArray(light.color.toArray()),
+            color: light.color.clone(),
             // 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 * (/** @type {THREE.PointLight} */ (light).isPointLight ? 683.0 / 3.1415 : /** @type {THREE.SpotLight} */ (light).isSpotLight ? 683.0 / 3.1415 : 1.0),
@@ -468,17 +510,7 @@ export function getLightData(lights, genContext) {
 
     // If we don't have enough entries in lightData, fill with empty lights
     while (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,
-        };
-        lightData.push(emptyLight);
+        lightData.push(_emptyLight);
     }
 
     if (debugUpdate) console.log("Registered lights in MaterialX context", lightTypesBound, lightData);

package/src/materialx.js

@@ -48,29 +48,41 @@ export async function ready() {
         if (debug) console.log("[MaterialX] Initializing WASM module...");
         try {
 
-            const useRemoteUrls = true;
-            const remoteVersion = "1.4.0";
+            // NOTE: This must be a plain string literal (not a template) so that the
+            // makeFilesLocal Vite plugin can statically detect and localize this URL.
+            const defaultBaseUrl = "https://cdn.needle.tools/static/materialx/1.4.3/";
 
             /** @type {Array<string>} */
             let urls;
 
-            if (useRemoteUrls) {
-                urls = [
-                    `https://cdn.needle.tools/static/materialx/${remoteVersion}/JsMaterialXCore.wasm`,
-                    `https://cdn.needle.tools/static/materialx/${remoteVersion}/JsMaterialXGenShader.wasm`,
-                    `https://cdn.needle.tools/static/materialx/${remoteVersion}/JsMaterialXGenShader.data.txt`,
-                ];
-            } else {
-                // For local paths, import the files as assets so Vite copies them to the dist folder
+            const location = globalThis.NEEDLE_MATERIALX_LOCATION;
+
+            if (location === "package" || location === "bin/" || location === "./bin/" || location === "../bin/") {
+                // Use local files from the @needle-tools/materialx npm package.
+                // Vite's ?url suffix copies these files to the output directory
+                // and returns their URL automatically — no CDN download needed.
                 urls = await Promise.all([
-                    /** @ts-ignore */
-                    import( /* @vite-ignore */ `../bin/JsMaterialXCore.wasm?url`).then(m => m.default || m),
-                    /** @ts-ignore */
-                    import( /* @vite-ignore */ `../bin/JsMaterialXGenShader.wasm?url`).then(m => m.default || m),
-                    /** @ts-ignore */
-                    import( /* @vite-ignore */ `../bin/JsMaterialXGenShader.data.txt?url`).then(m => m.default || m),
+                    import('../bin/JsMaterialXCore.wasm?url').then(m => m.default || m),
+                    import('../bin/JsMaterialXGenShader.wasm?url').then(m => m.default || m),
+                    import('../bin/JsMaterialXGenShader.data.txt?url').then(m => m.default || m),
                 ]);
             }
+            else if (location) {
+                // Custom path: use as base URL for CDN or self-hosted files
+                urls = [
+                    location + "JsMaterialXCore.wasm",
+                    location + "JsMaterialXGenShader.wasm",
+                    location + "JsMaterialXGenShader.data.txt",
+                ];
+            }
+            else {
+                // Default: fetch from CDN (or from local files if makeFilesLocal rewrites this URL)
+                urls = [
+                    defaultBaseUrl + "JsMaterialXCore.wasm",
+                    defaultBaseUrl + "JsMaterialXGenShader.wasm",
+                    defaultBaseUrl + "JsMaterialXGenShader.data.txt",
+                ];
+            }
             const [JsMaterialXCore, JsMaterialXGenShader, JsMaterialXGenShader_data] = urls;
 
             const module = await MaterialX({
@@ -125,6 +137,7 @@ export async function ready() {
             // Set a reasonable default for max active lights
             state.materialXGenContext.getOptions().hwMaxActiveLightSources = 4;
 
+            // We use Three.js shadow maps instead of MaterialX's own shadow implementation
             // state.materialXGenContext.getOptions().hwShadowMap = true;
 
             // This prewarms the shader generation context to have all light types
@@ -159,7 +172,7 @@ export class MaterialXEnvironment {
     }
 
     /** @type {WeakMap<Scene, MaterialXEnvironment>} */
-    static _environments = new Map();
+    static _environments = new WeakMap();
 
     /**
      * @param {Scene} scene
@@ -370,6 +383,9 @@ export class MaterialXEnvironment {
                 if ((/** @type {Light} */ (object)).isLight && object.visible)
                     lights.push(/** @type {Light} */(object));
             });
+            // Keep the same ordering strategy as Three.js (shadow casters first)
+            // and do this only when re-collecting lights to avoid per-frame sort allocations.
+            lights.sort((a, b) => (b.castShadow ? 1 : 0) - (a.castShadow ? 1 : 0));
             this._lights = lights;
         }
 
@@ -377,6 +393,15 @@ export class MaterialXEnvironment {
             const { lightData, lightCount } = getLightData(this._lights, state.materialXGenContext);
             this._lightData = lightData;
             this._lightCount = lightCount;
+            // Note: Shadow data is now handled by Three.js when lights: true is set on the material
         }
     }
+
+    /**
+     * Re-collect lights from the scene and rebuild light data.
+     * Call this after adding/removing lights, toggling visibility, or changing light properties.
+     */
+    refreshLights() {
+        this.updateLighting(true);
+    }
 }

package/src/materialx.material.js

@@ -1,8 +1,8 @@
-import { BufferGeometry, Camera, FrontSide, GLSL3, Group, Matrix3, Matrix4, Object3D, Scene, ShaderMaterial, Texture, Vector3, WebGLRenderer } from "three";
+import { BufferGeometry, Camera, FrontSide, GLSL3, Group, Matrix3, Matrix4, Object3D, Scene, ShaderMaterial, Texture, UniformsLib, Vector3, WebGLRenderer } from "three";
 import { debug, getFrame, getTime } from "./utils.js";
 import { MaterialXEnvironment } from "./materialx.js";
-import { generateMaterialPropertiesForUniforms, getUniformValues } from "./materialx.helper.js";
-import { cloneUniforms, cloneUniformsGroups } from "three/src/renderers/shaders/UniformsUtils.js";
+import { generateMaterialPropertiesForUniforms, getUniformValues, getLightTypeIds } from "./materialx.helper.js";
+import { cloneUniforms, cloneUniformsGroups, mergeUniforms } from "three/src/renderers/shaders/UniformsUtils.js";
 
 // Add helper matrices for uniform updates (similar to MaterialX example)
 const normalMat = new Matrix3();
@@ -35,8 +35,10 @@ export class MaterialXMaterial extends ShaderMaterial {
      */
     copy(source) {
         super.copy(source);
+        this.shaderName = source.shaderName;
         this._context = source._context;
         this._shader = source._shader;
+        this._needsTangents = source._needsTangents;
         this.uniforms = cloneUniforms(source.uniforms);
         this.uniformsGroups = cloneUniformsGroups(source.uniformsGroups);
         this.envMapIntensity = source.envMapIntensity;
@@ -59,16 +61,21 @@ export class MaterialXMaterial extends ShaderMaterial {
      */
     constructor(init) {
 
-        // TODO: we need to properly copy the uniforms and other properties from the source material
-        if (!init) {
-            super();
-            return;
-        }
+        /** @type {import('three').ShaderMaterialParameters | undefined} */
+        let materialParameters = undefined;
+        /** @type {string} */
+        let vertexShader = "";
+        /** @type {string} */
+        let fragmentShader = "";
+        /** @type {Record<string, string>} */
+        let defines = {};
+
+        if (init) {
 
         // Get vertex and fragment shader source, and remove #version directive for newer js. 
         // It's added by three.js glslVersion.
-        let vertexShader = init.shader.getSourceCode("vertex");
-        let fragmentShader = init.shader.getSourceCode("pixel");
+        vertexShader = init.shader.getSourceCode("vertex");
+        fragmentShader = init.shader.getSourceCode("pixel");
 
         vertexShader = vertexShader.replace(/^#version.*$/gm, '').trim();
         fragmentShader = fragmentShader.replace(/^#version.*$/gm, '').trim();
@@ -108,6 +115,12 @@ export class MaterialXMaterial extends ShaderMaterial {
         fragmentShader = fragmentShader.replace(/\bi_tangent\b/g, 'tangent');
         fragmentShader = fragmentShader.replace(/\bi_color_0\b/g, 'color');
 
+        // Patch env intensity uniform to match Three.js naming convention.
+        // MaterialX generates `u_envLightIntensity`; Three.js uses `envMapIntensity`.
+        // This lets us combine material.envMapIntensity * scene.environmentIntensity
+        // the same way MeshStandardMaterial does.
+        fragmentShader = fragmentShader.replace(/\bu_envLightIntensity\b/g, 'envMapIntensity');
+
         // Capture some vertex shader properties
         const uv_is_vec2 = vertexShader.includes('in vec2 uv;'); // check if uv is vec2; e.g. https://matlib.gpuopen.com/main/materials/all?material=da6ec531-f5c1-4790-ac14-8a5c51d0314e
         const uv1_is_vec2 = vertexShader.includes('in vec2 uv1;');
@@ -155,16 +168,154 @@ export class MaterialXMaterial extends ShaderMaterial {
     #include <tonemapping_fragment>
     #include <colorspace_fragment>`);
 
-        const defines = {};
+        defines = {};
         if (hasUv1) defines['USE_UV1'] = '';
         if (hasUv2) defines['USE_UV2'] = '';
         if (hasUv3) defines['USE_UV3'] = '';
         if (hasTangent) defines['USE_TANGENT'] = '';
         if (hasColor) defines['USE_COLOR'] = '';
 
-        const searchPath = ""; // Could be derived from the asset path if needed
+        // Add Three.js shadow support
+        // Insert shadow pars before main() in vertex shader
+        vertexShader = vertexShader.replace(
+            /void\s+main\s*\(\s*\)\s*\{/,
+            `#include <common>
+#include <shadowmap_pars_vertex>
+void main() {`
+        );
+
+        // Insert shadow vertex calculation at the end of vertex main (before the closing brace)
+        // We need to compute worldPosition and transformedNormal for shadow coords
+        // Note: Three.js shadowmap_vertex expects transformedNormal in VIEW space:
+        //   it does `inverseTransformDirection(transformedNormal, viewMatrix)` to get world-space normal
+        vertexShader = vertexShader.replace(
+            /(\n\s*)\}(\s*)$/,
+            `$1    // Three.js shadow support
+$1    vec4 worldPosition = u_worldMatrix * vec4(position, 1.0);
+$1    vec3 transformedNormal = mat3(viewMatrix) * normalWorld;
+$1    #include <shadowmap_vertex>
+$1}$2`
+        );
+
+        // Insert shadow includes at the very beginning of the fragment shader (after precision)
+        // This ensures DirectionalLightShadow struct is defined before getMxShadow uses it
+        fragmentShader = fragmentShader.replace(
+            /(precision\s+\w+\s+float;)/,
+            `$1
+
+#include <common>
+#include <packing>
+#include <shadowmap_pars_fragment>`
+        );
+
+        // Get MaterialX light type IDs for shadow dispatch
+        const lightTypeIds = getLightTypeIds();
+
+        // Generate GLSL helper functions that sample shadow maps using constant indices.
+        // Sampler arrays require constant integral expression indices in GLSL ES 3.0,
+        // so we use if/else chains with literal constants (guarded by preprocessor).
+        const MAX_SHADOW_LIGHTS = 4; // max shadow-casting lights per type
+
+        let dirShadowCases = '';
+        for (let i = 0; i < MAX_SHADOW_LIGHTS; i++) {
+            dirShadowCases += `
+        #if NUM_DIR_LIGHT_SHADOWS > ${i}
+        ${i > 0 ? 'else ' : ''}if (idx == ${i}) {
+            DirectionalLightShadow s = directionalLightShadows[${i}];
+            return getShadow(directionalShadowMap[${i}], s.shadowMapSize, s.shadowIntensity, s.shadowBias, s.shadowRadius, vDirectionalShadowCoord[${i}]);
+        }
+        #endif`;
+        }
+
+        let spotShadowCases = '';
+        for (let i = 0; i < MAX_SHADOW_LIGHTS; i++) {
+            spotShadowCases += `
+        #if NUM_SPOT_LIGHT_SHADOWS > ${i}
+        ${i > 0 ? 'else ' : ''}if (idx == ${i}) {
+            SpotLightShadow s = spotLightShadows[${i}];
+            return getShadow(spotShadowMap[${i}], s.shadowMapSize, s.shadowIntensity, s.shadowBias, s.shadowRadius, vSpotLightCoord[${i}]);
+        }
+        #endif`;
+        }
+
+        let pointShadowCases = '';
+        for (let i = 0; i < MAX_SHADOW_LIGHTS; i++) {
+            pointShadowCases += `
+        #if NUM_POINT_LIGHT_SHADOWS > ${i}
+        ${i > 0 ? 'else ' : ''}if (idx == ${i}) {
+            PointLightShadow s = pointLightShadows[${i}];
+            return getPointShadow(pointShadowMap[${i}], s.shadowMapSize, s.shadowIntensity, s.shadowBias, s.shadowRadius, vPointShadowCoord[${i}], s.shadowCameraNear, s.shadowCameraFar);
+        }
+        #endif`;
+        }
+
+        // Insert getMxShadow helper function BEFORE sampleLightSource (so it's defined when used)
+        // Supports directional, spot, and point light shadows.
+        // Uses global per-type counters to track which shadow map index to use.
+        fragmentShader = fragmentShader.replace(
+            /void sampleLightSource\(LightData light, vec3 position, out lightshader result\)/,
+            `// MaterialX light type IDs (from registerLights)
+#define MX_LIGHT_TYPE_DIRECTIONAL ${lightTypeIds.directional}
+#define MX_LIGHT_TYPE_POINT ${lightTypeIds.point}
+#define MX_LIGHT_TYPE_SPOT ${lightTypeIds.spot}
+
+// Per-type shadow index counters (global so they persist across sampleLightSource calls)
+int mxDirShadowIdx = 0;
+int mxSpotShadowIdx = 0;
+int mxPointShadowIdx = 0;
+
+// Shadow sampling helpers using constant indices (required for sampler arrays in GLSL ES 3.0)
+float sampleMxDirShadow(int idx) {
+    #ifdef USE_SHADOWMAP
+    #if NUM_DIR_LIGHT_SHADOWS > 0
+    ${dirShadowCases}
+    #endif
+    #endif
+    return 1.0;
+}
+
+float sampleMxSpotShadow(int idx) {
+    #ifdef USE_SHADOWMAP
+    #if NUM_SPOT_LIGHT_SHADOWS > 0
+    ${spotShadowCases}
+    #endif
+    #endif
+    return 1.0;
+}
+
+float sampleMxPointShadow(int idx) {
+    #ifdef USE_SHADOWMAP
+    #if NUM_POINT_LIGHT_SHADOWS > 0
+    ${pointShadowCases}
+    #endif
+    #endif
+    return 1.0;
+}
+
+void sampleLightSource(LightData light, vec3 position, out lightshader result)`
+        );
+
+        // Find the sampleLightSource function and add shadow + counter increment at the end.
+        // The per-type counters track which Three.js shadow map index to use for each light type.
+        // Lights must be sorted (shadow-casting first per type) to match Three.js shadow map ordering.
+        fragmentShader = fragmentShader.replace(
+            /(void sampleLightSource\(LightData light, vec3 position, out lightshader result\)\s*\{[\s\S]*?)(^\})/m,
+            `$1    // Apply Three.js shadow and increment per-type shadow counters
+    if (light.type == MX_LIGHT_TYPE_DIRECTIONAL) {
+        result.intensity *= sampleMxDirShadow(mxDirShadowIdx);
+        mxDirShadowIdx++;
+    } else if (light.type == MX_LIGHT_TYPE_SPOT) {
+        result.intensity *= sampleMxSpotShadow(mxSpotShadowIdx);
+        mxSpotShadowIdx++;
+    } else if (light.type == MX_LIGHT_TYPE_POINT) {
+        result.intensity *= sampleMxPointShadow(mxPointShadowIdx);
+        mxPointShadowIdx++;
+    }
+$2`
+        );
+
         const isTransparent = init.parameters?.transparent ?? false;
-        super({
+        materialParameters = {
             name: init.name,
             uniforms: {},
             vertexShader: vertexShader,
@@ -173,14 +324,28 @@ export class MaterialXMaterial extends ShaderMaterial {
             depthTest: true,
             depthWrite: !isTransparent,
             defines: defines,
+            lights: true, // Enable Three.js light uniforms
             ...init.parameters, // Spread any additional parameters passed to the material
-        });
+        };
+        }
+
+        super(materialParameters);
+
+        // Constructor can be called without init during clone() paths.
+        if (!init) {
+            return;
+        }
+
+        const searchPath = ""; // Could be derived from the asset path if needed
         this.shaderName = init.shaderName || null;
         this._context = init.context;
         this._shader = init.shader;
         this._needsTangents = vertexShader.includes('in vec4 tangent;') || vertexShader.includes('in vec3 tangent;');
 
         Object.assign(this.uniforms, {
+            // Three.js light uniforms (required when lights: true)
+            ...UniformsLib.lights,
+
             ...getUniformValues(init.shader.getStage('vertex'), init.loaders, searchPath),
             ...getUniformValues(init.shader.getStage('pixel'), init.loaders, searchPath),
 
@@ -189,15 +354,13 @@ export class MaterialXMaterial extends ShaderMaterial {
             u_viewPosition: { value: new Vector3() },
             u_worldInverseTransposeMatrix: { value: new Matrix4() },
 
-            // u_shadowMatrix: { value: new Matrix4() },
-            // u_shadowMap: { value: null, type: 't' }, // Shadow map
-
             u_envMatrix: { value: new Matrix4() },
             u_envRadiance: { value: null, type: 't' },
             u_envRadianceMips: { value: 8, type: 'i' },
             // TODO we need to figure out how we can set a PMREM here... doing many texture samples is prohibitively expensive
             u_envRadianceSamples: { value: 8, type: 'i' },
             u_envIrradiance: { value: null, type: 't' },
+            envMapIntensity: { value: 1.0 },
             u_refractionEnv: { value: true },
             u_numActiveLightSources: { value: 0 },
             u_lightData: { value: [], needsUpdate: false }, // Array of light data. We need to set needsUpdate to false until we actually update it
@@ -240,7 +403,7 @@ export class MaterialXMaterial extends ShaderMaterial {
         const env = MaterialXEnvironment.get(_scene);
         if (env) {
             env.update(frame, _scene, renderer);
-            this.updateEnvironmentUniforms(env);
+            this.updateEnvironmentUniforms(env, _scene);
         }
         this.updateUniforms(renderer, object, camera, time, frame);
     }
@@ -312,9 +475,10 @@ export class MaterialXMaterial extends ShaderMaterial {
 
     /**
      * @private
-     * @param {MaterialXEnvironment} environment
+    * @param {MaterialXEnvironment} environment
+    * @param {Scene} scene
      */
-    updateEnvironmentUniforms = (environment) => {
+    updateEnvironmentUniforms = (environment, scene) => {
 
         const uniforms = this.uniforms;
 
@@ -354,6 +518,14 @@ export class MaterialXMaterial extends ShaderMaterial {
             if (prev != textures.irradianceTexture) uniforms.u_envIrradiance.needsUpdate = true;
         }
 
+        // Sync environment intensity: combine per-material envMapIntensity with scene.environmentIntensity
+        // (mirrors MeshStandardMaterial behaviour in Three.js)
+        if (uniforms.envMapIntensity) {
+            uniforms.envMapIntensity.value = (this.envMapIntensity ?? 1.0) * (scene.environmentIntensity ?? 1.0);
+        }
+
+        // Note: Shadow uniforms are handled by Three.js when lights: true is set
+
         this.uniformsNeedUpdate = true;
     }
 }

package/src/utils.d.ts

@@ -17,4 +17,6 @@ export function getTime(): number;
 export function getFrame(): number;
 
 
-export function waitForNetworkIdle(): Promise<void>;
+export function waitForNetworkIdle(): Promise<void>;
+
+export function isDevEnvironment(): boolean;

package/src/vite-url-modules.d.ts

@@ -0,0 +1,9 @@
+declare module '*.wasm?url' {
+    const url: string;
+    export default url;
+}
+
+declare module '*.txt?url' {
+    const url: string;
+    export default url;
+}

package/bin/README.md

@@ -1,6 +0,0 @@
-Source: https://github.com/AcademySoftwareFoundation/MaterialX/tree/gh-pages
-
-Edits:
-
-- In `JsMaterialXGenShader.js` added `export default MaterialX;` at bottom 
-- Renamed `JsMaterialXGenShader.data` to `JsMaterialXGenShader.data.txt` so it can be loaded by vite etc