@needle-tools/three 0.169.12 → 0.169.13

package/types/src/nodes/accessors/BufferAttributeNode.d.ts

@@ -0,0 +1,54 @@
+import { Usage } from "../../constants.js";
+import { BufferAttribute, TypedArray } from "../../core/BufferAttribute.js";
+import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
+import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
+import InputNode from "../core/InputNode.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+declare class BufferAttributeNode extends InputNode<TypedArray | InterleavedBuffer | BufferAttribute> {
+    static get type(): string;
+    readonly isBufferNode: true;
+    bufferType: string | null;
+    bufferStride: number;
+    bufferOffset: number;
+    usage: Usage;
+    instanced: boolean;
+    attribute: BufferAttribute | InterleavedBufferAttribute | null;
+    constructor(
+        value: TypedArray | InterleavedBuffer | BufferAttribute,
+        bufferType?: string | null,
+        bufferStride?: number,
+        bufferOffset?: number,
+    );
+    getHash(builder: NodeBuilder): string;
+    getNodeType(builder: NodeBuilder): string | null;
+    setup(builder: NodeBuilder): void;
+    generate(builder: NodeBuilder): string | null | undefined;
+    getInputType(): string;
+    setUsage(value: Usage): this;
+    setInstanced(value: boolean): this;
+}
+export default BufferAttributeNode;
+export declare const bufferAttribute: (
+    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    type?: string | null,
+    stride?: number,
+    offset?: number,
+) => import("../tsl/TSLCore.js").ShaderNodeObject<BufferAttributeNode>;
+export declare const dynamicBufferAttribute: (
+    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    type?: string | null,
+    stride?: number,
+    offset?: number,
+) => import("../tsl/TSLCore.js").ShaderNodeObject<BufferAttributeNode>;
+export declare const instancedBufferAttribute: (
+    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    type?: string | null,
+    stride?: number,
+    offset?: number,
+) => import("../tsl/TSLCore.js").ShaderNodeObject<BufferAttributeNode>;
+export declare const instancedDynamicBufferAttribute: (
+    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    type?: string | null,
+    stride?: number,
+    offset?: number,
+) => import("../tsl/TSLCore.js").ShaderNodeObject<BufferAttributeNode>;

package/types/src/nodes/accessors/BufferNode.d.ts

@@ -0,0 +1,17 @@
+import UniformNode from "../core/UniformNode.js";
+import { NodeOrType, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export default class BufferNode extends UniformNode<unknown> {
+    isBufferNode: true;
+
+    bufferType: string;
+    bufferCount: number;
+
+    constructor(value: unknown, bufferType: string, bufferCount?: number);
+}
+
+export const buffer: (
+    value: unknown,
+    nodeOrType: NodeOrType,
+    count: number,
+) => ShaderNodeObject<BufferNode>;

package/types/src/nodes/accessors/Camera.d.ts

@@ -0,0 +1,15 @@
+import { Matrix3 } from "../../math/Matrix3.js";
+import { Matrix4 } from "../../math/Matrix4.js";
+import { Vector3 } from "../../math/Vector3.js";
+import UniformNode from "../core/UniformNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const cameraNear: ShaderNodeObject<UniformNode<number>>;
+export const cameraFar: ShaderNodeObject<UniformNode<number>>;
+export const cameraLogDepth: ShaderNodeObject<UniformNode<number>>;
+export const cameraProjectionMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
+export const cameraProjectionMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
+export const cameraViewMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
+export const cameraWorldMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
+export const cameraNormalMatrix: ShaderNodeObject<UniformNode<Matrix3>>;
+export const cameraPosition: ShaderNodeObject<UniformNode<Vector3>>;

package/types/src/nodes/accessors/ClippingNode.d.ts

@@ -0,0 +1,16 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type ClippingNodeScope = typeof ClippingNode.ALPHA_TO_COVERAGE | typeof ClippingNode.DEFAULT;
+
+export default class ClippingNode extends Node {
+    scope: ClippingNodeScope;
+
+    constructor(scope?: ClippingNodeScope);
+
+    static ALPHA_TO_COVERAGE: "alphaToCoverage";
+    static DEFAULT: "default";
+}
+
+export const clipping: () => ShaderNodeObject<ClippingNode>;
+export const clippingAlpha: () => ShaderNodeObject<ClippingNode>;

package/types/src/nodes/accessors/CubeTextureNode.d.ts

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

package/types/src/nodes/accessors/InstanceNode.d.ts

@@ -0,0 +1,13 @@
+import { InstancedMesh } from "../../objects/InstancedMesh.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export default class InstanceNode extends Node {
+    instanceMesh: InstancedMesh;
+    instanceMatrixNode: Node | null;
+    instanceColorNode: Node | null;
+
+    constructor(instanceMesh: InstancedMesh);
+}
+
+export const instance: (instanceMesh: InstancedMesh) => ShaderNodeObject<InstanceNode>;

