@needle-tools/materialx 1.1.1-next.714bc32 → 1.1.1-next.8e8afe1

package/src/{materialx.helper.ts → materialx.helper.js}

@@ -4,7 +4,6 @@
 //
 import * as THREE from 'three';
 import { debug, debugUpdate } from './utils.js';
-import { MaterialX } from './materialx.types.js';
 
 const IMAGE_PROPERTY_SEPARATOR = "_";
 const UADDRESS_MODE_SUFFIX = IMAGE_PROPERTY_SEPARATOR + "uaddressmode";
@@ -13,13 +12,13 @@ const FILTER_TYPE_SUFFIX = IMAGE_PROPERTY_SEPARATOR + "filtertype";
 const IMAGE_PATH_SEPARATOR = "/";
 
 /**
- * Initialized the environment texture as MaterialX expects it
+ * Initializes the environment texture as MaterialX expects it
  * @param {THREE.Texture} texture
  * @param {Object} capabilities
  * @returns {THREE.Texture}
  */
 export function prepareEnvTexture(texture, capabilities) {
-    let newTexture = new THREE.DataTexture(texture.image.data, texture.image.width, texture.image.height, texture.format, texture.type);
+    let newTexture = new THREE.DataTexture(texture.image.data, texture.image.width, texture.image.height, /** @type {any} */ (texture.format), texture.type);
     newTexture.wrapS = THREE.RepeatWrapping;
     newTexture.anisotropy = capabilities.getMaxAnisotropy();
     newTexture.minFilter = THREE.LinearMipmapLinearFilter;
@@ -34,7 +33,7 @@ export function prepareEnvTexture(texture, capabilities) {
  * Get Three uniform from MaterialX vector
  * @param {any} value
  * @param {any} dimension
- * @returns {THREE.Uniform}
+ * @returns {Array<number>}
  */
 function fromVector(value, dimension) {
     let outValue;
@@ -52,8 +51,11 @@ function fromVector(value, dimension) {
 
 /**
  * Get Three uniform from MaterialX matrix
+ * @param {any} matrix
+ * @param {number} dimension
+ * @returns {Array<number>}
  */
-function fromMatrix(matrix: MaterialX.Matrix, dimension: MaterialX.Matrix["size"]) {
+function fromMatrix(matrix, dimension) {
     const vec = new Array(dimension);
     if (matrix) {
         for (let i = 0; i < matrix.numRows(); ++i) {
@@ -69,19 +71,11 @@ function fromMatrix(matrix: MaterialX.Matrix, dimension: MaterialX.Matrix["size"
     return vec;
 }
 
-
-export type Callbacks = {
-    /**
-     * Cache key for the loaders, used to identify and reuse textures
-     */
-    readonly cacheKey?: string;
-    /**
-     * Get a texture by path
-     * @param {string} path - The path to the texture
-     * @return {Promise<THREE.Texture>} - A promise that resolves to the texture
-     */
-    readonly getTexture: (path: string) => Promise<THREE.Texture | null | void>;
-}
+/**
+ * @typedef {Object} Callbacks
+ * @property {string} [cacheKey] - Cache key for the loaders, used to identify and reuse textures
+ * @property {(path: string) => Promise<THREE.Texture | null | void>} getTexture - Get a texture by path
+ */
 
 const defaultTexture = new THREE.Texture();
 defaultTexture.needsUpdate = true;
@@ -94,21 +88,28 @@ defaultTexture.image.src = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAA
 // defaultTexture.magFilter = THREE.NearestFilter;
 // defaultTexture.repeat = new THREE.Vector2(100, 100);
 
-
 const defaultNormalTexture = new THREE.Texture();
 defaultNormalTexture.needsUpdate = true;
 defaultNormalTexture.image = new Image();
 defaultNormalTexture.image.src = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIBAMAAAA2IaO4AAAAAXNSR0IB2cksfwAAAAlwSFlzAAALEwAACxMBAJqcGAAAABJQTFRFgYH4gIH4gYH3gIH3gIH5gID4m94ORAAAADFJREFUeJxjZBBkfMdo9P/BB0aBj/8FGB0ufghgFGT4r8wo+P8rD2Pgo3sMjIz8jAwAMLoN0ZjS5hgAAAAASUVORK5CYII=";
 
-
-function tryGetFromCache(key: string): any {
+/**
+ * @param {string} key
+ * @returns {any}
+ */
+function tryGetFromCache(key) {
     const wasEnabled = THREE.Cache.enabled;
     THREE.Cache.enabled = true;
     const value = THREE.Cache.get(key);
     THREE.Cache.enabled = wasEnabled;
     return value;
 }
-function addToCache(key: string, value: any): void {
+
+/**
+ * @param {string} key
+ * @param {any} value
+ */
+function addToCache(key, value) {
     const wasEnabled = THREE.Cache.enabled;
     THREE.Cache.enabled = true;
     THREE.Cache.add(key, value);
@@ -118,10 +119,17 @@ function addToCache(key: string, value: any): void {
 
 /**
  * Get Three uniform from MaterialX value
+ * @param {any} uniforms
+ * @param {string} type
+ * @param {any} value
+ * @param {string} name
+ * @param {Callbacks} loaders
+ * @param {string} searchPath
+ * @returns {THREE.Uniform}
  */
-function toThreeUniform(uniforms: any, type: string, value: any, name: string, loaders: Callbacks, searchPath: string): THREE.Uniform {
+function toThreeUniform(uniforms, type, value, name, loaders, searchPath) {
 
-    const uniform = new THREE.Uniform<any>(null);
+    const uniform = new THREE.Uniform(/** @type {any} */ (null));
 
     switch (type) {
         case 'float':
@@ -130,21 +138,21 @@ function toThreeUniform(uniforms: any, type: string, value: any, name: string, l
             uniform.value = value;
             break;
         case 'vector2':
-            uniform.value = fromVector(value, 2);
+            uniform.value = /** @type {any} */ (fromVector(value, 2));
             break;
         case 'vector3':
         case 'color3':
-            uniform.value = fromVector(value, 3);
+            uniform.value = /** @type {any} */ (fromVector(value, 3));
             break;
         case 'vector4':
         case 'color4':
-            uniform.value = fromVector(value, 4);
+            uniform.value = /** @type {any} */ (fromVector(value, 4));
             break;
         case 'matrix33':
-            uniform.value = fromMatrix(value, 9);
+            uniform.value = /** @type {any} */ (fromMatrix(value, 9));
             break;
         case 'matrix44':
-            uniform.value = fromMatrix(value, 16);
+            uniform.value = /** @type {any} */ (fromMatrix(value, 16));
             break;
         case 'filename':
             if (value) {
@@ -182,8 +190,8 @@ function toThreeUniform(uniforms: any, type: string, value: any, name: string, l
                 else {
                     if (debug) console.log('[MaterialX] Load texture:', texturePath);
 
-                    if (name.toLowerCase().includes("normal")) uniform.value = defaultNormalTexture;
-                    else uniform.value = defaultTexture;
+                    if (name.toLowerCase().includes("normal")) uniform.value = /** @type {any} */ (defaultNormalTexture);
+                    else uniform.value = /** @type {any} */ (defaultTexture);
                     const defaultValue = uniform.value;
                     // Save the loading promise in the cache
                     const promise = loaders.getTexture(texturePath)
@@ -203,7 +211,7 @@ function toThreeUniform(uniforms: any, type: string, value: any, name: string, l
                     if (checkCache) addToCache(cacheKey, promise);
                     
                     promise?.then(res => {
-                        if (res) uniform.value = res;
+                        if (res) uniform.value = /** @type {any} */ (res);
                         else console.warn(`[MaterialX] Failed to load texture ${name} '${texturePath}'`);
                     });
                 }
@@ -224,12 +232,15 @@ function toThreeUniform(uniforms: any, type: string, value: any, name: string, l
     return uniform;
 }
 
-const valueTypeWarningMap = new Map<string, boolean>();
+/** @type {Map<string, boolean>} */
+const valueTypeWarningMap = new Map();
 
 /**
  * Get Three wrapping mode
+ * @param {number} mode
+ * @returns {THREE.Wrapping}
  */
-function getWrapping(mode: number): THREE.Wrapping {
+function getWrapping(mode) {
     let wrap;
     switch (mode) {
         case 1:
@@ -248,11 +259,14 @@ function getWrapping(mode: number): THREE.Wrapping {
     return wrap;
 }
 
-
 /**
  * Set Three texture parameters
+ * @param {THREE.Texture} texture
+ * @param {string} name
+ * @param {any} uniforms
+ * @param {boolean} [generateMipmaps=true]
  */
-function setTextureParameters(texture: THREE.Texture, name: string, uniforms: any, generateMipmaps = true) {
+function setTextureParameters(texture, name, uniforms, generateMipmaps = true) {
     const idx = name.lastIndexOf(IMAGE_PROPERTY_SEPARATOR);
     const base = name.substring(0, idx) || name;
 
@@ -267,15 +281,16 @@ function setTextureParameters(texture: THREE.Texture, name: string, uniforms: an
     }
 
     const mxFilterType = uniforms.find(base + FILTER_TYPE_SUFFIX) ? uniforms.get(base + FILTER_TYPE_SUFFIX).value : -1;
-    let minFilter: THREE.TextureFilter = generateMipmaps ? THREE.LinearMipMapLinearFilter : THREE.LinearFilter;
+    let minFilter = generateMipmaps ? THREE.LinearMipMapLinearFilter : THREE.LinearFilter;
     if (mxFilterType === 0) {
-        minFilter = generateMipmaps ? THREE.NearestMipMapNearestFilter : THREE.NearestFilter;
+        minFilter = /** @type {any} */ (generateMipmaps ? THREE.NearestMipMapNearestFilter : THREE.NearestFilter);
     }
     texture.minFilter = minFilter;
 }
 
 /**
  * Return the global light rotation matrix
+ * @returns {THREE.Matrix4}
  */
 export function getLightRotation() {
     return new THREE.Matrix4().makeRotationY(Math.PI / 2);
@@ -283,11 +298,11 @@ export function getLightRotation() {
 
 /**
  * Returns all lights nodes in a MaterialX document
- * @param {mx.Document} doc 
- * @returns {Array.<mx.Node>}
+ * @param {any} doc
+ * @returns {Array<any>}
  */
-export function findLights(doc: MaterialX.Document) {
-    let lights = new Array<any>;
+export function findLights(doc) {
+    let lights = new Array();
     for (let node of doc.getNodes()) {
         if (node.getType() === "lightshader")
             lights.push(node);
@@ -295,14 +310,16 @@ export function findLights(doc: MaterialX.Document) {
     return lights;
 }
 
+/** @type {Object<string, number>} */
 let lightTypesBound = {};
 
 /**
  * Register lights in shader generation context
- * @param {MaterialX.MODULE} mx MaterialX Module
- * @param {mx.GenContext} genContext Shader generation context
+ * @param {any} mx - MaterialX Module
+ * @param {any} genContext - Shader generation context
+ * @returns {Promise<void>}
  */
-export async function registerLights(mx: MaterialX.MODULE, genContext: any): Promise<void> {
+export async function registerLights(mx, genContext) {
     lightTypesBound = {};
     const maxLightCount = genContext.getOptions().hwMaxActiveLightSources;
     mx.HwShaderGenerator.unbindLightShaders(genContext);
@@ -355,7 +372,11 @@ export async function registerLights(mx: MaterialX.MODULE, genContext: any): Pro
     if (debug) console.log("Light types bound in MaterialX context", lightTypesBound);
 }
 
-// Converts Three.js light type to MaterialX node name
+/**
+ * Converts Three.js light type to MaterialX node name
+ * @param {string} threeLightType
+ * @returns {string}
+ */
 function threeLightTypeToMaterialXNodeName(threeLightType) {
     switch (threeLightType) {
         case 'PointLight':
@@ -368,23 +389,27 @@ function threeLightTypeToMaterialXNodeName(threeLightType) {
             console.warn('MaterialX: Unsupported light type: ' + threeLightType);
             return 'ND_point_light'; // Default to point light
     }
-};
-
-export type LightData = {
-    type: number, // Light type ID
-    position: THREE.Vector3, // Position in world space
-    direction: THREE.Vector3, // Direction in world space
-    color: THREE.Color, // Color of the light
-    intensity: number, // Intensity of the light
-    decay_rate: number, // Decay rate for point and spot lights
-    inner_angle: number, // Inner angle for spot lights
-    outer_angle: number, // Outer angle for spot lights
 }
 
+/**
+ * @typedef {Object} LightData
+ * @property {number} type - Light type ID
+ * @property {THREE.Vector3} position - Position in world space
+ * @property {THREE.Vector3} direction - Direction in world space
+ * @property {THREE.Color} color - Color of the light
+ * @property {number} intensity - Intensity of the light
+ * @property {number} decay_rate - Decay rate for point and spot lights
+ * @property {number} inner_angle - Inner angle for spot lights
+ * @property {number} outer_angle - Outer angle for spot lights
+ */
+
 /**
  * Update light data for shader uniforms
+ * @param {Array<THREE.Light>} lights
+ * @param {any} genContext
+ * @returns {{ lightData: LightData[], lightCount: number }}
  */
-export function getLightData(lights: Array<THREE.Light>, genContext: any): { lightData: LightData[], lightCount: number } {
+export function getLightData(lights, genContext) {
     const lightData = new Array();
     const maxLightCount = genContext.getOptions().hwMaxActiveLightSources;
 
@@ -410,8 +435,8 @@ export function getLightData(lights: Array<THREE.Light>, genContext: any): { lig
         // float cosDir = dot(result.direction, -light.direction);
         // float spotAttenuation = smoothstep(low, high, cosDir);
 
-        const outerAngleRad = (light as THREE.SpotLight).angle;
-        const innerAngleRad = outerAngleRad * (1 - (light as THREE.SpotLight).penumbra);
+        const outerAngleRad = /** @type {THREE.SpotLight} */ (light).angle;
+        const innerAngleRad = outerAngleRad * (1 - /** @type {THREE.SpotLight} */ (light).penumbra);
         const inner_angle = Math.cos(innerAngleRad);
         const outer_angle = Math.cos(outerAngleRad);
 
@@ -422,7 +447,7 @@ export function getLightData(lights: Array<THREE.Light>, genContext: any): { lig
             color: new THREE.Color().fromArray(light.color.toArray()),
             // 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 * ((light as THREE.PointLight).isPointLight ? 683.0 / 3.1415 : (light as THREE.SpotLight).isSpotLight ? 683.0 / 3.1415 : 1.0),
+            intensity: light.intensity * (/** @type {THREE.PointLight} */ (light).isPointLight ? 683.0 / 3.1415 : /** @type {THREE.SpotLight} */ (light).isSpotLight ? 683.0 / 3.1415 : 1.0),
             decay_rate: 2.0,
             // Approximations for testing – the relevant light has 61.57986...129.4445 as inner/outer spot angle
             inner_angle: inner_angle,
@@ -455,8 +480,13 @@ export function getLightData(lights: Array<THREE.Light>, genContext: any): { lig
 
 /**
  * Get uniform values for a shader
+ * @param {any} shaderStage
+ * @param {Callbacks} loaders
+ * @param {string} searchPath
+ * @returns {Object<string, THREE.Uniform>}
  */
-export function getUniformValues(shaderStage: MaterialX.ShaderStage, loaders: Callbacks, searchPath: string) {
+export function getUniformValues(shaderStage, loaders, searchPath) {
+    /** @type {Object<string, THREE.Uniform>} */
     const threeUniforms = {};
 
     const uniformBlocks = shaderStage.getUniformBlocks()
@@ -479,7 +509,11 @@ export function getUniformValues(shaderStage: MaterialX.ShaderStage, loaders: Ca
     return threeUniforms;
 }
 
-export function generateMaterialPropertiesForUniforms(material: THREE.ShaderMaterial, shaderStage: MaterialX.ShaderStage) {
+/**
+ * @param {THREE.ShaderMaterial} material
+ * @param {any} shaderStage
+ */
+export function generateMaterialPropertiesForUniforms(material, shaderStage) {
 
     const uniformBlocks = shaderStage.getUniformBlocks()
     for (const [blockName, uniforms] of Object.entries(uniformBlocks)) {

package/src/{materialx.ts → materialx.js}

@@ -1,30 +1,27 @@
-import type { MaterialX as MX } from "./materialx.types.js";
 import MaterialX from "../bin/JsMaterialXGenShader.js";
 import { debug } from "./utils.js";
 import { renderPMREMToEquirect } from "./utils.texture.js";
 import { Light, Mesh, MeshBasicMaterial, Object3D, PlaneGeometry, PMREMGenerator, Scene, Texture, WebGLRenderer } from "three";
-import { registerLights, getLightData, LightData } from "./materialx.helper.js";
-import type { MaterialXMaterial } from "./materialx.material.js";
-
-export type MaterialXContext = {
-    getTime?(): number,
-    getFrame?(): number,
-}
-
+import { registerLights, getLightData } from "./materialx.helper.js";
 
 export const state = new class {
-    materialXModule: MX.MODULE | null = null;
-    materialXGenerator: any = null;
-    materialXGenContext: any = null;
-    materialXStdLib: any = null;
-    materialXInitPromise: Promise<void> | null = null;
+    /** @type {import("./materialx.types.js").MaterialX.MODULE | null} */
+    materialXModule = null;
+    /** @type {any} */
+    materialXGenerator = null;
+    /** @type {any} */
+    materialXGenContext = null;
+    /** @type {any} */
+    materialXStdLib = null;
+    /** @type {Promise<void> | null} */
+    materialXInitPromise = null;
 }
 
-
 /** 
  * Wait for the MaterialX WASM module to be ready.
+ * @returns {Promise<void>}
  */
-export async function ready(): Promise<void> {
+export async function ready() {
     if (state.materialXInitPromise) {
         return state.materialXInitPromise;
     }
@@ -33,18 +30,19 @@ export async function ready(): Promise<void> {
         if (debug) console.log("[MaterialX] Initializing WASM module...");
         try {
 
-            const urls: Array<string> = await Promise.all([
+            /** @type {Array<string>} */
+            const urls = await Promise.all([
                 /** @ts-ignore */
-                import(`../bin/JsMaterialXCore.wasm?url`).then(m => m.default || m),
+                import( /* @vite-ignore */ `../bin/JsMaterialXCore.wasm?url`).then(m => m.default || m),
                 /** @ts-ignore */
-                import(`../bin/JsMaterialXGenShader.wasm?url`).then(m => m.default || m),
+                import( /* @vite-ignore */ `../bin/JsMaterialXGenShader.wasm?url`).then(m => m.default || m),
                 /** @ts-ignore */
-                import(`../bin/JsMaterialXGenShader.data.txt?url`).then(m => m.default || m),
+                import( /* @vite-ignore */ `../bin/JsMaterialXGenShader.data.txt?url`).then(m => m.default || m),
             ]);
             const [JsMaterialXCore, JsMaterialXGenShader, JsMaterialXGenShader_data] = urls;
 
             const module = await MaterialX({
-                locateFile: (path: string, scriptDirectory: string) => {
+                locateFile: (/** @type {string} */ path, /** @type {string} */ scriptDirectory) => {
                     if (debug) console.debug("[MaterialX]  locateFile called:", { path, scriptDirectory });
 
                     if (path.includes("JsMaterialXCore.wasm")) {
@@ -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 = /** @type {import("./materialx.types.js").MaterialX.MODULE} */ (module);
 
             // Initialize shader generator and context
             state.materialXGenerator = module.EsslShaderGenerator.create();
@@ -108,45 +106,69 @@ export async function ready(): Promise<void> {
     })();
 }
 
-type EnvironmentTextureSet = {
-    radianceTexture: Texture | null;
-    irradianceTexture: Texture | null;
-}
-
+/**
+ * @typedef {Object} EnvironmentTextureSet
+ * @property {Texture | null} radianceTexture
+ * @property {Texture | null} irradianceTexture
+ */
 
 /**
  * MaterialXEnvironment manages the environment settings for MaterialX materials.
  */
 export class MaterialXEnvironment {
 
-    static get(scene: Scene): MaterialXEnvironment | null {
+    /**
+     * @param {Scene} scene
+     * @returns {MaterialXEnvironment | null}
+     */
+    static get(scene) {
         return this.getEnvironment(scene);
     }
-    private static _environments: WeakMap<Scene, MaterialXEnvironment> = new Map();
-    private static getEnvironment(scene: Scene): MaterialXEnvironment {
+
+    /** @type {WeakMap<Scene, MaterialXEnvironment>} */
+    static _environments = new Map();
+
+    /**
+     * @param {Scene} scene
+     * @returns {MaterialXEnvironment}
+     */
+    static getEnvironment(scene) {
         if (this._environments.has(scene)) {
-            return this._environments.get(scene)!;
+            return /** @type {MaterialXEnvironment} */ (this._environments.get(scene));
         }
         const env = new MaterialXEnvironment(scene);
         this._environments.set(scene, env);
         return env;
     }
 
-
-    private _lights: Array<Light> = [];
-    private _lightData: null | LightData[] = null;
-    private _lightCount: number = 0;
-
-    private _initializePromise: Promise<boolean> | null = null;
-    private _isInitialized: boolean = false;
-    private _lastUpdateFrame: number = -1;
-
-    constructor(private _scene: Scene) {
+    /** @type {Array<Light>} */
+    _lights = [];
+    /** @type {import("./materialx.helper.js").LightData[] | null} */
+    _lightData = null;
+    /** @type {number} */
+    _lightCount = 0;
+
+    /** @type {Promise<boolean> | null} */
+    _initializePromise = null;
+    /** @type {boolean} */
+    _isInitialized = false;
+    /** @type {number} */
+    _lastUpdateFrame = -1;
+
+    /**
+     * @param {Scene} _scene
+     */
+    constructor(_scene) {
+        this._scene = _scene;
         if (debug) console.log("[MaterialX] Environment created");
     }
 
-    // Initialize with Needle Engine context
-    async initialize(renderer: WebGLRenderer): Promise<boolean> {
+    /**
+     * Initialize with Needle Engine context
+     * @param {WebGLRenderer} renderer
+     * @returns {Promise<boolean>}
+     */
+    async initialize(renderer) {
         if (this._initializePromise) {
             return this._initializePromise;
         }
@@ -154,7 +176,12 @@ export class MaterialXEnvironment {
         return this._initializePromise;
     }
 
-    update(frame: number, scene: Scene, renderer: WebGLRenderer): void {
+    /**
+     * @param {number} frame
+     * @param {Scene} scene
+     * @param {WebGLRenderer} renderer
+     */
+    update(frame, scene, renderer) {
         if (!this._initializePromise) {
             this.initialize(renderer);
             return;
@@ -181,13 +208,15 @@ export class MaterialXEnvironment {
             const radianceCube = new Mesh(planeGeometry, radianceMat);
             const irradianceMat = unlitMat.clone();
             irradianceMat.map = textures.irradianceTexture;
-            const irradianceCube = new Mesh(planeGeometry, radianceMat);
+            const irradianceCube = new Mesh(planeGeometry, irradianceMat);
             scene.add(radianceCube);
             scene.add(irradianceCube);
             radianceCube.name = "MaterialXRadianceCube";
-            radianceCube.position.set(.6, 1, 0);
+            radianceCube.position.set(.8, 1, .01);
+            radianceCube.scale.set(1.5, 1, 1);
             irradianceCube.name = "MaterialXIrradianceCube";
-            irradianceCube.position.set(-.6, 1, 0);
+            irradianceCube.position.set(-.8, 1, -.01);
+            irradianceCube.scale.set(1.5, 0.98, 1);
             console.log("[MaterialX] environment initialized from Needle context", { textures, radianceCube, irradianceCube });
         }
     }
@@ -218,7 +247,11 @@ export class MaterialXEnvironment {
         return this._lightData;
     }
     get lightCount() { return this._lightCount || 0; }
-    getTextures(material: MaterialXMaterial) {
+
+    /**
+     * @param {import("./materialx.material.js").MaterialXMaterial} material
+     */
+    getTextures(material) {
         if (material.envMap) {
             // If the material has its own envMap, we don't use the irradiance texture
             return this._getTextures(material.envMap);
@@ -226,11 +259,18 @@ export class MaterialXEnvironment {
         return this._getTextures(this._scene.environment);
     }
 
-    private _pmremGenerator: PMREMGenerator | null = null;
-    private _renderer: WebGLRenderer | null = null;
-    private readonly _texturesCache: Map<Texture | null, EnvironmentTextureSet> = new Map();
-
-    private async _initialize(renderer: WebGLRenderer): Promise<boolean> {
+    /** @type {PMREMGenerator | null} */
+    _pmremGenerator = null;
+    /** @type {WebGLRenderer | null} */
+    _renderer = null;
+    /** @type {Map<Texture | null, EnvironmentTextureSet>} */
+    _texturesCache = new Map();
+
+    /**
+     * @param {WebGLRenderer} renderer
+     * @returns {Promise<boolean>}
+     */
+    async _initialize(renderer) {
         this._isInitialized = false;
         this._pmremGenerator = new PMREMGenerator(renderer);
         this._renderer = renderer;
@@ -239,11 +279,13 @@ export class MaterialXEnvironment {
         return true;
     }
 
-    private _getTextures(texture: Texture | null | undefined): {
-        radianceTexture: Texture | null,
-        irradianceTexture: Texture | null
-    } {
-        let res: EnvironmentTextureSet | undefined = this._texturesCache.get(texture || null);
+    /**
+     * @param {Texture | null | undefined} texture
+     * @returns {{radianceTexture: Texture | null, irradianceTexture: Texture | null}}
+     */
+    _getTextures(texture) {
+        /** @type {EnvironmentTextureSet | undefined} */
+        let res = this._texturesCache.get(texture || null);
         if (res) {
             return res;
         }
@@ -269,14 +311,18 @@ export class MaterialXEnvironment {
         return res;
     }
 
-    private updateLighting = (collectLights: boolean = false) => {
+    /**
+     * @param {boolean} collectLights
+     */
+    updateLighting = (collectLights = false) => {
         if (!this._scene) return;
         // Find lights in scene
         if (collectLights) {
-            const lights = new Array<Light>();
-            this._scene.traverse((object: Object3D) => {
-                if ((object as Light).isLight && object.visible)
-                    lights.push(object as Light);
+            /** @type {Array<Light>} */
+            const lights = new Array();
+            this._scene.traverse((/** @type {Object3D} */ object) => {
+                if ((/** @type {Light} */ (object)).isLight && object.visible)
+                    lights.push(/** @type {Light} */ (object));
             });
             this._lights = lights;
         }

package/src/materialx.material.d.ts

@@ -0,0 +1,37 @@
+import { BufferGeometry, Camera, Group, IUniform, MaterialParameters, Object3D, Scene, ShaderMaterial, Texture, WebGLRenderer } from "three";
+import { MaterialXContext, MaterialXEnvironment } from "./materialx.js";
+import { Callbacks } from "./materialx.helper.js";
+
+declare type MaterialXMaterialInitParameters = {
+    name: string;
+    shaderName?: string | null;
+    shader: any;
+    loaders: Callbacks;
+    context: MaterialXContext;
+    parameters?: MaterialParameters;
+    debug?: boolean;
+}
+
+type Uniforms = Record<string, IUniform & { needsUpdate?: boolean }>;
+type Precision = "highp" | "mediump" | "lowp";
+
+export declare class MaterialXMaterial extends ShaderMaterial {
+    readonly shaderName: string | null;
+
+    copy(source: MaterialXMaterial): this;
+
+    private _context: MaterialXContext | null;
+    private _shader: any;
+    private _needsTangents: boolean;
+
+    constructor(init?: MaterialXMaterialInitParameters);
+
+    private _missingTangentsWarned: boolean;
+    onBeforeRender(renderer: WebGLRenderer, _scene: Scene, camera: Camera, geometry: BufferGeometry, object: Object3D, _group: Group): void;
+
+    envMapIntensity: number;
+    envMap: Texture | null;
+    updateUniforms(environment: MaterialXEnvironment, _renderer: WebGLRenderer, object: Object3D, camera: Camera, time?: number, frame?: number): void;
+
+    private updateEnvironmentUniforms(environment: MaterialXEnvironment): void;
+}