@needle-tools/engine 4.13.1-next.9fc3e64 → 4.14.0-next.31f837e

package/dist/needle-engine.d.ts

@@ -10056,6 +10056,40 @@ export declare class MaskableGraphic extends Graphic {
     protected onAfterCreated(): void;
 }
 
+export declare class MaterialPropertyBlock<T extends Material = Material> {
+    private _overrides;
+    private _defines;
+    private _object;
+    get object(): Object3D | null;
+    constructor(object?: Object3D | null);
+    static get<T extends Material = Material>(object: Object3D): MaterialPropertyBlock<T>;
+    dispose(): void;
+    setOverride<K extends NonFunctionPropertyNames<T>>(name: K, value: T[K], textureTransform?: TextureTransform): void;
+    setOverride(name: string, value: MaterialPropertyType, textureTransform?: TextureTransform): void;
+    getOverride(name: string): PropertyBlockOverride | undefined;
+    clearOverride(name: string): void;
+    clearAllOverrides(): void;
+    removeOverride(name: string): void;
+    get overrides(): PropertyBlockOverride[];
+    hasOverrides(): boolean;
+    /**
+     * Set a shader define that will be included in the program cache key
+     * This allows different objects sharing the same material to have different shader programs
+     */
+    setDefine(name: string, value: string | number | boolean): void;
+    /**
+     * Remove a shader define
+     */
+    clearDefine(name: string): void;
+    /**
+     * Get all defines set on this property block
+     */
+    getDefines(): Readonly<Record<string, string | number | boolean>>;
+    getCacheKey(): string;
+}
+
+declare type MaterialPropertyType = number | number[] | Color | Texture | Vector2 | Vector3 | Vector4 | null;
+
 export declare namespace MaterialX {
     /**
      * Utility function to load a MaterialX material from a URL. This can be used in your own code to load MaterialX materials outside of the glTF loading process. The URL should point to a MaterialX XML file.
@@ -12184,6 +12218,10 @@ export declare class NoiseModule {
     apply(_index: number, pos: Vec3, vel: Vec3, _deltaTime: number, age: number, life: number): void;
 }
 
+declare type NonFunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+
 /** Removes all undefined functions */
 declare type NoUndefinedNoFunctions<T> = FilterTypes<T, Function | undefined | null>;
 
@@ -14653,6 +14691,12 @@ export declare class OrbitControls extends Component implements ICameraControlle
          constructor(reason: string);
      }
 
+     declare interface PropertyBlockOverride {
+         name: string;
+         value: MaterialPropertyType;
+         textureTransform?: TextureTransform;
+     }
+
      export declare const PUBLIC_KEY: string;
 
      /** Adds an entry to the browser history. Internally uses `window.history.pushState` */
@@ -15083,7 +15127,6 @@ export declare class OrbitControls extends Component implements ICameraControlle
          awake(): void;
          start(): void;
          onDestroy(): void;
-         private static _rendererMaterialsCache;
          onSet(_rend: IRenderer): void;
          onUnset(_rend: IRenderer): void;
      }
@@ -15485,23 +15528,27 @@ export declare class OrbitControls extends Component implements ICameraControlle
          private lightmapIndex;
          private lightmapScaleOffset;
          private readonly renderer;
-         private readonly clonedMaterials;
+         private _isApplied;
          private get context();
          private get gameObject();
          private lightmapTexture;
-         private lightmapScaleOffsetUniform;
-         private lightmapUniform;
          constructor(renderer: Renderer);
          init(lightmapIndex: number, lightmapScaleOffset: Vector4, lightmapTexture: Texture): void;
-         updateLightmapUniforms(material: Material): void;
+         updateLightmapUniforms(_material: any): void;
          /**
-          * Apply the lightmap to the object. This will clone the material and set the lightmap texture and scale/offset
+          * Apply the lightmap to the object using MaterialPropertyBlock instead of cloning materials.
+          * The lightmap texture and its per-object UV transform are set as overrides via PropertyBlock.
+          * Three.js reads material.lightMap to determine shader defines and upload uniforms,
+          * and uses texture.offset/repeat to compute lightMapTransform in the vertex shader.
           */
          applyLightmap(): void;
+         /** Update the lightMap override on all property blocks (e.g. after LOD swap) */
+         private updatePropertyBlockTexture;
+         /**
+          * Remove the lightmap from the object
+          */
+         onUnset(): void;
          private ensureLightmapUvs;
-         private ensureLightmapMaterial;
-         private assignLightmapTexture;
-         private onBeforeCompile;
          private setLightmapDebugMaterial;
      }
 
@@ -19271,6 +19318,11 @@ export declare class OrbitControls extends Component implements ICameraControlle
      /**@obsolete use Graphics.textureToCanvas */
      export declare function textureToCanvas(texture: Texture, force?: boolean): HTMLCanvasElement | null;
 
+     declare interface TextureTransform {
+         offset?: Vector2;
+         repeat?: Vector2;
+     }
+
      declare enum TextWrapMode {
          singleLine = "singleLine",
          hardBreaks = "hardBreaks",