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

package/src/materialx.ts

@@ -1,15 +1,13 @@
-import { Context, delay, isDevEnvironment, ObjectUtils, GameObject, onBeforeRender } from "@needle-tools/engine";
-import type { MaterialX as MX } from "./materialx.types.js";
+import { Context, delay, isDevEnvironment, ObjectUtils, GameObject } from "@needle-tools/engine";
 import MaterialX from "../bin/JsMaterialXGenShader.js";
 import { debug } from "./utils.js";
 import { renderPMREMToEquirect } from "./textureHelper.js";
-import { Light, Material, MeshBasicMaterial, Object3D, PMREMGenerator, Texture } from "three";
-import { registerLights, getLightData } from "./materialx.helper.js";
-import type { MaterialXMaterial } from "./materialx.material.js";
+import { Light, MeshBasicMaterial, Object3D, PMREMGenerator, Texture } from "three";
+import { registerLights, getLightData } from "./helper.js";
 
 
 export const state = new class {
-    materialXModule: MX.MODULE | null = null;
+    materialXModule: typeof MaterialX | null = null;
     materialXGenerator: any = null;
     materialXGenContext: any = null;
     materialXStdLib: any = null;
@@ -61,7 +59,7 @@ export async function ready(): Promise<void> {
                 },
             });
             if (debug) console.log("[MaterialX] module loaded", module);
-            state.materialXModule = module as MX.MODULE
+            state.materialXModule = module;
 
             // Initialize shader generator and context
             state.materialXGenerator = module.EsslShaderGenerator.create();
@@ -97,6 +95,7 @@ export async function ready(): Promise<void> {
 
             // This prewarms the shader generation context to have all light types
             await registerLights(state.materialXModule, state.materialXGenContext);
+            // getLightData(state.materialXModule, [], state.materialXGenContext);
 
             if (debug) console.log("[MaterialX]  generator initialized successfully");
         } catch (error) {
@@ -106,81 +105,91 @@ export async function ready(): Promise<void> {
     })();
 }
 