package/types/src/nodes/accessors/MaterialNode.d.ts

@@ -0,0 +1,129 @@
+import { Vector2 } from "../../math/Vector2.js";
+import Node from "../core/Node.js";
+import UniformNode from "../core/UniformNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type MaterialNodeScope =
+    | typeof MaterialNode.ALPHA_TEST
+    | typeof MaterialNode.COLOR
+    | typeof MaterialNode.OPACITY
+    | typeof MaterialNode.SHININESS
+    | typeof MaterialNode.SPECULAR
+    | typeof MaterialNode.SPECULAR_STRENGTH
+    | typeof MaterialNode.SPECULAR_INTENSITY
+    | typeof MaterialNode.SPECULAR_COLOR
+    | typeof MaterialNode.REFLECTIVITY
+    | typeof MaterialNode.ROUGHNESS
+    | typeof MaterialNode.METALNESS
+    | typeof MaterialNode.NORMAL
+    | typeof MaterialNode.CLEARCOAT
+    | typeof MaterialNode.CLEARCOAT_ROUGHNESS
+    | typeof MaterialNode.CLEARCOAT_NORMAL
+    | typeof MaterialNode.EMISSIVE
+    | typeof MaterialNode.ROTATION
+    | typeof MaterialNode.SHEEN
+    | typeof MaterialNode.SHEEN_ROUGHNESS
+    | typeof MaterialNode.ANISOTROPY
+    | typeof MaterialNode.IRIDESCENCE
+    | typeof MaterialNode.IRIDESCENCE_IOR
+    | typeof MaterialNode.IRIDESCENCE_THICKNESS
+    | typeof MaterialNode.IOR
+    | typeof MaterialNode.TRANSMISSION
+    | typeof MaterialNode.THICKNESS
+    | typeof MaterialNode.ATTENUATION_DISTANCE
+    | typeof MaterialNode.ATTENUATION_COLOR
+    | typeof MaterialNode.LINE_SCALE
+    | typeof MaterialNode.LINE_DASH_SIZE
+    | typeof MaterialNode.LINE_GAP_SIZE
+    | typeof MaterialNode.LINE_WIDTH
+    | typeof MaterialNode.LINE_DASH_OFFSET
+    | typeof MaterialNode.POINT_WIDTH
+    | typeof MaterialNode.DISPERSION
+    | typeof MaterialNode.LIGHT_MAP
+    | typeof MaterialNode.AO_MAP
+    | typeof MaterialNode.REFRACTION_RATIO;
+
+export default class MaterialNode extends Node {
+    static ALPHA_TEST: "alphaTest";
+    static COLOR: "color";
+    static OPACITY: "opacity";
+    static SHININESS: "shininess";
+    static SPECULAR: "specular";
+    static SPECULAR_STRENGTH: "specularStrength";
+    static SPECULAR_INTENSITY: "specularIntensity";
+    static SPECULAR_COLOR: "specularColor";
+    static REFLECTIVITY: "reflectivity";
+    static ROUGHNESS: "roughness";
+    static METALNESS: "metalness";
+    static NORMAL: "normal";
+    static CLEARCOAT: "clearcoat";
+    static CLEARCOAT_ROUGHNESS: "clearcoatRoughness";
+    static CLEARCOAT_NORMAL: "clearcoatNormal";
+    static EMISSIVE: "emissive";
+    static ROTATION: "rotation";
+    static SHEEN: "sheen";
+    static SHEEN_ROUGHNESS: "sheenRoughness";
+    static ANISOTROPY: "anisotropy";
+    static IRIDESCENCE: "iridescence";
+    static IRIDESCENCE_IOR: "iridescenceIOR";
+    static IRIDESCENCE_THICKNESS: "iridescenceThickness";
+    static IOR: "ior";
+    static TRANSMISSION: "transmission";
+    static THICKNESS: "thickness";
+    static ATTENUATION_DISTANCE: "attenuationDistance";
+    static ATTENUATION_COLOR: "attenuationColor";
+    static LINE_SCALE: "scale";
+    static LINE_DASH_SIZE: "dashSize";
+    static LINE_GAP_SIZE: "gapSize";
+    static LINE_WIDTH: "linewidth";
+    static LINE_DASH_OFFSET: "dashOffset";
+    static POINT_WIDTH: "pointWidth";
+    static DISPERSION: "dispersion";
+    static LIGHT_MAP: "light";
+    static AO_MAP: "ao";
+    static REFRACTION_RATIO: "refractionRatio";
+
+    scope: MaterialNodeScope;
+    constructor(scope?: MaterialNodeScope);
+}
+
+export const materialAlphaTest: ShaderNodeObject<MaterialNode>;
+export const materialColor: ShaderNodeObject<MaterialNode>;
+export const materialShininess: ShaderNodeObject<MaterialNode>;
+export const materialEmissive: ShaderNodeObject<MaterialNode>;
+export const materialOpacity: ShaderNodeObject<MaterialNode>;
+export const materialSpecular: ShaderNodeObject<MaterialNode>;
+
+export const materialSpecularIntensity: ShaderNodeObject<MaterialNode>;
+export const materialSpecularColor: ShaderNodeObject<MaterialNode>;
+
+export const materialSpecularStrength: ShaderNodeObject<MaterialNode>;
+export const materialReflectivity: ShaderNodeObject<MaterialNode>;
+export const materialRoughness: ShaderNodeObject<MaterialNode>;
+export const materialMetalness: ShaderNodeObject<MaterialNode>;
+export const materialNormal: ShaderNodeObject<Node>;
+export const materialClearcoat: ShaderNodeObject<MaterialNode>;
+export const materialClearcoatRoughness: ShaderNodeObject<MaterialNode>;
+export const materialClearcoatNormal: ShaderNodeObject<Node>;
+export const materialRotation: ShaderNodeObject<MaterialNode>;
+export const materialSheen: ShaderNodeObject<MaterialNode>;
+export const materialSheenRoughness: ShaderNodeObject<MaterialNode>;
+export const materialAnisotropy: ShaderNodeObject<MaterialNode>;
+export const materialIridescence: ShaderNodeObject<MaterialNode>;
+export const materialIridescenceIOR: ShaderNodeObject<MaterialNode>;
+export const materialIridescenceThickness: ShaderNodeObject<MaterialNode>;
+export const materialTransmission: ShaderNodeObject<MaterialNode>;
+export const materialThickness: ShaderNodeObject<MaterialNode>;
+export const materialIOR: ShaderNodeObject<MaterialNode>;
+export const materialAttenuationDistance: ShaderNodeObject<MaterialNode>;
+export const materialAttenuationColor: ShaderNodeObject<MaterialNode>;
+export const materialLineScale: ShaderNodeObject<MaterialNode>;
+export const materialLineDashSize: ShaderNodeObject<MaterialNode>;
+export const materialLineGapSize: ShaderNodeObject<MaterialNode>;
+export const materialLineWidth: ShaderNodeObject<MaterialNode>;
+export const materialLineDashOffset: ShaderNodeObject<MaterialNode>;
+export const materialPointWidth: ShaderNodeObject<MaterialNode>;
+export const materialDispersion: ShaderNodeObject<MaterialNode>;
+export const materialLightMap: ShaderNodeObject<MaterialNode>;
+export const materialAOMap: ShaderNodeObject<MaterialNode>;
+export const materialAnisotropyVector: ShaderNodeObject<UniformNode<Vector2>>;

