@types/three 0.179.0 → 0.181.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Mon, 04 Aug 2025 15:38:34 GMT
+ * Last updated: Fri, 31 Oct 2025 16:38:34 GMT
  * Dependencies: [@dimforge/rapier3d-compat](https://npmjs.com/package/@dimforge/rapier3d-compat), [@tweenjs/tween.js](https://npmjs.com/package/@tweenjs/tween.js), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [@webgpu/types](https://npmjs.com/package/@webgpu/types), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

three/examples/jsm/Addons.d.ts

@@ -89,6 +89,7 @@ export * from "./loaders/FontLoader.js";
 export * from "./loaders/GCodeLoader.js";
 export * from "./loaders/GLTFLoader.js";
 export * from "./loaders/HDRCubeTextureLoader.js";
+export * from "./loaders/HDRLoader.js";
 export * from "./loaders/IESLoader.js";
 export * from "./loaders/KMZLoader.js";
 export * from "./loaders/KTX2Loader.js";
@@ -108,7 +109,6 @@ export * from "./loaders/PDBLoader.js";
 export * from "./loaders/PLYLoader.js";
 export * from "./loaders/PVRLoader.js";
 export * from "./loaders/RGBELoader.js";
-export * from "./loaders/RGBMLoader.js";
 export * from "./loaders/STLLoader.js";
 export * from "./loaders/SVGLoader.js";
 export * from "./loaders/TDSLoader.js";

three/examples/jsm/controls/DragControls.d.ts

@@ -76,36 +76,6 @@ declare class DragControls extends Controls<DragControlsEventMap> {
      * @param domElement The HTML element used for event listeners. (optional)
      */
     constructor(objects: Object3D[], camera: Camera, domElement?: HTMLElement | null);
-
-    /**
-     * Returns the internal {@link Raycaster} instance that is used for intersection tests.
-     * @deprecated getRaycaster() has been deprecated. Use controls.raycaster instead.
-     */
-    getRaycaster(): Raycaster;
-
-    /**
-     * Sets an array of draggable objects by overwriting the existing one.
-     * @deprecated setObjects() has been deprecated. Use controls.objects instead.
-     */
-    setObjects(objects: readonly Object3D[]): void;
-
-    /**
-     * Returns the array of draggable objects.
-     * @deprecated getObjects() has been deprecated. Use controls.objects instead.
-     */
-    getObjects(): Object3D[];
-
-    /**
-     * Adds the event listeners of the controls.
-     * @deprecated activate() has been renamed to connect().
-     */
-    activate(): void;
-
-    /**
-     * Removes the event listeners of the controls.
-     * @deprecated deactivate() has been renamed to disconnect().
-     */
-    deactivate(): void;
 }
 
 export { DragControls };

three/examples/jsm/controls/PointerLockControls.d.ts

@@ -49,11 +49,6 @@ declare class PointerLockControls extends Controls<PointerLockControlsEventMap>
      */
     constructor(camera: Camera, domElement?: HTMLElement | null);
 
-    /**
-     * @deprecated getObject() has been deprecated. Use controls.object instead.
-     */
-    getObject(): Camera;
-
     /**
      * Returns the look direction of the camera.
      * @param v The target vector.

three/examples/jsm/exporters/DRACOExporter.d.ts

@@ -13,5 +13,5 @@ export interface DRACOExporterOptions {
 export class DRACOExporter {
     constructor();
 
-    parse(object: Mesh | Points, options?: DRACOExporterOptions): Int8Array;
+    parse(object: Mesh | Points, options?: DRACOExporterOptions): Int8Array<ArrayBuffer>;
 }

three/examples/jsm/exporters/EXRExporter.d.ts

@@ -22,6 +22,6 @@ export class EXRExporter {
         renderer: WebGLRenderer | WebGPURenderer,
         renderTarget: WebGLRenderTarget,
         options?: EXRExporterParseOptions,
-    ): Promise<Uint8Array>;
-    parse(dataTexture: DataTexture, options?: EXRExporterParseOptions): Promise<Uint8Array>;
+    ): Promise<Uint8Array<ArrayBuffer>>;
+    parse(dataTexture: DataTexture, options?: EXRExporterParseOptions): Promise<Uint8Array<ArrayBuffer>>;
 }

three/examples/jsm/exporters/KTX2Exporter.d.ts

@@ -2,6 +2,6 @@ import { Data3DTexture, DataTexture, WebGLRenderer, WebGLRenderTarget } from "th
 import { WebGPURenderer } from "three/webgpu";
 
 export class KTX2Exporter {
-    parse(renderer: WebGLRenderer | WebGPURenderer, rtt?: WebGLRenderTarget): Promise<Uint8Array>;
-    parse(texture: Data3DTexture | DataTexture): Promise<Uint8Array>;
+    parse(renderer: WebGLRenderer | WebGPURenderer, rtt?: WebGLRenderTarget): Promise<Uint8Array<ArrayBuffer>>;
+    parse(texture: Data3DTexture | DataTexture): Promise<Uint8Array<ArrayBuffer>>;
 }

three/examples/jsm/exporters/STLExporter.d.ts

@@ -15,7 +15,7 @@ export interface STLExporterOptions {
 export class STLExporter {
     constructor();
 
-    parse(scene: Object3D, options: STLExporterOptionsBinary): DataView;
+    parse(scene: Object3D, options: STLExporterOptionsBinary): DataView<ArrayBuffer>;
     parse(scene: Object3D, options?: STLExporterOptionsString): string;
-    parse(scene: Object3D, options?: STLExporterOptions): string | DataView;
+    parse(scene: Object3D, options?: STLExporterOptions): string | DataView<ArrayBuffer>;
 }

three/examples/jsm/exporters/USDZExporter.d.ts

@@ -17,10 +17,10 @@ export class USDZExporter {
 
     parse(
         scene: Object3D,
-        onDone: (result: Uint8Array) => void,
+        onDone: (result: Uint8Array<ArrayBuffer>) => void,
         onError: (error: unknown) => void,
         options?: USDZExporterOptions,
     ): void;
 
-    parseAsync(scene: Object3D, options?: USDZExporterOptions): Promise<Uint8Array>;
+    parseAsync(scene: Object3D, options?: USDZExporterOptions): Promise<Uint8Array<ArrayBuffer>>;
 }

three/examples/jsm/geometries/TextGeometry.d.ts

@@ -59,6 +59,8 @@ export interface TextGeometryParameters extends ExtrudeGeometryOptions {
      * @defaultValue `3`
      */
     bevelSegments?: number | undefined;
+
+    direction?: "ltr" | "rtl" | "tb" | undefined;
 }
 
 /**

three/examples/jsm/gpgpu/BitonicSort.d.ts

@@ -0,0 +1,21 @@
+import { Node, Renderer, StorageBufferNode } from "three/webgpu";
+
+export const getBitonicFlipIndices: (index: Node, blockHeight: Node) => Node;
+
+export const getBitonicDisperseIndices: (index: Node, swapSpan: Node) => Node;
+
+export interface BitonicSortOptions {
+    workgroupSize?: number | undefined;
+}
+
+export class BitonicSort {
+    infoStorage: StorageBufferNode;
+
+    swapOpCount: number;
+    stepCount: number;
+
+    constructor(renderer: Renderer, dataBuffer: StorageBufferNode, options?: BitonicSortOptions);
+
+    computeStep(renderer: Renderer): Promise<void>;
+    compute(renderer: Renderer): Promise<void>;
+}

three/examples/jsm/inspector/Inspector.d.ts

@@ -0,0 +1,10 @@
+import { RendererInspector } from "./RendererInspector.js";
+import { ParametersGroup } from "./tabs/Parameters.js";
+
+declare class Inspector extends RendererInspector {
+    createParameters(name: string): ParametersGroup;
+
+    get domElement(): HTMLDivElement;
+}
+
+export { Inspector };

three/examples/jsm/inspector/RendererInspector.d.ts

@@ -0,0 +1,4 @@
+import { InspectorBase } from "three/webgpu";
+
+export class RendererInspector extends InspectorBase {
+}

three/examples/jsm/inspector/tabs/Parameters.d.ts

@@ -0,0 +1,95 @@
+import { Tab } from "../ui/Tab.js";
+import { ValueButton, ValueCheckbox, ValueColor, ValueNumber, ValueSelect, ValueSlider } from "../ui/Values.js";
+
+type KeyToValueOfType<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T];
+
+interface ValueSelectWithParameters<T = Record<string, unknown>, K extends keyof T = keyof T>
+    extends ValueSelect<T, K>
+{
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueNumberWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends ValueNumber<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueSliderWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends ValueSlider<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueCheckboxWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, boolean> = KeyToValueOfType<T, boolean>,
+> extends ValueCheckbox<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueButtonWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, (this: T) => void> = KeyToValueOfType<T, (this: T) => void>,
+> extends ValueButton<T, K> {
+    name: (name: string) => this;
+}
+
+interface ValueColorWithParameters<
+    T = Record<string, unknown>,
+    K extends keyof T = keyof T,
+> extends ValueColor<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+declare class ParametersGroup {
+    name: string;
+
+    constructor(parameters: never, name: string);
+
+    add<T, K extends keyof T>(
+        object: T,
+        property: K,
+        options: ReadonlyArray<T[K]> | Record<string, T[K]>,
+    ): ValueSelectWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, number>>(
+        object: T,
+        property: K,
+        min: number,
+        max: number,
+        step?: number,
+    ): ValueSliderWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, number>>(
+        object: T,
+        property: K,
+        min?: number,
+    ): ValueNumberWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, boolean>>(
+        object: T,
+        property: K,
+        options?: never,
+    ): ValueCheckboxWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, (this: T) => void>>(
+        object: T,
+        property: K,
+        options?: never,
+    ): ValueButtonWithParameters<T, K>;
+
+    addFolder(name: string): ParametersGroup;
+
+    addColor<T, K extends keyof T>(object: T, property: K, rgbScale?: number): ValueColorWithParameters<T, K>;
+}
+
+declare class Parameters extends Tab {
+    createGroup(name: string): ParametersGroup;
+}
+
+export { Parameters };
+export type { ParametersGroup };

three/examples/jsm/inspector/ui/Tab.d.ts

@@ -0,0 +1,3 @@
+export class Tab {
+    constructor(title: string);
+}

three/examples/jsm/inspector/ui/Values.d.ts

@@ -0,0 +1,80 @@
+import { ColorRepresentation, EventDispatcher } from "three";
+
+type KeyToValueOfType<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T];
+
+declare class Value<T = Record<string, unknown>, K extends keyof T = keyof T> extends EventDispatcher {
+    onChange(callback: (value: T[K]) => void): this;
+}
+
+export interface ValueNumberParams {
+    value?: number;
+    step?: number;
+    min?: number;
+    max?: number;
+}
+
+declare class ValueNumber<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends Value<T, K> {
+    constructor(params: ValueNumberParams);
+}
+
+export interface ValueCheckboxParams {
+    value?: boolean;
+}
+
+declare class ValueCheckbox<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, boolean> = KeyToValueOfType<T, boolean>,
+> extends Value<T, K> {
+    constructor(params: ValueCheckboxParams);
+}
+
+export interface ValueSliderParams {
+    value?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+
+declare class ValueSlider<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends Value<T, K> {
+    constructor(params: ValueSliderParams);
+
+    setValue(val: number): this;
+    step(value: number): this;
+}
+
+export interface ValueSelectParams<T, K extends keyof T> {
+    options?: ReadonlyArray<T[K]> | Record<string, T[K]>;
+    value?: number;
+}
+
+declare class ValueSelect<T = Record<string, unknown>, K extends keyof T = keyof T> extends Value<T, K> {
+    constructor(params: ValueSelectParams<T, K>);
+}
+
+export interface ValueColorParams {
+    value?: ColorRepresentation;
+}
+
+declare class ValueColor<T = Record<string, unknown>, K extends keyof T = keyof T> extends Value<T, K> {
+    constructor(params: ValueColorParams);
+}
+
+export interface ValueButtonParams {
+    text?: string;
+    value?: () => void;
+}
+
+declare class ValueButton<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, (this: T) => void> = KeyToValueOfType<T, (this: T) => void>,
+> extends Value<T, K> {
+    constructor(params: ValueColorParams);
+}
+
+export { Value, ValueButton, ValueCheckbox, ValueColor, ValueNumber, ValueSelect, ValueSlider };

three/examples/jsm/interactive/SelectionBox.d.ts

@@ -1,16 +1,16 @@
-import { Camera, Frustum, Mesh, Object3D, Scene, Vector3 } from "three";
+import { Camera, Object3D, Scene, Vector3 } from "three";
 
-export class SelectionBox {
-    constructor(camera: Camera, scene: Scene, deep?: number);
+declare class SelectionBox {
     camera: Camera;
-    collection: Mesh[];
-    deep: number;
-    endPoint: Vector3;
     scene: Scene;
     startPoint: Vector3;
+    endPoint: Vector3;
+    collection: Object3D[];
     instances: Record<string, number[]>;
+    batches: Record<string, number[]>;
+    deep: number;
+
+    constructor(camera: Camera, scene: Scene, deep?: number);
 
-    select(startPoint?: Vector3, endPoint?: Vector3): Mesh[];
-    updateFrustum(startPoint: Vector3, endPoint: Vector3): void;
-    searchChildInFrustum(frustum: Frustum, object: Object3D): void;
+    select(startPoint?: Vector3, endPoint?: Vector3): Object3D[];
 }

three/examples/jsm/lighting/TiledLighting.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Lighting } from "three/webgpu";
 import { Light } from "../../../src/lights/Light.js";
 import TiledLightsNode from "../tsl/lighting/TiledLightsNode.js";
@@ -6,5 +5,5 @@ import TiledLightsNode from "../tsl/lighting/TiledLightsNode.js";
 export class TiledLighting extends Lighting {
     constructor();
 
-    createNode(lights?: Light[]): ShaderNodeObject<TiledLightsNode>;
+    createNode(lights?: Light[]): TiledLightsNode;
 }

three/examples/jsm/loaders/FontLoader.d.ts

@@ -37,5 +37,5 @@ export class Font {
 
     constructor(data: FontData);
 
-    generateShapes(text: string, size?: number): Shape[];
+    generateShapes(text: string, size?: number, direction?: "ltr" | "rtl" | "tb"): Shape[];
 }

three/examples/jsm/loaders/HDRCubeTextureLoader.d.ts

@@ -1,10 +1,10 @@
 import { CubeTexture, Loader, LoadingManager, TextureDataType } from "three";
 
-import { RGBELoader } from "./RGBELoader.js";
+import { HDRLoader } from "./HDRLoader.js";
 
 export class HDRCubeTextureLoader extends Loader<CubeTexture, readonly string[]> {
     constructor(manager?: LoadingManager);
-    hdrLoader: RGBELoader;
+    hdrLoader: HDRLoader;
     type: TextureDataType;
 
     load(

three/examples/jsm/loaders/HDRLoader.d.ts

@@ -0,0 +1,22 @@
+import { DataTextureLoader, LoadingManager, TextureDataType } from "three";
+
+export interface HDR {
+    width: number;
+    height: number;
+    data: Float32Array | Uint8Array;
+    header: string;
+    gamma: number;
+    exposure: number;
+    type: TextureDataType;
+}
+
+declare class HDRLoader extends DataTextureLoader {
+    type: TextureDataType;
+
+    constructor(manager?: LoadingManager);
+
+    parse(buffer: ArrayBuffer): HDR;
+    setDataType(type: TextureDataType): this;
+}
+
+export { HDRLoader };

three/examples/jsm/loaders/KTX2Loader.d.ts

@@ -35,6 +35,9 @@ export class KTX2Loader extends Loader<CompressedTexture> {
      */
     setWorkerLimit(limit: number): this;
 