-type EnvironmentTextureSet = {
-    radianceTexture: Texture | null;
-    irradianceTexture: Texture | null;
-}
-
 // MaterialX Environment Manager - handles lighting and environment setup
 export class MaterialXEnvironment {
     private _context: Context | null = null;
     private _lights: Array<Light> = [];
     private _lightData: any = null;
     private _lightCount: number = 0;
+    private _radianceTexture: Texture | null = null;
+    private _irradianceTexture: Texture | null = null;
     private _initializePromise: Promise<boolean> | null = null;
 
-    private _unsubscribehook: (() => void) | null = null;
-
     constructor() {
         if (debug) console.log("[MaterialX] Environment created");
     }
 
     // Initialize with Needle Engine context
-    async initialize(context: Context): Promise<boolean> {
+    async initializeFromContext(context: Context): Promise<boolean> {
         if (this._initializePromise) {
             return this._initializePromise;
         }
         return this._initializePromise = this._initialize(context);
     }
 
-    get lightData() { return this._lightData; }
-    get lightCount() { return this._lightCount || 0; }
-    getTextures(material: MaterialXMaterial) {
-        if (material.envMap) {
-            // If the material has its own envMap, we don't use the irradiance texture
-            return this._getTextures(material.envMap);
-        }
-        return this._getTextures(this._context?.scene.environment);
-    }
+    getLightData() { return this._lightData; }
+    getLightCount() { return this._lightCount; }
 
-    private _pmremGenerator: PMREMGenerator | null = null;
-    private readonly _texturesCache: Map<Texture | null, EnvironmentTextureSet> = new Map();
+    setRadianceTexture(texture: Texture) { this._radianceTexture = texture; }
+    getRadianceTexture() { return this._radianceTexture; }
+
+    getIrradianceTexture() { return this._irradianceTexture; }
+    setIrradianceTexture(texture: Texture) { this._irradianceTexture = texture; }
 
     private _initialize: (context: Context) => Promise<boolean> = async (context: Context) => {
 
         this._context = context;
-        this._pmremGenerator = new PMREMGenerator(context.renderer);
 
-        this._unsubscribehook?.();
-        this._unsubscribehook = onBeforeRender(() => {
-            this.updateLighting(false);
-            this._getTextures(context.scene.environment);
-        })
+        // Get renderer from context
+        const renderer = context.renderer;
+
+        // Clean up previous textures if they exist
+        if (this._radianceTexture) {
+            if (debug) console.log("[MaterialX] Disposing previous radiance texture");
+            this._radianceTexture.dispose();
+            this._radianceTexture = null;
+        }
+        if (this._irradianceTexture) {
+            if (debug) console.log("[MaterialX] Disposing previous irradiance texture");
+            this._irradianceTexture.dispose();
+            this._irradianceTexture = null;
+        }
 
         // TODO remove this delay; we should wait for the scene lighting to be ready
         // and then update the uniforms
-        while (!context.scene.environment) {
-            await delay(5);
+        let envMap = context.scene.environment;
+        while (!envMap) {
+            await delay(1000);
+            envMap = context.scene.environment;
+        }
+        const pmrem = new PMREMGenerator(renderer);
+        const target = pmrem.fromEquirectangular(envMap);
+        const radianceRenderTarget = renderPMREMToEquirect(renderer, target.texture, 0.0, 1024, 512, target.height);
+        const irradianceRenderTarget = renderPMREMToEquirect(renderer, target.texture, 1.0, 32, 16, target.height);
+        this._radianceTexture = radianceRenderTarget.texture;
+        this._irradianceTexture = irradianceRenderTarget.texture;
+
+        // Clean up PMREM generator and its render target
+        target.dispose();
+        pmrem.dispose();
+
+        if (debug) {
+            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("Quad", { material: radianceMat });
+            const irradianceMat = unlitMat.clone();
+            irradianceMat.map = this._irradianceTexture;
+            const irradianceCube = ObjectUtils.createPrimitive("Quad", { material: irradianceMat });
+            context.scene.add(radianceCube);
+            context.scene.add(irradianceCube);
+            radianceCube.position.set(2, 0, 0);
+            irradianceCube.position.set(-2, 0, 0);
+            console.log("[MaterialX] environment initialized from Needle context", this, this._context.scene);
         }
-        this._getTextures(context.scene.environment);
-
-        // if (debug) {
-        //     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("Quad", { material: radianceMat });
-        //     const irradianceMat = unlitMat.clone();
-        //     irradianceMat.map = this._irradianceTexture;
-        //     const irradianceCube = ObjectUtils.createPrimitive("Quad", { material: irradianceMat });
-        //     context.scene.add(radianceCube);
-        //     context.scene.add(irradianceCube);
-        //     radianceCube.position.set(2, 0, 0);
-        //     irradianceCube.position.set(-2, 0, 0);
-        //     console.log("[MaterialX] environment initialized from Needle context", this, this._context.scene);
-        // }
 
         this.updateLighting(true);
 
@@ -188,58 +197,7 @@ export class MaterialXEnvironment {
         return true;
     }
 
-    // Reset the environment to allow re-initialization
-    reset() {
-        if (debug) console.log("[MaterialX] Resetting environment");
-        this._initializePromise = null;
-        this._lights = [];
-        this._lightData = null;
-        this._lightCount = 0;
-        this._pmremGenerator?.dispose();
-        this._pmremGenerator = null;
-        for(const textureSet of this._texturesCache.values()) {
-            textureSet.radianceTexture?.dispose();
-            textureSet.irradianceTexture?.dispose();
-        }
-        this._texturesCache.clear();
-
-        this._unsubscribehook?.();
-        this._unsubscribehook = null;
-    }
-
-    private _getTextures(texture: Texture | null | undefined): {
-        radianceTexture: Texture | null,
-        irradianceTexture: Texture | null
-    } {
-
-        let res: EnvironmentTextureSet | undefined = this._texturesCache.get(texture || null);
-        if (res) {
-            return res;
-        }
-
-        if (this._context && this._pmremGenerator && texture) {
-            if (debug) console.log("[MaterialX] Generating environment textures", texture.name);
-
-            const target = this._pmremGenerator.fromEquirectangular(texture);
-            const radianceRenderTarget = renderPMREMToEquirect(this._context.renderer, target.texture, 0.0, 1024, 512, target.height);
-            const irradianceRenderTarget = renderPMREMToEquirect(this._context.renderer, target.texture, 1.0, 32, 16, target.height);
-            target.dispose();
-            res = {
-                radianceTexture: radianceRenderTarget.texture,
-                irradianceTexture: irradianceRenderTarget.texture
-            }
-        }
-        else {
-            res = {
-                radianceTexture: null,
-                irradianceTexture: null
-            }
-        }
-        this._texturesCache.set(texture || null, res);
-        return res;
-    }
-
-    private updateLighting = (collectLights: boolean = false) => {
+    updateLighting(collectLights: boolean) {
         if (!this._context) return;
 
         // Find lights in scene
@@ -252,10 +210,24 @@ export class MaterialXEnvironment {
             this._lights = lights;
         }
 
-        if (state.materialXGenContext) {
-            const { lightData, lightCount } = getLightData(this._lights, state.materialXGenContext);
-            this._lightData = lightData;
-            this._lightCount = lightCount;
+        const { lightData, lightCount } = getLightData(state.materialXModule, this._lights, state.materialXGenContext);
+        this._lightData = lightData;
+        this._lightCount = lightCount;
+    }
+
+    // Reset the environment to allow re-initialization
+    reset() {
+        if (debug) console.log("[MaterialX] Resetting environment");
+        if (this._radianceTexture) {
+            this._radianceTexture.dispose();
+            this._radianceTexture = null;
         }
+        if (this._irradianceTexture) {
+            this._irradianceTexture.dispose();
+            this._irradianceTexture = null;
+        }
+        this._initializePromise = null;
+        this._lights = [];
+        this._lightData = null;
     }
 }

package/src/textureHelper.ts

@@ -40,7 +40,7 @@ export function renderPMREMToEquirect(renderer: WebGLRenderer, pmremTexture: Tex
     } else {
         imageHeight = 256; // Final fallback
     }
-
+    
     const maxMip = Math.log2(imageHeight) - 2;
     const cubeUVHeight = imageHeight;
     const cubeUVWidth = 3 * Math.max(Math.pow(2, maxMip), 7 * 16);
@@ -129,14 +129,14 @@ export function renderPMREMToEquirect(renderer: WebGLRenderer, pmremTexture: Tex
     const currentAutoClear = renderer.autoClear;
     const currentXrEnabled = renderer.xr.enabled;
     const currentShadowMapEnabled = renderer.shadowMap.enabled;
-
+    
     renderTarget.texture.generateMipmaps = true;
-
+    
     try {
         // Disable XR and shadow mapping during our render to avoid interference
         renderer.xr.enabled = false;
         renderer.shadowMap.enabled = false;
-
+        
         // Render to our target
         renderer.autoClear = true;
         renderer.setRenderTarget(renderTarget);
@@ -148,7 +148,7 @@ export function renderPMREMToEquirect(renderer: WebGLRenderer, pmremTexture: Tex
         renderer.autoClear = currentAutoClear;
         renderer.xr.enabled = currentXrEnabled;
         renderer.shadowMap.enabled = currentShadowMapEnabled;
-
+        
         // Clean up temporary objects
         geometry.dispose();
         material.dispose();
@@ -159,7 +159,7 @@ export function renderPMREMToEquirect(renderer: WebGLRenderer, pmremTexture: Tex
     renderTarget.texture.mapping = EquirectangularReflectionMapping;
 
     // Log mipmap infos
-    if (debug) console.log('[MaterialX] PMREM to Equirect Render Target:', {
+    if (debug) console.log('PMREM to Equirect Render Target:', {
         width: renderTarget.width,
         height: renderTarget.height,
         mipmaps: renderTarget.texture.mipmaps?.length,

package/src/utils.ts

@@ -2,7 +2,10 @@ import { Context, getParam } from "@needle-tools/engine";
 import { Mesh } from "three";
 
 export const debug = getParam("debugmaterialx");
-export const debugUpdate = getParam("debugmaterialxupdate");
+
+
+
+
 
 /**
  * =====================================
@@ -30,44 +33,6 @@ const patchWebGL2 = () => {
         }
         return uniform4fv.call(this, location, v);
     };
-
-    const uniform3fv = WebGL2RenderingContext.prototype.uniform3fv;
-    WebGL2RenderingContext.prototype.uniform3fv = function (location: WebGLUniformLocation | null, v: Float32Array | number[]) {
-        if (location) {
-            const uniformName = programAndNameToUniformLocation.get(location);
-            if (true) console.log("Calling uniform3fv", { location, v, name: uniformName?.name });
-        }
-        return uniform3fv.call(this, location, v);
-    };
-
-    const uniform3iv = WebGL2RenderingContext.prototype.uniform3iv;
-    WebGL2RenderingContext.prototype.uniform3iv = function (location: WebGLUniformLocation | null, v: Int32Array | number[]) {
-        if (location) {
-            const uniformName = programAndNameToUniformLocation.get(location);
-            if (true) console.log("Calling uniform3iv", { location, v, name: uniformName?.name });
-        }
-        return uniform3iv.call(this, location, v);
-    };
-
-    const uniform3uiv = WebGL2RenderingContext.prototype.uniform3uiv;
-    WebGL2RenderingContext.prototype.uniform3uiv = function (location: WebGLUniformLocation | null, v: Uint32Array | number[]) {
-        if (location) {
-            const uniformName = programAndNameToUniformLocation.get(location);
-            if (true) console.log("Calling uniform3uiv", { location, v, name: uniformName?.name });
-        }
-        return uniform3uiv.call(this, location, v);
-    };
-
-    const uniform3f = WebGL2RenderingContext.prototype.uniform3f;
-    WebGL2RenderingContext.prototype.uniform3f = function (location: WebGLUniformLocation
-        | null, x: number, y: number, z: number) {
-        if (location) {
-            const uniformName = programAndNameToUniformLocation.get(location);
-            if (uniformName?.name !== "diffuse")
-                if (true) console.log("Calling uniform3f", { location, x, y, z, name: uniformName?.name });
-        }
-        return uniform3f.call(this, location, x, y, z);
-    };
 };
 // patchWebGL2();
 

package/src/materialx.material.ts

@@ -1,227 +0,0 @@
-import { Camera, DoubleSide, FrontSide, GLSL3, Matrix3, Matrix4, Mesh, Object3D, ShaderMaterial, Texture, Vector3 } from "three";
-import { debug } from "./utils.js";
-import { MaterialXEnvironment, state } from "./materialx.js";
-import { getUniformValues, Loaders } from "./materialx.helper.js";
-import { Context } from "@needle-tools/engine";
-
-
-// Add helper matrices for uniform updates (similar to MaterialX example)
-const identityMatrix = new Matrix4();
-const normalMat = new Matrix3();
-const viewProjMat = new Matrix4();
-const worldViewPos = new Vector3();
-
-declare type MaterialXMaterialInitParameters = {
-    name: string,
-    shader: any,
-    loaders: Loaders,
-    transparent?: boolean,
-}
-
-export class MaterialXMaterial extends ShaderMaterial {
-
-    // copy(source: MaterialXMaterial): this {
-    //     super.copy(source);
-    //     this.name = source.name;
-    //     this.uniforms = { ...source.uniforms }; // Shallow copy of uniforms
-    //     this.envMapIntensity = source.envMapIntensity;
-    //     this.envMap = source.envMap;
-    //     this.updateUniforms = source.updateUniforms; // Copy the update function
-    //     return this;
-    // }
-
-    constructor(init?: MaterialXMaterialInitParameters) {
-
-        // TODO: we need to properly copy the uniforms and other properties from the source material
-        if (!init) {
-            super();
-            return;
-        }
-
-        // 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 = vertexShader.replace(/^#version.*$/gm, '').trim();
-        fragmentShader = fragmentShader.replace(/^#version.*$/gm, '').trim();
-
-        // MaterialX uses different attribute names than js defaults,
-        // so we patch the MaterialX shaders to match the js standard names.
-        // Otherwise, we'd have to modify the mesh attributes (see original MaterialX for reference).
-
-        // Patch vertexShader
-        vertexShader = vertexShader.replace(/\bi_position\b/g, 'position');
-        vertexShader = vertexShader.replace(/\bi_normal\b/g, 'normal');
-        vertexShader = vertexShader.replace(/\bi_texcoord_0\b/g, 'uv');
-        vertexShader = vertexShader.replace(/\bi_texcoord_1\b/g, 'uv1');
-        vertexShader = vertexShader.replace(/\bi_tangent\b/g, 'tangent');
-        vertexShader = vertexShader.replace(/\bi_color_0\b/g, 'color');
-
-        // Patch fragmentShader
-        fragmentShader = fragmentShader.replace(/\bi_position\b/g, 'position');
-        fragmentShader = fragmentShader.replace(/\bi_normal\b/g, 'normal');
-        fragmentShader = fragmentShader.replace(/\bi_texcoord_0\b/g, 'uv');
-        fragmentShader = fragmentShader.replace(/\bi_texcoord_1\b/g, 'uv1');
-        fragmentShader = fragmentShader.replace(/\bi_tangent\b/g, 'tangent');
-        fragmentShader = fragmentShader.replace(/\bi_color_0\b/g, 'color');
-
-        // Remove `in vec3 position;` and so on since they're already declared by ShaderMaterial
-        vertexShader = vertexShader.replace(/in\s+vec3\s+position;/g, '');
-        vertexShader = vertexShader.replace(/in\s+vec3\s+normal;/g, '');
-        vertexShader = vertexShader.replace(/in\s+vec3\s+uv;/g, '');
-        vertexShader = vertexShader.replace(/in\s+vec3\s+uv1;/g, '');
-        vertexShader = vertexShader.replace(/in\s+vec4\s+tangent;/g, '');
-        vertexShader = vertexShader.replace(/in\s+vec4\s+color;/g, '');
-
-        // Patch uv 2-component to 3-component (`texcoord_0 = uv;` needs to be replaced with `texcoord_0 = vec3(uv, 0.0);`)
-        // TODO what if we actually have a 3-component UV? Not sure what three.js does then
-        vertexShader = vertexShader.replace(/texcoord_0 = uv;/g, 'texcoord_0 = vec3(uv, 0.0);');
-
-        // Patch units – seems MaterialX uses different units and we end up with wrong light values?
-        // result.direction = light.position - position;
-        fragmentShader = fragmentShader.replace(
-            /result\.direction\s*=\s*light\.position\s*-\s*position;/g,
-            'result.direction = (light.position - position) * 10.0 / 1.0;');
-
-        // Add tonemapping and colorspace handling
-        // Replace `out vec4 out1;` with `out vec4 gl_FragColor;`
-        fragmentShader = fragmentShader.replace(
-            /out\s+vec4\s+out1;/,
-            'layout(location = 0) out vec4 pc_fragColor;\n#define gl_FragColor pc_fragColor');
-
-        // Replace `out1 = vec4(<CAPTURE>)` with `gl_FragColor = vec4(<CAPTURE>)` and tonemapping/colorspace handling
-        fragmentShader = fragmentShader.replace(/^\s*out1\s*=\s*vec4\((.*)\);/gm, `
-    gl_FragColor = vec4($1);
-    #include <tonemapping_fragment>
-    #include <colorspace_fragment>`);
-
-        const searchPath = ""; // Could be derived from the asset path if needed
-        const flipV = false; // Set based on your geometry requirements
-        const isTransparent = init.transparent ?? false;
-        super({
-            name: init.name,
-            uniforms: {
-                ...getUniformValues(init.shader.getStage('vertex'), init.loaders, searchPath, flipV),
-                ...getUniformValues(init.shader.getStage('pixel'), init.loaders, searchPath, flipV),
-            },
-            vertexShader: vertexShader,
-            fragmentShader: fragmentShader,
-            glslVersion: GLSL3,
-            transparent: isTransparent,
-            side: FrontSide,
-            depthTest: true,
-            depthWrite: !isTransparent,
-        });
-
-
-
-        Object.assign(this.uniforms, {
-            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' },
-            u_refractionEnv: { value: true },
-            u_numActiveLightSources: { value: 0 },
-            u_lightData: { value: [] }, // Array of light data
-        });
-
-        if (debug) {
-            // Get lighting and environment data from MaterialX environment
-            console.group("[MaterialX]: ", name);
-            console.log("Vertex shader length:", vertexShader.length, vertexShader);
-            console.log("Fragment shader length:", fragmentShader.length, fragmentShader);
-            console.groupEnd();
-        }
-
-    }
-
-
-    envMapIntensity: number = 1.0; // Default intensity for environment map
-    envMap: Texture | null = null; // Environment map texture, can be set externally
-    updateUniforms = (context: Context, environment: MaterialXEnvironment, object: Object3D, camera: Camera) => {
-
-        const uniforms = this.uniforms;
-
-        if (!uniforms) return;
-
-        // TODO remove. Not sure why this is needed, but without it
-        // we currently get some "swimming" where matrices are not up to date.
-        camera.updateMatrixWorld(true);
-
-        // Update standard transformation matrices
-        if (uniforms.u_worldMatrix) {
-            if (!uniforms.u_worldMatrix.value?.isMatrix4) uniforms.u_worldMatrix.value = new Matrix4();
-            uniforms.u_worldMatrix.value = object.matrixWorld;
-        }
-
-        if (uniforms.u_viewProjectionMatrix) {
-            if (!uniforms.u_viewProjectionMatrix.value?.isMatrix4) uniforms.u_viewProjectionMatrix.value = new Matrix4();
-            uniforms.u_viewProjectionMatrix.value.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
-        }
-
-        if (uniforms.u_viewPosition) {
-            if (!uniforms.u_viewPosition.value?.isVector3) uniforms.u_viewPosition.value = new Vector3();
-            uniforms.u_viewPosition.value.copy(camera.getWorldPosition(worldViewPos));
-        }
-
-        if (uniforms.u_worldInverseTransposeMatrix) {
-            if (!uniforms.u_worldInverseTransposeMatrix.value?.isMatrix4) uniforms.u_worldInverseTransposeMatrix.value = new Matrix4();
-            uniforms.u_worldInverseTransposeMatrix.value.setFromMatrix3(normalMat.getNormalMatrix(object.matrixWorld));
-        }
-
-        // Update time uniforms
-        if (uniforms.u_time) {
-            uniforms.u_time.value = context.time.time;
-        }
-        if (uniforms.u_frame) {
-            uniforms.u_frame.value = context.time.frame;
-        }
-
-        // Update light uniforms
-        this.updateEnvironmentUniforms(environment);
-
-        this.uniformsNeedUpdate = true;
-    }
-
-    private updateEnvironmentUniforms = (environment: MaterialXEnvironment) => {
-
-        // Get lighting data from environment
-        const lightData = environment.lightData || null;
-        const lightCount = environment.lightCount || 0;
-        const textures = environment.getTextures(this) || null;
-
-        // Update each generated material's lighting uniforms
-        if (!this.uniforms) return;
-
-        // Update light count
-        if (this.uniforms.u_numActiveLightSources && lightCount >= 0) {
-            this.uniforms.u_numActiveLightSources.value = lightCount;
-        }
-
-        // Update light data if we have lights
-        if (lightData) {
-            this.uniforms.u_lightData.value = lightData;
-            if (debug) console.log("[MaterialX] Updated light data for material", this.name, lightData, this.uniforms,);
-        }
-        else if (debug) console.warn("[MaterialX] No light data available to update uniforms for material", this.name);
-
-        // Update environment uniforms
-        if (this.uniforms.u_envMatrix) {
-            this.uniforms.u_envMatrix.value = identityMatrix;
-        }
-        if (this.uniforms.u_envRadiance) {
-            this.uniforms.u_envRadiance.value = textures.radianceTexture || null;
-        }
-        if (this.uniforms.u_envRadianceMips) {
-            this.uniforms.u_envRadianceMips.value = Math.trunc(Math.log2(Math.max(textures.radianceTexture?.source.data.width ?? 0, textures.radianceTexture?.source.data.height ?? 0))) + 1;
-        }
-        if (this.uniforms.u_envIrradiance) {
-            this.uniforms.u_envIrradiance.value = textures.irradianceTexture;
-        }
-
-        this.uniformsNeedUpdate = true;
-    }
-}

package/src/materialx.types.d.ts

@@ -1,50 +0,0 @@
-
-
-
-export namespace MaterialX {
-
-    export type MODULE = {
-        ShaderInterfaceType: any;
-        HwSpecularEnvironmentMethod: any;
-        HwShaderGenerator: {
-            bindLightShader(def: any, id: number, genContext: GenContext): void;
-            unbindLightShaders(context: any): void;
-        };
-        createDocument(): Document;
-        readFromXmlString(doc: Document, xml: string, unknown: string): void;
-        loadStandardLibraries(genContext: GenContext): StandardLibrary;
-        isTransparentSurface(renderableElement: any, target: string): boolean;
-    }
-
-
-    export type GenContext = {
-    }
-
-    export type StandardLibrary = {
-
-    }
-    
-    // https://github.com/AcademySoftwareFoundation/MaterialX/blob/b74787db6544283dc32afc8085ebc93cabe937cb/source/MaterialXGenShader/ShaderStage.h#L56
-    export type ShaderStage = {
-        getUniformBlocks(): Record<string, any>;
-    }
-
-    export type Document = {
-        setDataLibrary(lib: StandardLibrary): void;
-        importLibrary(lib: Document): void;
-
-        getNodes(): Node[];
-    }
-
-    export type Node = {
-        getType(): string;
-    }
-
-    export type Matrix = {
-        numRows(): number;
-        numColumns(): number;
-        get size(): number;
-        getItem(row: number, col: number): number;
-    }
-
-}