package/types/src/nodes/accessors/MaterialProperties.d.ts

@@ -0,0 +1,4 @@
+import UniformNode from "../core/UniformNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const materialRefractionRatio: ShaderNodeObject<UniformNode<number>>;

package/types/src/nodes/accessors/MaterialReferenceNode.d.ts

@@ -0,0 +1,15 @@
+import { Material } from "../../materials/Material.js";
+import { NodeOrType, ShaderNodeObject } from "../tsl/TSLCore.js";
+import ReferenceNode from "./ReferenceNode.js";
+
+export default class MaterialReferenceNode extends ReferenceNode<Material | null> {
+    readonly isMaterialReferenceNode: true;
+
+    constructor(property: string, inputType: string, material?: Material | null);
+}
+
+export const materialReference: (
+    name: string,
+    nodeOrType: NodeOrType,
+    material?: Material | null,
+) => ShaderNodeObject<MaterialReferenceNode>;

package/types/src/nodes/accessors/ModelNode.d.ts

@@ -0,0 +1,24 @@
+import { Matrix4 } from "../../math/Matrix4.js";
+import Node from "../core/Node.js";
+import { UniformNode } from "../Nodes.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import Object3DNode from "./Object3DNode.js";
+
+/**
+ * Similar to {@link Object3DNode} but the object comes from {@link NodeFrame}
+ */
+export default class ModelNode extends Object3DNode {
+    constructor(scope: string);
+}
+
+export const modelDirection: ShaderNodeObject<ModelNode>;
+export const modelWorldMatrix: ShaderNodeObject<ModelNode>;
+export const modelPosition: ShaderNodeObject<ModelNode>;
+export const modelScale: ShaderNodeObject<ModelNode>;
+export const modelViewPosition: ShaderNodeObject<ModelNode>;
+export const modelNormalMatrix: ShaderNodeObject<Node>;
+export const modelWorldMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
+export const modelViewMatrix: ShaderNodeObject<ModelNode>;
+
+export const highPrecisionModelViewMatrix: ShaderNodeObject<Node>;
+export const highPrecisionModelNormalViewMatrix: ShaderNodeObject<Node>;