+    /**
+     * "detectSupportAsync()" has been deprecated. Use "detectSupport()" and "await renderer.init();" when creating the renderer.
+     */
     detectSupportAsync(renderer: Renderer): Promise<this>;
 
     /**

three/examples/jsm/loaders/LDrawLoader.d.ts

@@ -10,17 +10,21 @@ export class LDrawLoader extends Loader<Group> {
 
     smoothNormals: boolean;
 
+    partsLibraryPath: string;
+
     ConditionalLineMaterial: typeof LDrawConditionalLineMaterial | typeof LDrawConditionalLineNodeMaterial | null;
 
     constructor(manager?: LoadingManager);
 
+    setPartsLibraryPath(path: string): this;
+
     setConditionalLineMaterial(
         type: typeof LDrawConditionalLineMaterial | typeof LDrawConditionalLineNodeMaterial,
     ): this;
 
     preloadMaterials(url: string): Promise<void>;
 
-    parse(text: string, path: string, onLoad: (data: Group) => void, onError?: (error: unknown) => void): void;
+    parse(text: string, onLoad: (data: Group) => void, onError?: (error: unknown) => void): void;
 
     setMaterials(materials: Material[]): this;
     clearMaterials(): this;

three/examples/jsm/loaders/RGBELoader.d.ts

@@ -1,19 +1,13 @@
-import { DataTextureLoader, LoadingManager, PixelFormat, TextureDataType } from "three";
+import { HDR, HDRLoader } from "./HDRLoader.js";
 
-export interface RGBE {
-    width: number;
-    height: number;
-    data: Float32Array | Uint8Array;
-    header: string;
-    gamma: number;
-    exposure: number;
-    type: TextureDataType;
+/**
+ * @deprecated RGBELoader has been deprecated. Please use HDRLoader instead.
+ */
+export interface RGBE extends HDR {
 }
 
