@needle-tools/materialx 1.1.1-next.b7e5e45 → 1.1.1-next.fb25319

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;
+}

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

@@ -1,38 +1,43 @@
-import { BufferGeometry, Camera, FrontSide, GLSL3, Group, IUniform, MaterialParameters, Matrix3, Matrix4, Object3D, Scene, ShaderMaterial, Texture, Vector3, WebGLRenderer } from "three";
+import { BufferGeometry, Camera, FrontSide, GLSL3, Group, Matrix3, Matrix4, Object3D, Scene, ShaderMaterial, Texture, Vector3, WebGLRenderer } from "three";
 import { debug, getFrame, getTime } from "./utils.js";
-import { MaterialXContext, MaterialXEnvironment } from "./materialx.js";
-import { generateMaterialPropertiesForUniforms, getUniformValues, Callbacks } from "./materialx.helper.js";
+import { MaterialXEnvironment } from "./materialx.js";
+import { generateMaterialPropertiesForUniforms, getUniformValues } from "./materialx.helper.js";
 import { cloneUniforms, cloneUniformsGroups } from "three/src/renderers/shaders/UniformsUtils.js";
 
-
 // Add helper matrices for uniform updates (similar to MaterialX example)
 const normalMat = new Matrix3();
 const worldViewPos = new Vector3();
 