package/types/src/nodes/accessors/ModelViewProjectionNode.d.ts

@@ -0,0 +1,8 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export default class ModelViewProjectionNode extends Node {
+    constructor(positionNode?: Node);
+}
+
+export const modelViewProjection: (position?: NodeRepresentation) => ShaderNodeObject<ModelViewProjectionNode>;

package/types/src/nodes/accessors/MorphNode.d.ts

@@ -0,0 +1,15 @@
+import { Mesh } from "../../objects/Mesh.js";
+import Node from "../core/Node.js";
+import UniformNode from "../core/UniformNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class MorphNode extends Node {
+    mesh: Mesh;
+    morphBaseInfluence: UniformNode<number>;
+
+    constructor(mesh: Mesh);
+}
+
+export default MorphNode;
+
+export const morphReference: (mesh: Mesh) => ShaderNodeObject<MorphNode>;

package/types/src/nodes/accessors/Normal.d.ts

@@ -0,0 +1,25 @@
+import { Matrix4 } from "../../math/Matrix4.js";
+import AttributeNode from "../core/AttributeNode.js";
+import Node from "../core/Node.js";
+import VarNode from "../core/VarNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const normalGeometry: ShaderNodeObject<AttributeNode>;
+
+export const normalLocal: ShaderNodeObject<VarNode>;
+
+export const normalFlat: ShaderNodeObject<VarNode>;
+
+export const normalView: ShaderNodeObject<VarNode>;
+
+export const normalWorld: ShaderNodeObject<VarNode>;
+
+export const transformedNormalView: ShaderNodeObject<VarNode>;
+
+export const transformedNormalWorld: ShaderNodeObject<VarNode>;
+
+export const transformedClearcoatNormalView: ShaderNodeObject<VarNode>;
+
+export const transformNormal: (normal: Node, matrix?: Node) => ShaderNodeObject<Node>;
+
+export const transformNormalToView: (normal: Node) => ShaderNodeObject<Node>;

package/types/src/nodes/accessors/Object3DNode.d.ts

@@ -0,0 +1,22 @@
+import { Object3D } from "../../core/Object3D.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export default class Object3DNode extends Node {
+    scope: string;
+    object3d: Object3D | null;
+
+    constructor(scope: string, object3d?: Object3D | null);
+
+    static WORLD_MATRIX: "worldMatrix";
+    static POSITION: "position";
+    static SCALE: "scale";
+    static VIEW_POSITION: "viewPosition";
+    static DIRECTION: "direction";
+}
+
+export const objectDirection: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectWorldMatrix: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectPosition: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectScale: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectViewPosition: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;