-export class RGBELoader extends DataTextureLoader {
-    constructor(manager?: LoadingManager);
-    type: TextureDataType;
-
-    parse(buffer: ArrayBuffer): RGBE;
-    setDataType(type: TextureDataType): this;
+/**
+ * @deprecated RGBELoader has been deprecated. Please use HDRLoader instead.
+ */
+export class RGBELoader extends HDRLoader {
 }

three/examples/jsm/materials/WoodNodeMaterial.d.ts

@@ -0,0 +1,75 @@
+import * as THREE from "three";
+
+export type WoodGenus =
+    | "teak"
+    | "walnut"
+    | "white_oak"
+    | "pine"
+    | "poplar"
+    | "maple"
+    | "red_oak"
+    | "cherry"
+    | "cedar"
+    | "mahogany";
+export type WoodFinish = "raw" | "matte" | "semigloss" | "gloss";
+
+export const WoodGenuses: WoodGenus[];
+export const Finishes: WoodFinish[];
+
+export interface WoodParameters {
+    transformationMatrix: THREE.Matrix4;
+    centerSize: number;
+    largeWarpScale: number;
+    largeGrainStretch: number;
+    smallWarpStrength: number;
+    smallWarpScale: number;
+    fineWarpStrength: number;
+    fineWarpScale: number;
+    ringThickness: number;
+    ringBias: number;
+    ringSizeVariance: number;
+    ringVarianceScale: number;
+    barkThickness: number;
+    splotchScale: number;
+    splotchIntensity: number;
+    cellScale: number;
+    cellSize: number;
+    darkGrainColor: string | THREE.Color;
+    lightGrainColor: string | THREE.Color;
+    genus: WoodGenus;
+    finish: WoodFinish;
+    clearcoat: number;
+    clearcoatRoughness: number;
+    clearcoatDarken: number;
+}
+
+export function GetWoodPreset(genus: WoodGenus, finish: WoodFinish): WoodParameters;
+
+export class WoodNodeMaterial extends THREE.MeshPhysicalMaterial {
+    readonly isWoodNodeMaterial: true;
+
+    transformationMatrix: THREE.Matrix4;
+    centerSize: number;
+    largeWarpScale: number;
+    largeGrainStretch: number;
+    smallWarpStrength: number;
+    smallWarpScale: number;
+    fineWarpStrength: number;
+    fineWarpScale: number;
+    ringThickness: number;
+    ringBias: number;
+    ringSizeVariance: number;
+    ringVarianceScale: number;
+    barkThickness: number;
+    splotchScale: number;
+    splotchIntensity: number;
+    cellScale: number;
+    cellSize: number;
+    darkGrainColor: THREE.Color;
+    lightGrainColor: THREE.Color;
+    clearcoatDarken: number;
+
+    constructor(params?: Partial<WoodParameters>);
+
+    static fromPreset(genus?: WoodGenus, finish?: WoodFinish): WoodNodeMaterial;
+}

three/examples/jsm/math/ColorSpaces.d.ts

@@ -9,3 +9,7 @@ export const LinearDisplayP3ColorSpaceImpl: ColorSpaceDefinition;
 export const LinearRec2020ColorSpace: "rec2020-linear";
 
 export const LinearRec2020ColorSpaceImpl: ColorSpaceDefinition;
+
+export const ExtendedSRGBColorSpace: "extended-srgb";
+
+export const ExtendedSRGBColorSpaceImpl: ColorSpaceDefinition;

three/examples/jsm/objects/SkyMesh.d.ts

@@ -1,13 +1,12 @@
-import { ShaderNodeObject } from "three/tsl";
 import { BoxGeometry, Mesh, NodeMaterial, UniformNode, Vector3 } from "three/webgpu";
 
 declare class SkyMesh extends Mesh<BoxGeometry, NodeMaterial> {
-    turbidity: ShaderNodeObject<UniformNode<number>>;
-    rayleigh: ShaderNodeObject<UniformNode<number>>;
-    mieCoefficient: ShaderNodeObject<UniformNode<number>>;
-    mieDirectionalG: ShaderNodeObject<UniformNode<number>>;
-    sunPosition: ShaderNodeObject<UniformNode<Vector3>>;
-    upUniform: ShaderNodeObject<UniformNode<Vector3>>;
+    turbidity: UniformNode<number>;
+    rayleigh: UniformNode<number>;
+    mieCoefficient: UniformNode<number>;
+    mieDirectionalG: UniformNode<number>;
+    sunPosition: UniformNode<Vector3>;
+    upUniform: UniformNode<Vector3>;
 
     readonly isSky: true;
 

three/examples/jsm/objects/WaterMesh.d.ts

@@ -11,7 +11,7 @@ import {
 } from "three/webgpu";
 
 export interface WaterMeshOptions {
-    resolution?: number | undefined;
+    resolutionScale?: number | undefined;
     waterNormals: Texture;
     alpha?: number | undefined;
     size?: number | undefined;
@@ -24,7 +24,7 @@ export interface WaterMeshOptions {
 declare class WaterMesh extends Mesh<BufferGeometry, NodeMaterial> {
     readonly isWater: true;
 
-    resolution: number;
+    resolutionScale: number;
 
     waterNormals: TextureNode;
     alpha: UniformNode<number>;