@types/three 0.176.0 → 0.178.0

three/src/materials/nodes/SpriteNodeMaterial.d.ts

@@ -1,26 +1,76 @@
-import { Color } from "../../math/Color.js";
 import Node from "../../nodes/core/Node.js";
-import { Texture } from "../../textures/Texture.js";
-import { SpriteMaterialParameters } from "../SpriteMaterial.js";
-import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
-
-export interface SpriteNodeMaterialParameters extends NodeMaterialParameters, SpriteMaterialParameters {
-}
-
-export default class SpriteNodeMaterial extends NodeMaterial {
-    isSpriteNodeMaterial: true;
+import NodeBuilder from "../../nodes/core/NodeBuilder.js";
+import { MapColorPropertiesToColorRepresentations } from "../Material.js";
+import { SpriteMaterialParameters, SpriteMaterialProperties } from "../SpriteMaterial.js";
+import NodeMaterial, { NodeMaterialNodeProperties } from "./NodeMaterial.js";
 
+export interface SpriteNodeMaterialNodeProperties extends NodeMaterialNodeProperties {
+    /**
+     * The rotation of sprite materials is by default inferred from the `rotation`,
+     * property. This node property allows to overwrite the default and define
+     * the rotation with a node instead.
+     *
+     * If you don't want to overwrite the rotation but modify the existing
+     * value instead, use {@link materialRotation}.
+     *
+     * @default null
+     */
     rotationNode: Node | null;
+    /**
+     * This node property provides an additional way to scale sprites next to
+     * `Object3D.scale`. The scale transformation based in `Object3D.scale`
+     * is multiplied with the scale value of this node in the vertex shader.
+     *
+     * @default null
+     */
     scaleNode: Node | null;
+    set sizeAttenuation(value: boolean);
+    /**
+     * Whether to use size attenuation or not.
+     *
+     * @type {boolean}
+     * @default true
+     */
+    get sizeAttenuation(): boolean;
+}
 
-    // Properties from SpriteMaterial
-    readonly isSpriteMaterial: true;
-    color: Color;
-    map: Texture | null;
-    alphaMap: Texture | null;
-    rotation: number;
-    sizeAttenuation: boolean;
-    fog: boolean;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface SpriteNodeMaterialParameters
+    extends
+        Partial<MapColorPropertiesToColorRepresentations<SpriteNodeMaterialNodeProperties>>,
+        SpriteMaterialParameters
+{}
 
+/**
+ * Node material version of {@link SpriteMaterial}.
+ */
+declare class SpriteNodeMaterial extends NodeMaterial {
+    /**
+     * Constructs a new sprite node material.
+     *
+     * @param {Object} [parameters] - The configuration parameter.
+     */
     constructor(parameters?: SpriteNodeMaterialParameters);
+    readonly isSpriteMaterial: boolean;
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isSpriteNodeMaterial: boolean;
+    /**
+     * Setups the position node in view space. This method implements
+     * the sprite specific vertex shader.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {Node<vec3>} The position in view space.
+     */
+    setupPositionView(builder: NodeBuilder): Node;
 }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface SpriteNodeMaterial extends SpriteNodeMaterialNodeProperties, SpriteMaterialProperties {}
+
+export default SpriteNodeMaterial;

three/src/materials/nodes/VolumeNodeMaterial.d.ts

@@ -1,22 +1,58 @@
-import FunctionNode from "../../nodes/code/FunctionNode.js";
 import Node from "../../nodes/core/Node.js";
+import VolumetricLightingModel from "../../nodes/functions/VolumetricLightingModel.js";
 import { ShaderNodeObject } from "../../nodes/tsl/TSLCore.js";
-import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
-
-export interface VolumeNodeMaterialParameters extends NodeMaterialParameters {
-    steps?: number | undefined;
-
-    scatteringNode?: Node | null | undefined;
-}
-
-export default class VolumeNodeMaterial extends NodeMaterial {
-    readonly isVolumeNodeMaterial: true;
+import { MapColorPropertiesToColorRepresentations, MaterialParameters, MaterialProperties } from "../Material.js";
+import NodeMaterial, { NodeMaterialNodeProperties } from "./NodeMaterial.js";
 
+export interface VolumeNodeMaterialNodeProperties extends NodeMaterialNodeProperties {
+    /**
+     * Number of steps used for raymarching.
+     *
+     * @default 25
+     */
     steps: number;
-
+    /**
+     * Offsets the distance a ray has been traveled through a volume.
+     * Can be used to implement dithering to reduce banding.
+     *
+     * @default null
+     */
+    offsetNode: Node;
+    /**
+     * Node used for scattering calculations.
+     *
+     * @default null
+     */
     scatteringNode: (params: { positionRay: ShaderNodeObject<Node> }) => Node | null;
+}
 
-    offsetNode?: Node | undefined;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface VolumeNodeMaterialParameters
+    extends Partial<MapColorPropertiesToColorRepresentations<VolumeNodeMaterialNodeProperties>>, MaterialParameters
+{}
 
-    constructor(parameters?: NodeMaterialParameters);
+/**
+ * Volume node material.
+ *
+ * @augments NodeMaterial
+ */
+declare class VolumeNodeMaterial extends NodeMaterial {
+    /**
+     * Constructs a new volume node material.
+     *
+     * @param {Object} [parameters] - The configuration parameter.
+     */
+    constructor(parameters?: VolumeNodeMaterialParameters);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @default true
+     */
+    readonly isVolumeNodeMaterial: boolean;
+    setupLightingModel(): VolumetricLightingModel;
 }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface VolumeNodeMaterial extends VolumeNodeMaterialNodeProperties, MaterialProperties {}
+
+export default VolumeNodeMaterial;

three/src/materials/nodes/manager/NodeMaterialObserver.d.ts

@@ -12,6 +12,7 @@ declare const refreshUniforms: readonly [
     "anisotropyMap",
     "anisotropyRotation",
     "aoMap",
+    "aoMapIntensity",
     "attenuationColor",
     "attenuationDistance",
     "bumpMap",
@@ -24,8 +25,10 @@ declare const refreshUniforms: readonly [
     "dispersion",
     "displacementMap",
     "emissive",
+    "emissiveIntensity",
     "emissiveMap",
     "envMap",
+    "envMapIntensity",
     "gradientMap",
     "ior",
     "iridescence",
@@ -33,6 +36,7 @@ declare const refreshUniforms: readonly [
     "iridescenceMap",
     "iridescenceThicknessMap",
     "lightMap",
+    "lightMapIntensity",
     "map",
     "matcap",
     "metalness",

three/src/math/Box3.d.ts

@@ -63,4 +63,12 @@ export class Box3 {
      * @deprecated Use {@link Box3#intersectsSphere .intersectsSphere()} instead.
      */
     isIntersectionSphere(s: any): any;
+
+    toJSON(): Box3JSON;
+    fromJSON(json: Box3JSON): this;
+}
+
+export interface Box3JSON {
+    min: number[];
+    max: number[];
 }

three/src/math/Color.d.ts

@@ -302,7 +302,7 @@ export class Color {
     getHex(colorSpace?: string): number;
 
     /**
-     * Returns the string formated hexadecimal value of this color.
+     * Returns the string formatted hexadecimal value of this color.
      */
     getHexString(colorSpace?: string): string;
 

three/src/math/ColorManagement.d.ts

@@ -29,9 +29,9 @@ export interface ColorManagement {
 
     convert: (color: Color, sourceColorSpace: string, targetColorSpace: string) => Color;
 
-    fromWorkingColorSpace: (color: Color, targetColorSpace: string) => Color;
+    workingToColorSpace: (color: Color, targetColorSpace: string) => Color;
 
-    toWorkingColorSpace: (color: Color, sourceColorSpace: string) => Color;
+    colorSpaceToWorking: (color: Color, sourceColorSpace: string) => Color;
 
     getPrimaries: (colorSpace: string) => [number, number, number, number, number, number];
 
@@ -40,6 +40,16 @@ export interface ColorManagement {
     getLuminanceCoefficients: (target: Vector3, colorSpace?: string) => [number, number, number];
 
     define: (colorSpaces: Record<string, ColorSpaceDefinition>) => void;
+
+    /**
+     * @deprecated .fromWorkingColorSpace() has been renamed to .workingToColorSpace().
+     */
+    fromWorkingColorSpace: (color: Color, targetColorSpace: string) => Color;
+
+    /**
+     * @deprecated .toWorkingColorSpace() has been renamed to .colorSpaceToWorking().
+     */
+    toWorkingColorSpace: (color: Color, sourceColorSpace: string) => Color;
 }
 
 export const ColorManagement: ColorManagement;

three/src/math/Sphere.d.ts

@@ -44,4 +44,12 @@ export class Sphere {
      * @deprecated Use {@link Sphere#isEmpty .isEmpty()} instead.
      */
     empty(): any;
+
+    toJSON(): SphereJSON;
+    fromJSON(json: SphereJSON): this;
+}
+
+export interface SphereJSON {
+    radius: number;
+    center: number[];
 }

three/src/math/Triangle.d.ts

@@ -83,7 +83,7 @@ export class Triangle {
         target: Vector4,
     ): Vector4 | null;
     static getInterpolatedAttribute(
-        attr: BufferAttribute,
+        attr: BufferAttribute | InterleavedBufferAttribute,
         i1: number,
         i2: number,
         i3: number,
@@ -91,7 +91,7 @@ export class Triangle {
         target: Vector2,
     ): Vector2;
     static getInterpolatedAttribute(
-        attr: BufferAttribute,
+        attr: BufferAttribute | InterleavedBufferAttribute,
         i1: number,
         i2: number,
         i3: number,
@@ -99,7 +99,7 @@ export class Triangle {
         target: Vector3,
     ): Vector3;
     static getInterpolatedAttribute(
-        attr: BufferAttribute,
+        attr: BufferAttribute | InterleavedBufferAttribute,
         i1: number,
         i2: number,
         i3: number,

three/src/nodes/Nodes.d.ts

@@ -39,6 +39,7 @@ export { default as PropertyNode } from "./core/PropertyNode.js";
 export { default as StackNode } from "./core/StackNode.js";
 export { default as StructNode } from "./core/StructNode.js";
 export { default as StructTypeNode } from "./core/StructTypeNode.js";
+export { default as SubBuildNode } from "./core/SubBuildNode.js";
 export { default as TempNode } from "./core/TempNode.js";
 export { default as UniformGroupNode } from "./core/UniformGroupNode.js";
 export { default as UniformNode } from "./core/UniformNode.js";
@@ -52,11 +53,9 @@ export { NodeUtils };
 export { default as ArrayElementNode } from "./utils/ArrayElementNode.js";
 export { default as ConvertNode } from "./utils/ConvertNode.js";
 export { default as DebugNode } from "./utils/DebugNode.js";
-export { default as EquirectUVNode } from "./utils/EquirectUVNode.js";
 export { default as FunctionOverloadingNode } from "./utils/FunctionOverloadingNode.js";
 export { default as JoinNode } from "./utils/JoinNode.js";
 export { default as LoopNode } from "./utils/LoopNode.js";
-export { default as MatcapUVNode } from "./utils/MatcapUVNode.js";
 export { default as MaxMipLevelNode } from "./utils/MaxMipLevelNode.js";
 export { default as MemberNode } from "./utils/MemberNode.js";
 export { default as ReflectorNode, ReflectorNodeParameters } from "./utils/ReflectorNode.js";
@@ -67,7 +66,6 @@ export { default as SetNode } from "./utils/SetNode.js";
 export { default as SplitNode } from "./utils/SplitNode.js";
 export { default as SpriteSheetUVNode } from "./utils/SpriteSheetUVNode.js";
 export { default as StorageArrayElementNode } from "./utils/StorageArrayElementNode.js";
-export { default as TriplanarTexturesNode } from "./utils/TriplanarTexturesNode.js";
 
 // accessors
 export { default as BatchNode } from "./accessors/BatchNode.js";
@@ -139,6 +137,7 @@ export { default as LightingNode } from "./lighting/LightingNode.js";
 export { default as LightProbeNode } from "./lighting/LightProbeNode.js";
 export { default as LightsNode } from "./lighting/LightsNode.js";
 export { default as PointLightNode } from "./lighting/PointLightNode.js";
+export { default as ProjectorLightNode } from "./lighting/ProjectorLightNode.js";
 export { default as RectAreaLightNode, RectAreaLightTexturesLib } from "./lighting/RectAreaLightNode.js";
 export { default as ShadowBaseNode } from "./lighting/ShadowBaseNode.js";
 export { default as ShadowNode } from "./lighting/ShadowNode.js";

three/src/nodes/TSL.d.ts

@@ -24,10 +24,10 @@ export * from "./math/MathUtils.js";
 export * from "./math/TriNoise3D.js";
 
 // utils
-export * from "./utils/EquirectUVNode.js";
+export * from "./utils/EquirectUV.js";
 export * from "./utils/FunctionOverloadingNode.js";
 export * from "./utils/LoopNode.js";
-export * from "./utils/MatcapUVNode.js";
+export * from "./utils/MatcapUV.js";
 export * from "./utils/MaxMipLevelNode.js";
 export * from "./utils/Oscillators.js";
 export * from "./utils/Packing.js";
@@ -36,10 +36,11 @@ export * from "./utils/ReflectorNode.js";
 export * from "./utils/RemapNode.js";
 export * from "./utils/RotateNode.js";
 export * from "./utils/RTTNode.js";
+export * from "./utils/SampleNode.js";
 export * from "./utils/SpriteSheetUVNode.js";
 export * from "./utils/SpriteUtils.js";
 export * from "./utils/Timer.js";
-export * from "./utils/TriplanarTexturesNode.js";
+export * from "./utils/TriplanarTextures.js";
 export * from "./utils/UVUtils.js";
 export * from "./utils/ViewportUtils.js";
 

three/src/nodes/accessors/AccessorsUtils.d.ts

@@ -1,9 +1,9 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const TBNViewMatrix: ShaderNodeObject<Node>;
 
 export const parallaxDirection: ShaderNodeObject<Node>;
-export const parallaxUV: (uv: ShaderNodeObject<Node>, scale: NodeRepresentation) => ShaderNodeObject<Node>;
+export const parallaxUV: (uv: ShaderNodeObject<Node>, scale: Node) => ShaderNodeObject<Node>;
 
-export const transformedBentNormalView: ShaderNodeObject<Node>;
+export const bentNormalView: ShaderNodeObject<Node>;

three/src/nodes/accessors/Bitangent.d.ts

@@ -5,5 +5,3 @@ export const bitangentGeometry: ShaderNodeObject<MathNode>;
 export const bitangentLocal: ShaderNodeObject<MathNode>;
 export const bitangentView: ShaderNodeObject<MathNode>;
 export const bitangentWorld: ShaderNodeObject<MathNode>;
-export const transformedBitangentView: ShaderNodeObject<MathNode>;
-export const transformedBitangentWorld: ShaderNodeObject<MathNode>;

three/src/nodes/accessors/CubeTextureNode.d.ts

@@ -1,6 +1,6 @@
 import { CubeTexture } from "../../textures/CubeTexture.js";
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import TextureNode from "./TextureNode.js";
 
 declare class CubeTextureNode extends TextureNode {
@@ -20,9 +20,20 @@ declare class CubeTextureNode extends TextureNode {
 
 export default CubeTextureNode;
 
-export const cubeTexture: (
+export const cubeTextureBase: (
     value: CubeTexture,
-    uvNode?: NodeRepresentation,
-    levelNode?: NodeRepresentation,
-    biasNode?: NodeRepresentation,
+    uvNode?: Node,
+    levelNode?: Node,
+    biasNode?: Node,
+) => ShaderNodeObject<CubeTextureNode>;
+
+export const cubeTexture: (
+    value?: CubeTexture,
+    uvNode?: Node | null,
+    levelNode?: Node | null,
+    biasNode?: Node | null,
+) => ShaderNodeObject<CubeTextureNode>;
+
+export const uniformCubeTexture: (
+    value?: CubeTexture,
 ) => ShaderNodeObject<CubeTextureNode>;

three/src/nodes/accessors/Normal.d.ts

@@ -1,4 +1,3 @@
-import { Matrix4 } from "../../math/Matrix4.js";
 import AttributeNode from "../core/AttributeNode.js";
 import Node from "../core/Node.js";
 import VarNode from "../core/VarNode.js";
@@ -10,16 +9,31 @@ export const normalLocal: ShaderNodeObject<VarNode>;
 
 export const normalFlat: ShaderNodeObject<VarNode>;
 
+export const normalViewGeometry: ShaderNodeObject<VarNode>;
+
+export const normalWorldGeometry: ShaderNodeObject<VarNode>;
+
 export const normalView: ShaderNodeObject<VarNode>;
 
 export const normalWorld: ShaderNodeObject<VarNode>;
 
+export const clearcoatNormalView: ShaderNodeObject<VarNode>;
+
+export const transformNormal: (normal: Node, matrix?: Node) => ShaderNodeObject<Node>;
+
+export const transformNormalToView: (normal: Node) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated since r178. Use `normalView` instead.
+ */
 export const transformedNormalView: ShaderNodeObject<VarNode>;
 
+/**
+ * @deprecated since r178. Use `normalWorld` instead.
+ */
 export const transformedNormalWorld: ShaderNodeObject<VarNode>;
 
+/**
+ * @deprecated since r178. Use `clearcoatNormalView` instead.
+ */
 export const transformedClearcoatNormalView: ShaderNodeObject<VarNode>;
-
-export const transformNormal: (normal: Node, matrix?: Node) => ShaderNodeObject<Node>;
-
-export const transformNormalToView: (normal: Node) => ShaderNodeObject<Node>;

three/src/nodes/accessors/ReferenceBaseNode.d.ts

@@ -1,5 +1,5 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ReferenceBaseNode<T> extends Node {
     property: string;

three/src/nodes/accessors/StorageBufferNode.d.ts

@@ -1,9 +1,10 @@
 import StorageBufferAttribute from "../../renderers/common/StorageBufferAttribute.js";
 import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
 import { NodeAccess } from "../core/constants.js";
+import Node from "../core/Node.js";
 import { Struct } from "../core/StructNode.js";
 import StructTypeNode from "../core/StructTypeNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import StorageArrayElementNode from "../utils/StorageArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
 
@@ -24,7 +25,7 @@ export default class StorageBufferNode extends BufferNode<StorageBufferAttribute
         bufferCount?: number,
     );
 
-    element(indexNode: NodeRepresentation): ShaderNodeObject<StorageArrayElementNode>;
+    element(indexNode: Node | number): ShaderNodeObject<StorageArrayElementNode>;
 
     setPBO(value: boolean): this;
 

three/src/nodes/accessors/StorageTextureNode.d.ts

@@ -2,7 +2,7 @@ import { Texture } from "../../textures/Texture.js";
 import { NodeAccess } from "../core/constants.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import TextureNode from "./TextureNode.js";
 
 export default class StorageTextureNode extends TextureNode {
@@ -31,12 +31,12 @@ export default class StorageTextureNode extends TextureNode {
 
 export const storageTexture: (
     value: Texture,
-    uvNode?: NodeRepresentation | null,
-    storeNode?: NodeRepresentation,
+    uvNode?: Node | null,
+    storeNode?: Node,
 ) => ShaderNodeObject<StorageTextureNode>;
 
 export const textureStore: (
     value: Texture,
-    uvNode?: NodeRepresentation | null,
-    storeNode?: NodeRepresentation,
+    uvNode?: Node | null,
+    storeNode?: Node,
 ) => ShaderNodeObject<StorageTextureNode>;

three/src/nodes/accessors/Tangent.d.ts

@@ -8,5 +8,3 @@ export const tangentGeometry: ShaderNodeObject<AttributeNode>;
 export const tangentLocal: ShaderNodeObject<VaryingNode>;
 export const tangentView: ShaderNodeObject<MathNode>;
 export const tangentWorld: ShaderNodeObject<MathNode>;
-export const transformedTangentView: ShaderNodeObject<VarNode>;
-export const transformedTangentWorld: ShaderNodeObject<MathNode>;

three/src/nodes/accessors/TangentUtils.d.ts

@@ -0,0 +1,22 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+/**
+ * Tangent vector in view space, computed dynamically from geometry and UV derivatives.
+ * Useful for normal mapping without precomputed tangents.
+ *
+ * Reference: http://www.thetenthplanet.de/archives/1180
+ *
+ * @tsl
+ */
+export const tangentViewFrame: ShaderNodeObject<Node>;
+
+/**
+ * Bitangent vector in view space, computed dynamically from geometry and UV derivatives.
+ * Complements the tangentViewFrame for constructing the tangent space basis.
+ *
+ * Reference: http://www.thetenthplanet.de/archives/1180
+ *
+ * @tsl
+ */
+export const bitangentViewFrame: ShaderNodeObject<Node>;

three/src/nodes/accessors/Texture3DNode.d.ts

@@ -1,17 +1,18 @@
-import { CubeTexture } from "../../textures/CubeTexture.js";
 import { Texture } from "../../textures/Texture.js";
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import TextureNode from "./TextureNode.js";
 
 export default class Texture3DNode extends TextureNode {
     readonly isTexture3DNode: true;
 
     constructor(value: Texture, uvNode?: ShaderNodeObject<Node> | null, levelNode?: ShaderNodeObject<Node> | null);
+
+    normal(uvNode: Node): ShaderNodeObject<Node>;
 }
 
 export const texture3D: (
     value: Texture,
-    uvNode?: NodeRepresentation | null,
-    levelNode?: NodeRepresentation | null,
+    uvNode?: Node | null,
+    levelNode?: Node | number | null,
 ) => ShaderNodeObject<Texture3DNode>;

three/src/nodes/accessors/TextureBicubic.d.ts

@@ -1,4 +1,6 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const textureBicubic: (textureNode: Node, lodNode?: NodeRepresentation) => ShaderNodeObject<Node>;
+export const textureBicubicLevel: (textureNode: Node, lodNode: Node) => ShaderNodeObject<Node>;
+
+export const textureBicubic: (textureNode: Node, strength: Node) => ShaderNodeObject<Node>;

three/src/nodes/accessors/TextureNode.d.ts

@@ -1,7 +1,7 @@
 import { Texture } from "../../textures/Texture.js";
 import Node from "../core/Node.js";
 import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class TextureNode extends UniformNode<Texture> {
     readonly isTextureNode: true;
@@ -19,7 +19,7 @@ export default class TextureNode extends UniformNode<Texture> {
     referenceNode: Node | null;
 
     constructor(
-        value: Texture,
+        value?: Texture,
         uvNode?: ShaderNodeObject<Node> | null,
         levelNode?: ShaderNodeObject<Node> | null,
         biasNode?: ShaderNodeObject<Node> | null,
@@ -34,38 +34,43 @@ export default class TextureNode extends UniformNode<Texture> {
     /**
      * @deprecated
      */
-    uv(uvNode: NodeRepresentation): ShaderNodeObject<Node>;
+    uv(uvNode: Node): ShaderNodeObject<Node>;
 
-    sample(uvNode: NodeRepresentation): ShaderNodeObject<Node>;
+    sample(uvNode: Node): ShaderNodeObject<Node>;
 
-    blur(amountNode: NodeRepresentation): ShaderNodeObject<Node>;
+    blur(amountNode: Node): ShaderNodeObject<Node>;
 
-    level(levelNode: NodeRepresentation): ShaderNodeObject<Node>;
+    level(levelNode: Node): ShaderNodeObject<Node>;
 
-    size(levelNode: NodeRepresentation): ShaderNodeObject<Node>;
+    size(levelNode: Node): ShaderNodeObject<Node>;
 
-    bias(biasNode: NodeRepresentation): ShaderNodeObject<Node>;
+    bias(biasNode: Node): ShaderNodeObject<Node>;
 
-    compare(compareNode: NodeRepresentation): ShaderNodeObject<Node>;
+    compare(compareNode: Node): ShaderNodeObject<Node>;
 
-    grad(gradeNodeX: NodeRepresentation, gradeNodeY: NodeRepresentation): ShaderNodeObject<Node>;
+    grad(gradeNodeX: Node, gradeNodeY: Node): ShaderNodeObject<Node>;
 
-    depth(depthNode: NodeRepresentation): ShaderNodeObject<Node>;
+    depth(depthNode: Node): ShaderNodeObject<Node>;
 
     clone(): this;
 }
 
 export const texture: (
-    value: Texture,
-    uvNode?: NodeRepresentation,
-    levelNode?: NodeRepresentation,
-    biasNode?: NodeRepresentation,
+    value?: Texture,
+    uvNode?: Node | null,
+    levelNode?: Node | number | null,
+    biasNode?: Node | null,
 ) => ShaderNodeObject<TextureNode>;
+
+export const uniformTexture: (
+    value?: Texture,
+) => ShaderNodeObject<TextureNode>;
+
 export const textureLoad: (
-    value: Texture,
-    uvNode?: NodeRepresentation,
-    levelNode?: NodeRepresentation,
-    biasNode?: NodeRepresentation,
+    value?: Texture,
+    uvNode?: Node,
+    levelNode?: Node | number,
+    biasNode?: Node,
 ) => ShaderNodeObject<TextureNode>;
 
 export const sampler: (value: Texture | TextureNode) => ShaderNodeObject<Node>;