package/types/src/nodes/accessors/PointUVNode.d.ts

@@ -0,0 +1,10 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export default class PointUVNode extends Node {
+    isPointUVNode: true;
+
+    constructor();
+}
+
+export const pointUV: ShaderNodeObject<PointUVNode>;

package/types/src/nodes/accessors/Position.d.ts

@@ -0,0 +1,10 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const positionGeometry: ShaderNodeObject<Node>;
+export const positionLocal: ShaderNodeObject<Node>;
+export const positionPrevious: ShaderNodeObject<Node>;
+export const positionWorld: ShaderNodeObject<Node>;
+export const positionWorldDirection: ShaderNodeObject<Node>;
+export const positionView: ShaderNodeObject<Node>;
+export const positionViewDirection: ShaderNodeObject<Node>;

package/types/src/nodes/accessors/ReferenceBaseNode.d.ts

@@ -0,0 +1,27 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class ReferenceBaseNode<T> extends Node {
+    property: string;
+    uniformType: string;
+    object: T;
+    count: number | null;
+
+    properties: string[];
+    reference: T | null;
+    node: Node | null;
+
+    constructor(property: string, uniformType: string, object?: T | null, count?: number | null);
+
+    setNodeType(uniformType: string): void;
+}
+
+export default ReferenceBaseNode;
+
+export const reference: <T>(name: string, type: string, object: T) => ShaderNodeObject<ReferenceBaseNode<T>>;
+export const referenceBuffer: <T>(
+    name: string,
+    type: string,
+    count: number,
+    object: T,
+) => ShaderNodeObject<ReferenceBaseNode<T>>;

package/types/src/nodes/accessors/ReferenceNode.d.ts

@@ -0,0 +1,29 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class ReferenceNode<T> extends Node {
+    property: string;
+
+    uniformType: string;
+
+    object: T;
+    count: number | null;
+
+    properties: string[];
+    reference: T | null;
+    node: Node | null;
+
+    constructor(property: string, uniformType: string, object?: T | null, count?: number | null);
+
+    setNodeType(uniformType: string): void;
+}
+
+export default ReferenceNode;
+
+export const reference: <T>(name: string, type: string, object: T) => ShaderNodeObject<ReferenceNode<T>>;
+export const referenceBuffer: <T>(
+    name: string,
+    type: string,
+    count: number,
+    object: T,
+) => ShaderNodeObject<ReferenceNode<T>>;

package/types/src/nodes/accessors/ReflectVector.d.ts

@@ -0,0 +1,9 @@
+import Node from "../core/Node.js";
+import VarNode from "../core/VarNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const reflectView: ShaderNodeObject<Node>;
+export const refractView: ShaderNodeObject<Node>;
+
+export const reflectVector: ShaderNodeObject<VarNode>;
+export const refractVector: ShaderNodeObject<VarNode>;

package/types/src/nodes/accessors/RendererReferenceNode.d.ts

@@ -0,0 +1,15 @@
+import Renderer from "../../renderers/common/Renderer.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import ReferenceNode from "./ReferenceNode.js";
+
+export default class RendererReferenceNode extends ReferenceNode<Renderer> {
+    renderer: Renderer | null;
+
+    constructor(property: string, inputType: string, renderer?: Renderer | null);
+}
+
+export const rendererReference: (
+    name: string,
+    type: string,
+    renderer?: Renderer | null,
+) => ShaderNodeObject<RendererReferenceNode>;

package/types/src/nodes/accessors/SceneNode.d.ts

@@ -0,0 +1,20 @@
+import { Scene } from "../../scenes/Scene.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type SceneNodeScope = typeof SceneNode.BACKGROUND_BLURRINESS | typeof SceneNode.BACKGROUND_INTENSITY;
+
+declare class SceneNode extends Node {
+    scope: SceneNodeScope;
+    scene: Scene | null;
+
+    constructor(scope?: SceneNodeScope, scene?: Scene | null);
+
+    static BACKGROUND_BLURRINESS: "backgroundBlurriness";
+    static BACKGROUND_INTENSITY: "backgroundIntensity";
+}
+
+export default SceneNode;
+
+export const backgroundBlurriness: ShaderNodeObject<SceneNode>;
+export const backgroundIntensity: ShaderNodeObject<SceneNode>;