-declare type MaterialXMaterialInitParameters = {
-    name: string,
-    shaderName?: string | null, // Optional name of the shader
-    shader: any,
-    loaders: Callbacks,
-    context: MaterialXContext,
-    // Optional parameters
-    parameters?: MaterialParameters,
-    debug?: boolean,
-}
-
-type Uniforms = Record<string, IUniform & { needsUpdate?: boolean }>;
-type Precision = "highp" | "mediump" | "lowp";
+/**
+ * @typedef {Object} MaterialXMaterialInitParameters
+ * @property {string} name
+ * @property {string | null} [shaderName] - Optional name of the shader
+ * @property {any} shader
+ * @property {import('./materialx.helper.js').Callbacks} loaders
+ * @property {import('./materialx.js').MaterialXContext} context
+ * @property {import('three').MaterialParameters} [parameters] - Optional parameters
+ * @property {boolean} [debug] - Debug flag
+ */
+
+/**
+ * @typedef {"highp" | "mediump" | "lowp"} Precision
+ */
 
 export class MaterialXMaterial extends ShaderMaterial {
 
-    /** The original name of the shader */
-    readonly shaderName: string | null = null;
+    /** The original name of the shader 
+     * @type {string | null} */
+    shaderName = null;
 
-    copy(source: MaterialXMaterial): this {
+    /**
+     * @param {MaterialXMaterial} source
+     * @returns {this}
+     */
+    copy(source) {
         super.copy(source);
         this._context = source._context;
         this._shader = source._shader;
-        this.uniforms = cloneUniforms(source.uniforms) as Uniforms;
+        this.uniforms = cloneUniforms(source.uniforms);
         this.uniformsGroups = cloneUniformsGroups(source.uniformsGroups);
         this.envMapIntensity = source.envMapIntensity;
         this.envMap = source.envMap;
@@ -42,11 +47,17 @@ export class MaterialXMaterial extends ShaderMaterial {
         return this;
     }
 
-    private _context: MaterialXContext | null = null;
-    private _shader: any;
-    private _needsTangents: boolean = false;
+    /** @type {import('./materialx.js').MaterialXContext | null} */
+    _context = null;
+    /** @type {any} */
+    _shader = null;
+    /** @type {boolean} */
+    _needsTangents = false;
 
-    constructor(init?: MaterialXMaterialInitParameters) {
+    /**
+     * @param {MaterialXMaterialInitParameters} [init]
+     */
+    constructor(init) {
 
         // TODO: we need to properly copy the uniforms and other properties from the source material
         if (!init) {
@@ -77,7 +88,7 @@ export class MaterialXMaterial extends ShaderMaterial {
         vertexShader = vertexShader.replace(/\bi_color_0\b/g, 'color');
 
         // Patch fragmentShader
-        const precision: Precision = init.parameters?.precision || "highp" as Precision;
+        const precision = init.parameters?.precision || "highp";
         vertexShader = vertexShader.replace(/precision mediump float;/g, `precision ${precision} float;`);
         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`);
@@ -138,7 +149,7 @@ export class MaterialXMaterial extends ShaderMaterial {
     #include <tonemapping_fragment>
     #include <colorspace_fragment>`);
 
-        const defines: Record<string, string> = {};
+        const defines = {};
         if (hasUv1) defines['USE_UV1'] = '';
         if (hasUv2) defines['USE_UV2'] = '';
         if (hasUv3) defines['USE_UV3'] = '';
@@ -199,8 +210,18 @@ export class MaterialXMaterial extends ShaderMaterial {
         }
     }
 
-    private _missingTangentsWarned: boolean = false;
-    onBeforeRender(renderer: WebGLRenderer, _scene: Scene, camera: Camera, geometry: BufferGeometry, object: Object3D, _group: Group): void {
+    /** @type {boolean} */
+    _missingTangentsWarned = false;
+
+    /**
+     * @param {WebGLRenderer} renderer
+     * @param {Scene} _scene
+     * @param {Camera} camera
+     * @param {BufferGeometry} geometry
+     * @param {Object3D} object
+     * @param {Group} _group
+     */
+    onBeforeRender(renderer, _scene, camera, geometry, object, _group) {
         if (this._needsTangents && !geometry.attributes.tangent) {
             if (!this._missingTangentsWarned) {
                 this._missingTangentsWarned = true;
@@ -217,12 +238,22 @@ export class MaterialXMaterial extends ShaderMaterial {
         }
     }
 
+    /** @type {number} */
+    envMapIntensity = 1.0; // Default intensity for environment map
+    /** @type {Texture | null} */
+    envMap = null; // Environment map texture, can be set externally
 
-    envMapIntensity: number = 1.0; // Default intensity for environment map
-    envMap: Texture | null = null; // Environment map texture, can be set externally
-    updateUniforms = (environment: MaterialXEnvironment, _renderer: WebGLRenderer, object: Object3D, camera: Camera, time?: number, frame?: number) => {
+    /**
+     * @param {MaterialXEnvironment} environment
+     * @param {WebGLRenderer} _renderer
+     * @param {Object3D} object
+     * @param {Camera} camera
+     * @param {number} [time]
+     * @param {number} [frame]
+     */
+    updateUniforms = (environment, _renderer, object, camera, time, frame) => {
 
-        const uniforms = this.uniforms as Uniforms;
+        const uniforms = this.uniforms;
 
         // Update standard transformation matrices
         if (uniforms.u_worldMatrix) {
@@ -269,9 +300,13 @@ export class MaterialXMaterial extends ShaderMaterial {
         this.uniformsNeedUpdate = true;
     }
 
-    private updateEnvironmentUniforms = (environment: MaterialXEnvironment) => {
+    /**
+     * @private
+     * @param {MaterialXEnvironment} environment
+     */
+    updateEnvironmentUniforms = (environment) => {
 
-        const uniforms = this.uniforms as Uniforms;
+        const uniforms = this.uniforms;
 
         // Get lighting data from environment
         const lightData = environment.lightData || null;

package/src/utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Get URL parameter value
+ */
+export function getParam(name: string): boolean | string;
+
+export const debug: boolean | string;
+export const debugUpdate: boolean;
+
+/**
+ * Get current time in seconds
+ */
+export function getTime(): number;
+
+/**
+ * Get current frame number
+ */
+export function getFrame(): number;

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

@@ -1,8 +1,12 @@
 // import { BufferGeometry } from 'three';
 // import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 
-
-export function getParam(name: string) {
+/**
+ * Get URL parameter value
+ * @param {string} name - Parameter name
+ * @returns {boolean|string} Parameter value or false if not found
+ */
+export function getParam(name) {
     const urlParams = new URLSearchParams(window.location.search);
     const param = urlParams.get(name);
     if (param == null || param === "0" || param === "false") return false;
@@ -13,21 +17,30 @@ export function getParam(name: string) {
 export const debug = getParam("debugmaterialx");
 export const debugUpdate = debug === "update";
 
-
 let time = 0;
+/**
+ * Get current time in seconds
+ * @returns {number} Current time
+ */
 export function getTime() {
     return time;
 }
+
 let frame = 0;
+/**
+ * Get current frame number
+ * @returns {number} Current frame
+ */
 export function getFrame() {
     return frame;
 }
 
-const performance = window.performance || (window as any).webkitPerformance || (window as any).mozPerformance;
+const performance = window.performance || /** @type {any} */ (window).webkitPerformance || /** @type {any} */ (window).mozPerformance;
+
 function updateTime() {
     time = performance.now() / 1000; // Convert to seconds
     frame++;
     window.requestAnimationFrame(updateTime);
 }
-window.requestAnimationFrame(updateTime);
 
+window.requestAnimationFrame(updateTime);

package/src/utils.texture.d.ts

@@ -0,0 +1,13 @@
+import { WebGLRenderer, WebGLRenderTarget, Texture } from 'three';
+
+/**
+ * Renders a PMREM environment map to an equirectangular texture with specified roughness
+ */
+export function renderPMREMToEquirect(
+    renderer: WebGLRenderer,
+    pmremTexture: Texture,
+    roughness?: number,
+    width?: number,
+    height?: number,
+    renderTargetHeight?: number
+): WebGLRenderTarget;

package/src/{utils.texture.ts → utils.texture.js}

@@ -1,4 +1,4 @@
-import { WebGLRenderer, Scene, WebGLRenderTarget, PlaneGeometry, OrthographicCamera, ShaderMaterial, RGBAFormat, FloatType, LinearFilter, Mesh, EquirectangularReflectionMapping, RepeatWrapping, LinearMipMapLinearFilter, Texture, WebGLUtils } from 'three';
+import { WebGLRenderer, Scene, WebGLRenderTarget, PlaneGeometry, OrthographicCamera, ShaderMaterial, RGBAFormat, FloatType, LinearFilter, Mesh, EquirectangularReflectionMapping, RepeatWrapping, LinearMipMapLinearFilter, Texture } from 'three';
 import { getParam } from './utils.js';
 
 const debug = getParam("debugmaterialx");
@@ -7,25 +7,26 @@ const debug = getParam("debugmaterialx");
  * Renders a PMREM environment map to an equirectangular texture with specified roughness
  * @param {WebGLRenderer} renderer - Three.js WebGL renderer
  * @param {Texture} pmremTexture - PMREM texture (2D CubeUV layout) to convert
- * @param {number} roughness - Roughness value (0.0 to 1.0)
- * @param {number} width - Output texture width (default: 1024)
- * @param {number} height - Output texture height (default: 512)
- * @param {number} renderTargetHeight - Original render target height (optional, for proper PMREM parameter calculation)
+ * @param {number} [roughness=0.0] - Roughness value (0.0 to 1.0)
+ * @param {number} [width=1024] - Output texture width
+ * @param {number} [height=512] - Output texture height
+ * @param {number} [renderTargetHeight] - Original render target height (optional, for proper PMREM parameter calculation)
  * @returns {WebGLRenderTarget} Render target containing the equirectangular texture
- * @example // Creating an equirectangular texture from a PMREM environment map at a certain roughness level:
+ * @example 
+ * // Creating an equirectangular texture from a PMREM environment map at a certain roughness level:
  * const pmremRenderTarget = pmremGenerator.fromEquirectangular(envMap);
  * const equirectRenderTarget = await renderPMREMToEquirect(renderer, pmremRenderTarget.texture, 0.5, 2048, 1024, pmremRenderTarget.height);
-    
-    // Use the rendered equirectangular texture
-    const equirectTexture = equirectRenderTarget.texture;
-    
-    // Apply to your material or save/export
-    someMaterial.map = equirectTexture;
-    
-    // Don't forget to dispose when done
-    // equirectRenderTarget.dispose();
+ * 
+ * // Use the rendered equirectangular texture
+ * const equirectTexture = equirectRenderTarget.texture;
+ * 
+ * // Apply to your material or save/export
+ * someMaterial.map = equirectTexture;
+ * 
+ * // Don't forget to dispose when done
+ * // equirectRenderTarget.dispose();
  */
-export function renderPMREMToEquirect(renderer: WebGLRenderer, pmremTexture: Texture, roughness = 0.0, width = 1024, height = 512, renderTargetHeight?: number) {
+export function renderPMREMToEquirect(renderer, pmremTexture, roughness = 0.0, width = 1024, height = 512, renderTargetHeight) {
     // TODO Validate inputs
     // console.log(renderer, pmremTexture);
 
@@ -167,4 +168,4 @@ export function renderPMREMToEquirect(renderer: WebGLRenderer, pmremTexture: Tex
     });
 
     return renderTarget;
-}
+}

package/src/loader/loader.needle.ts

@@ -1,43 +0,0 @@
-import { addCustomExtensionPlugin } from "@needle-tools/engine";
-import { Context, GLTF, INeedleGLTFExtensionPlugin } from "@needle-tools/engine";
-import type { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
-import type { GLTFExporter } from "three/examples/jsm/exporters/GLTFExporter.js";
-import { useNeedleMaterialX as _useNeedleMaterialX, MaterialXLoader } from "./loader.three.js";
-import { debug } from "../utils.js";
-import { MaterialParameters } from "three";
-
-
-export class MaterialXLoaderPlugin implements INeedleGLTFExtensionPlugin {
-    readonly name = "MaterialXLoaderPlugin";
-
-    private loader: MaterialXLoader | null = null;
-
-    onImport = (loader: GLTFLoader, url: string, context: Context) => {
-        if (debug) console.log("MaterialXLoaderPlugin: Registering MaterialX extension for", url);
-        _useNeedleMaterialX(loader, {
-            cacheKey: url,
-            parameters: {
-                precision: context.renderer.capabilities.getMaxPrecision("highp") as MaterialParameters["precision"],
-            }
-        }, {
-            getTime: () => context.time.time,
-            getFrame: () => context.time.frame,
-        });
-    };
-
-    onLoaded = (url: string, gltf: GLTF, _context: Context) => {
-        if (debug) console.log("[MaterialX] MaterialXLoaderPlugin: glTF loaded", { url, scene: gltf.scene, materialX_root_data: this.loader?.materialX_root_data });
-    };
-
-    onExport = (_exporter: GLTFExporter, _context: Context) => {
-        console.warn("[MaterialX] Export is not supported");
-    };
-}
-
-
-/**
- * Add the MaterialXLoaderPlugin to the Needle Engine.
- */
-export async function useNeedleMaterialX() {
-    addCustomExtensionPlugin(new MaterialXLoaderPlugin());
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "useDefineForClassFields": true,
-    "module": "ESNext",
-    "lib": ["ESNext", "DOM"],
-    "moduleResolution": "Node",
-    "strict": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "noEmit": true,
-    "noUnusedLocals": false,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noImplicitAny": false,
-    "experimentalDecorators": true
-  },
-  "include": ["."]
-}