package/types/src/nodes/accessors/SkinningNode.d.ts

@@ -0,0 +1,30 @@
+import { SkinnedMesh } from "../../objects/SkinnedMesh.js";
+import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export default class SkinningNode extends Node {
+    skinnedMesh: SkinnedMesh;
+    useReference: boolean;
+
+    skinIndexNode: Node;
+    skinWeightNode: Node;
+
+    bindMatrixNode: Node;
+    bindMatrixInverseNode: Node;
+    boneMatricesNode: Node;
+    previousBoneMatricesNode: Node | null;
+
+    constructor(skinnedMesh: SkinnedMesh, useReference?: boolean);
+
+    getSkinnedPosition(boneMatrices?: Node, position?: Node): ShaderNodeObject<Node>;
+
+    getSkinnedNormal(boneMatrices?: Node, normal?: Node): ShaderNodeObject<Node>;
+
+    getPreviousSkinnedPosition(builder: NodeBuilder): ShaderNodeObject<Node>;
+
+    needsPreviousBoneMatrices(builder: NodeBuilder): boolean;
+}
+
+export const skinning: (skinnedMesh: SkinnedMesh) => ShaderNodeObject<SkinningNode>;
+export const skinningReference: (skinnedMesh: SkinnedMesh) => ShaderNodeObject<SkinningNode>;

package/types/src/nodes/accessors/StorageBufferNode.d.ts

@@ -0,0 +1,38 @@
+import StorageBufferAttribute from "../../renderers/common/StorageBufferAttribute.js";
+import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
+import { GPUBufferBindingType } from "../../renderers/webgpu/utils/WebGPUConstants.js";
+import { NodeOrType, NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import StorageArrayElementNode from "../utils/StorageArrayElementNode.js";
+import BufferNode from "./BufferNode.js";
+
+export default class StorageBufferNode extends BufferNode {
+    readonly isStorageBufferNode: true;
+    bufferObject: boolean;
+
+    access: GPUBufferBindingType;
+
+    constructor(
+        value: StorageBufferAttribute | StorageInstancedBufferAttribute,
+        bufferType: string,
+        bufferCount?: number,
+    );
+
+    element(indexNode: NodeRepresentation): ShaderNodeObject<StorageArrayElementNode>;
+
+    setBufferObject(value: boolean): this;
+
+    setAccess(value: GPUBufferBindingType): this;
+
+    toReadOnly(): this;
+}
+
+export const storage: (
+    value: StorageBufferAttribute | StorageInstancedBufferAttribute,
+    nodeOrType: NodeOrType,
+    count: number,
+) => ShaderNodeObject<StorageBufferNode>;
+export const storageObject: (
+    value: StorageBufferAttribute | StorageInstancedBufferAttribute,
+    nodeOrType: NodeOrType,
+    count: number,
+) => ShaderNodeObject<StorageBufferNode>;

package/types/src/nodes/accessors/StorageTextureNode.d.ts

@@ -0,0 +1,40 @@
+import { GPUStorageTextureAccess } from "../../renderers/webgpu/utils/WebGPUConstants.js";
+import { Texture } from "../../textures/Texture.js";
+import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import TextureNode from "./TextureNode.js";
+
+export default class StorageTextureNode extends TextureNode {
+    storeNode: Node | null;
+
+    readonly isStorageTextureNode: true;
+
+    access: GPUStorageTextureAccess;
+
+    constructor(
+        value: Texture,
+        uvNode?: ShaderNodeObject<Node> | null,
+        storeNode?: Node | null,
+    );
+
+    setAccess(value: GPUStorageTextureAccess): this;
+
+    toReadOnly(): this;
+
+    toWriteOnly(): this;
+
+    generateStore(builder: NodeBuilder): void;
+}
+
+export const storageTexture: (
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    storeNode?: NodeRepresentation,
+) => ShaderNodeObject<StorageTextureNode>;
+
+export const textureStore: (
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    storeNode?: NodeRepresentation,
+) => ShaderNodeObject<StorageTextureNode>;

package/types/src/nodes/accessors/Tangent.d.ts

@@ -0,0 +1,12 @@
+import AttributeNode from "../core/AttributeNode.js";
+import VarNode from "../core/VarNode.js";
+import VaryingNode from "../core/VaryingNode.js";
+import MathNode from "../math/MathNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+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>;