@needle-tools/three 0.169.12 → 0.169.13

package/types/src/nodes/tsl/TSLCore.d.ts

@@ -0,0 +1,273 @@
+import ConstNode from "../core/ConstNode.js";
+import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+import StackNode from "../core/StackNode.js";
+
+export interface NodeElements {
+    toGlobal: (node: Node) => Node;
+
+    append: typeof append;
+
+    toColor: typeof color;
+    toFloat: typeof float;
+    toInt: typeof int;
+    toUint: typeof uint;
+    toBool: typeof bool;
+    toVec2: typeof vec2;
+    toIvec2: typeof ivec2;
+    toUvec2: typeof uvec2;
+    toBvec2: typeof bvec2;
+    toVec3: typeof vec3;
+    toIvec3: typeof ivec3;
+    toUvec3: typeof uvec3;
+    toBvec3: typeof bvec3;
+    toVec4: typeof vec4;
+    toIvec4: typeof ivec4;
+    toUvec4: typeof uvec4;
+    toBvec4: typeof bvec4;
+    toMat2: typeof mat2;
+    toMat3: typeof mat3;
+    toMat4: typeof mat4;
+
+    element: typeof element;
+    convert: typeof convert;
+}
+
+export function addMethodChaining(name: string, nodeElement: unknown): void;
+
+export type SwizzleCharacter = "x" | "y" | "z" | "w" | "r" | "g" | "b" | "a" | "s" | "t" | "p" | "q";
+
+export type SwizzleOption = Exclude<
+    | `${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`,
+    "abs" | "sqrt"
+>;
+
+export type Swizzable<T extends Node = Node> =
+    & T
+    & {
+        [Key in SwizzleOption | number]: ShaderNodeObject<Node>;
+    }
+    & {
+        [Key in SwizzleOption as `flip${Uppercase<Key>}`]: () => ShaderNodeObject<Node>;
+    };
+
+export type ShaderNodeObject<T extends Node> =
+    & T
+    & {
+        [Key in keyof NodeElements]: T extends { [K in Key]: infer M } ? M
+            : NodeElements[Key] extends (node: T, ...args: infer Args) => infer R ? (...args: Args) => R
+            : never;
+    }
+    & {
+        [Key in keyof NodeElements as `${Key}Assign`]: T extends { [K in Key]: infer M } ? M
+            : NodeElements[Key] extends (node: T, ...args: infer Args) => unknown
+                ? (...args: Args) => ShaderNodeObject<T>
+            : never;
+    }
+    & Swizzable<T>;
+
+/** anything that can be passed to {@link nodeObject} and returns a proxy */
+export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | ShaderNodeObject<T>;
+
+/** anything that can be passed to {@link nodeObject} */
+export type NodeObjectOption = NodeRepresentation | string;
+
+// same logic as in ShaderNodeObject: number,boolean,node->ShaderNodeObject, otherwise do nothing
+export type NodeObject<T> = T extends Node ? ShaderNodeObject<T>
+    : T extends number | boolean ? ShaderNodeObject<ConstNode<number | boolean>>
+    : T;
+
+// opposite of NodeObject: node -> node|ShaderNodeObject|boolean|number, otherwise do nothing
+type Proxied<T> = T extends Node ? NodeRepresentation<T> : T;
+// https://github.com/microsoft/TypeScript/issues/42435#issuecomment-765557874
+export type ProxiedTuple<T extends readonly [...unknown[]]> = [...{ [index in keyof T]: Proxied<T[index]> }];
+export type ProxiedObject<T> = { [index in keyof T]: Proxied<T[index]> };
+type RemoveTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X] ? X : [];
+type RemoveHeadAndTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X, unknown] ? X : [];
+
+/**
+ * Temporary type to save signatures of 4 constructors. Each element may be tuple or undefined.
+ *
+ * We use an object instead of tuple or union as it makes stuff easier, especially in Typescript 4.0.
+ */
+interface Construtors<
+    A extends undefined | [...unknown[]],
+    B extends undefined | [...unknown[]],
+    C extends undefined | [...unknown[]],
+    D extends undefined | [...unknown[]],
+> {
+    a: A;
+    b: B;
+    c: C;
+    d: D;
+}
+
+/**
+ * Returns all constructors
+ *
+ * <https://github.com/microsoft/TypeScript/issues/37079>
+ * <https://stackoverflow.com/a/52761156/1623826>
+ */
+type OverloadedConstructorsOf<T> = T extends {
+    new(...args: infer A1): unknown;
+    new(...args: infer A2): unknown;
+    new(...args: infer A3): unknown;
+    new(...args: infer A4): unknown;
+} ? Construtors<A1, A2, A3, A4>
+    : T extends {
+        new(...args: infer A1): unknown;
+        new(...args: infer A2): unknown;
+        new(...args: infer A3): unknown;
+    } ? Construtors<A1, A2, A3, undefined>
+    : T extends {
+        new(...args: infer A1): unknown;
+        new(...args: infer A2): unknown;
+    } ? Construtors<A1, A2, undefined, undefined>
+    : T extends new(...args: infer A) => unknown ? Construtors<A, undefined, undefined, undefined>
+    : Construtors<undefined, undefined, undefined, undefined>;
+
+type AnyConstructors = Construtors<any, any, any, any>;
+
+/**
+ * Returns all constructors where the first paramter is assignable to given "scope"
+ */
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+type FilterConstructorsByScope<T extends AnyConstructors, S> = {
+    a: S extends T["a"][0] ? T["a"] : undefined;
+    b: S extends T["b"][0] ? T["b"] : undefined;
+    c: S extends T["c"][0] ? T["c"] : undefined;
+    d: S extends T["d"][0] ? T["d"] : undefined;
+};
+/**
+ * "flattens" the tuple into an union type
+ */
+type ConstructorUnion<T extends AnyConstructors> =
+    | Exclude<T["a"], undefined>
+    | Exclude<T["b"], undefined>
+    | Exclude<T["c"], undefined>
+    | Exclude<T["d"], undefined>;
+
+/**
+ * Extract list of possible scopes - union of the first paramter
+ * of all constructors, should it be string
+ */
+type ExtractScopes<T extends AnyConstructors> =
+    | (T["a"][0] extends string ? T["a"][0] : never)
+    | (T["b"][0] extends string ? T["b"][0] : never)
+    | (T["c"][0] extends string ? T["c"][0] : never)
+    | (T["d"][0] extends string ? T["d"][0] : never);
+
+type GetConstructorsByScope<T, S> = ConstructorUnion<FilterConstructorsByScope<OverloadedConstructorsOf<T>, S>>;
+type GetConstructors<T> = ConstructorUnion<OverloadedConstructorsOf<T>>;
+type GetPossibleScopes<T> = ExtractScopes<OverloadedConstructorsOf<T>>;
+
+export type ConvertType = (...params: unknown[]) => ShaderNodeObject<Node>;
+
+type NodeArray<T extends NodeObjectOption[]> = { [index in keyof T]: NodeObject<T[index]> };
+type NodeObjects<T> = { [key in keyof T]: T[key] extends NodeObjectOption ? NodeObject<T[key]> : T[key] };
+type ConstructedNode<T> = T extends new(...args: any[]) => infer R ? (R extends Node ? R : never) : never;
+
+export type NodeOrType = Node | string;
+
+export const getConstNodeType: (value: NodeOrType) => string | null;
+
+export class ShaderNode<T = {}, R extends Node = Node> {
+    constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => NodeRepresentation);
+    call: (
+        inputs: { [key in keyof T]: T[key] extends NodeRepresentation ? ShaderNodeObject<Node> | Node : T[key] },
+        builder?: NodeBuilder,
+    ) => ShaderNodeObject<R>;
+}
+
+export function nodeObject<T extends NodeObjectOption>(obj: T): NodeObject<T>;
+export function nodeObjects<T>(obj: T): NodeObjects<T>;
+
+export function nodeArray<T extends NodeObjectOption[]>(obj: readonly [...T]): NodeArray<T>;
+
+export function nodeProxy<T>(
+    nodeClass: T,
+): (...params: ProxiedTuple<GetConstructors<T>>) => ShaderNodeObject<ConstructedNode<T>>;
+
+export function nodeProxy<T, S extends GetPossibleScopes<T>>(
+    nodeClass: T,
+    scope: S,
+): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
+
+export function nodeProxy<T, S extends GetPossibleScopes<T>>(
+    nodeClass: T,
+    scope: S,
+    factor: NodeObjectOption,
+): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
+
+export function nodeImmutable<T>(
+    nodeClass: T,
+    ...params: ProxiedTuple<GetConstructors<T>>
+): ShaderNodeObject<ConstructedNode<T>>;
+
+export function Fn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
+export function Fn<T extends any[], R extends Node = ShaderNodeObject<Node>>(
+    jsFunc: (args: T) => R,
+): (...args: ProxiedTuple<T>) => R;
+export function Fn<T extends { [key: string]: unknown }, R extends Node = ShaderNodeObject<Node>>(
+    jsFunc: (args: T) => R,
+): (args: ProxiedObject<T>) => R;
+
+/**
+ * @deprecated tslFn() has been renamed to Fn()
+ */
+export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
+/**
+ * @deprecated tslFn() has been renamed to Fn()
+ */
+export function tslFn<T extends any[], R extends Node = ShaderNodeObject<Node>>(
+    jsFunc: (args: T) => R,
+): (...args: ProxiedTuple<T>) => R;
+/**
+ * @deprecated tslFn() has been renamed to Fn()
+ */
+export function tslFn<T extends { [key: string]: unknown }, R extends Node = ShaderNodeObject<Node>>(
+    jsFunc: (args: T) => R,
+): (args: ProxiedObject<T>) => R;
+
+export const setCurrentStack: (stack: StackNode | null) => void;
+
+export const getCurrentStack: () => StackNode | null;
+
+export const If: (boolNode: Node, method: () => void) => StackNode;
+
+export function append(node: Node): Node;
+
+export const color: ConvertType;
+
+export const float: ConvertType;
+export const int: ConvertType;
+export const uint: ConvertType;
+export const bool: ConvertType;
+
+export const vec2: ConvertType;
+export const ivec2: ConvertType;
+export const uvec2: ConvertType;
+export const bvec2: ConvertType;
+
+export const vec3: ConvertType;
+export const ivec3: ConvertType;
+export const uvec3: ConvertType;
+export const bvec3: ConvertType;
+
+export const vec4: ConvertType;
+export const ivec4: ConvertType;
+export const uvec4: ConvertType;
+export const bvec4: ConvertType;
+
+export const mat2: ConvertType;
+export const mat3: ConvertType;
+export const mat4: ConvertType;
+
+export const string: (value?: string) => ShaderNodeObject<ConstNode<string>>;
+export const arrayBuffer: (value: ArrayBuffer) => ShaderNodeObject<ConstNode<ArrayBuffer>>;
+
+export const element: (node: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<Node>;
+export const convert: (node: NodeRepresentation, types: string) => ShaderNodeObject<Node>;

package/types/src/nodes/utils/ArrayElementNode.d.ts

@@ -0,0 +1,9 @@
+import Node from "../core/Node.js";
+import { TempNode } from "../Nodes.js";
+
+export default class ArrayElementNode extends TempNode {
+    node: Node;
+    indexNode: Node;
+
+    constructor(node: Node, indexNode: Node);
+}

package/types/src/nodes/utils/ConvertNode.d.ts

@@ -0,0 +1,7 @@
+import Node from "../core/Node.js";
+
+export default class ConvertNode extends Node {
+    node: Node;
+    convertTo: string;
+    constructor(node: Node, convertTo: string);
+}

package/types/src/nodes/utils/CubeMapNode.d.ts

@@ -0,0 +1,13 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class CubeMapNode extends TempNode {
+    envNode: Node;
+
+    constructor(envNode: Node);
+}
+
+export default CubeMapNode;
+
+export const cubeMapNode: (envNode: NodeRepresentation) => ShaderNodeObject<CubeMapNode>;

package/types/src/nodes/utils/Discard.d.ts

@@ -0,0 +1,11 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const Discard: (conditional: NodeRepresentation) => ShaderNodeObject<Node>;
+export const Return: () => ShaderNodeObject<Node>;
+
+declare module "../tsl/TSLCore.js" {
+    interface NodeElements {
+        discard: typeof Discard;
+    }
+}

package/types/src/nodes/utils/EquirectUVNode.d.ts

@@ -0,0 +1,8 @@
+import { Node, TempNode } from "../Nodes.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export default class EquirectUVNode extends TempNode {
+    constructor(dirNode?: ShaderNodeObject<Node>);
+}
+
+export const equirectUV: ShaderNodeObject<EquirectUVNode>;

package/types/src/nodes/utils/FunctionOverloadingNode.d.ts

@@ -0,0 +1,13 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class FunctionOverloadingNode extends Node {
+    functionNodes: Node[];
+    parameterNodes: Node[];
+
+    constructor(functionNodes?: Node[], ...parameterNodes: Node[]);
+}
+
+export default FunctionOverloadingNode;
+
+export const overloadingFn: (functionNodes: Node[]) => (...params: Node[]) => ShaderNodeObject<FunctionOverloadingNode>;

package/types/src/nodes/utils/JoinNode.d.ts

@@ -0,0 +1,10 @@
+import Node from "../core/Node.js";
+import { TempNode } from "../Nodes.js";
+
+/**
+ * This node constructs given type from elements, like vec3(a,b,c)
+ */
+export default class JoinNode extends TempNode {
+    nodes: Node[];
+    constructor(nodes: Node[]);
+}

package/types/src/nodes/utils/LoopNode.d.ts

@@ -0,0 +1,22 @@
+import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class LoopNode extends Node {
+    params: unknown[];
+
+    constructor(params?: unknown[]);
+
+    getProperties(builder: NodeBuilder): unknown;
+}
+
+export default LoopNode;
+
+export const Loop: (...params: unknown[]) => ShaderNodeObject<Node>;
+export const Continue: () => ShaderNodeObject<Node>;
+export const Break: () => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated loop() has been renamed to Loop()
+ */
+export const loop: (...params: unknown[]) => ShaderNodeObject<Node>;

package/types/src/nodes/utils/MatcapUVNode.d.ts

@@ -0,0 +1,8 @@
+import TempNode from "../core/TempNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export default class MatcapUVNode extends TempNode {
+    constructor();
+}
+
+export const matcapUV: ShaderNodeObject<MatcapUVNode>;

package/types/src/nodes/utils/MaxMipLevelNode.d.ts

@@ -0,0 +1,14 @@
+import { Texture } from "../../textures/Texture.js";
+import TextureNode from "../accessors/TextureNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export default class MaxMipLevelNode extends UniformNode<0> {
+    constructor(textureNode: TextureNode);
+
+    get textureNode(): TextureNode;
+
+    get texture(): Texture;
+}
+
+export const maxMipLevel: (texture: Texture) => ShaderNodeObject<MaxMipLevelNode>;

package/types/src/nodes/utils/OscNode.d.ts

@@ -0,0 +1,25 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type OscNodeMethod =
+    | typeof OscNode.SINE
+    | typeof OscNode.SQUARE
+    | typeof OscNode.TRIANGLE
+    | typeof OscNode.SAWTOOTH;
+
+export default class OscNode extends Node {
+    static SINE: "sine";
+    static SQUARE: "square";
+    static TRIANGLE: "triangle";
+    static SAWTOOTH: "sawtooth";
+
+    method: OscNodeMethod;
+    timeNode: Node;
+
+    constructor(method: OscNodeMethod, timeNode?: Node);
+}
+
+export const oscSine: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscSquare: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscTriangle: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscSawtooth: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;

package/types/src/nodes/utils/Packing.d.ts

@@ -0,0 +1,5 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const directionToColor: (node: NodeRepresentation) => ShaderNodeObject<Node>;
+export const colorToDirection: (node: NodeRepresentation) => ShaderNodeObject<Node>;

package/types/src/nodes/utils/RTTNode.d.ts

@@ -0,0 +1,45 @@
+import { TextureDataType } from "../../constants.js";
+import { RenderTarget } from "../../core/RenderTarget.js";
+import TextureNode from "../accessors/TextureNode.js";
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export interface RTTNodeOptions {
+    type: TextureDataType;
+}
+
+declare class RTTNode extends TextureNode {
+    node: Node;
+    width: number | null;
+    height: number | null;
+
+    renderTarget: RenderTarget | null;
+
+    textureNeedsUpdate: boolean;
+    autoUpdate: boolean;
+
+    pixelRatio?: number;
+
+    constructor(node: Node, width?: number | null, height?: number | null, options?: RTTNodeOptions);
+
+    get autoSize(): boolean;
+
+    setSize(width: number | null, height: number | null): void;
+
+    setPixelRatio(pixelRatio: number): void;
+}
+
+export default RTTNode;
+
+export const rtt: (
+    node: NodeRepresentation,
+    width?: number | null,
+    height?: number | null,
+    options?: RTTNodeOptions,
+) => ShaderNodeObject<RTTNode>;
+export const convertToTexture: (
+    node: Node,
+    width?: number | null,
+    height?: number | null,
+    options?: RTTNodeOptions,
+) => ShaderNodeObject<RTTNode>;

package/types/src/nodes/utils/ReflectorNode.d.ts

@@ -0,0 +1,32 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
+import { RenderTarget } from "../../core/RenderTarget.js";
+import TextureNode from "../accessors/TextureNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export interface ReflectorNodeParameters {
+    target?: Object3D | undefined;
+    resolution?: number | undefined;
+    generateMipmaps?: boolean | undefined;
+    bounces?: boolean | undefined;
+}
+
+export default class ReflectorNode extends TextureNode {
+    target: Object3D;
+    resolution: number;
+    generateMipmaps: boolean;
+    bounces: boolean;
+
+    virtualCameras: WeakMap<Camera, Camera>;
+    renderTargets: WeakMap<Camera, RenderTarget>;
+
+    constructor(parameters?: ReflectorNodeParameters);
+
+    getTextureNode(): TextureNode;
+
+    getVirtualCamera(camera: Camera): Camera;
+
+    getRenderTarget(camera: Camera): RenderTarget;
+}
+
+export const reflector: (parameters?: ReflectorNodeParameters) => ShaderNodeObject<ReflectorNode>;

package/types/src/nodes/utils/RemapNode.d.ts

@@ -0,0 +1,36 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export default class RemapNode extends Node {
+    node: Node;
+    inLowNode: Node;
+    inHighNode: Node;
+    outLowNode: Node;
+    outHighNode: Node;
+
+    doClamp: boolean;
+
+    constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode?: Node, outHighNode?: Node);
+}
+
+export const remap: (
+    node: Node,
+    inLowNode: NodeRepresentation,
+    inHighNode: NodeRepresentation,
+    outLowNode?: NodeRepresentation,
+    outHighNode?: NodeRepresentation,
+) => ShaderNodeObject<RemapNode>;
+export const remapClamp: (
+    node: Node,
+    inLowNode: NodeRepresentation,
+    inHighNode: NodeRepresentation,
+    outLowNode?: NodeRepresentation,
+    outHighNode?: NodeRepresentation,
+) => ShaderNodeObject<RemapNode>;
+
+declare module "../tsl/TSLCore.js" {
+    interface NodeElements {
+        remap: typeof remap;
+        remapClamp: typeof remapClamp;
+    }
+}

package/types/src/nodes/utils/RotateNode.d.ts

@@ -0,0 +1,15 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export default class RotateNode extends TempNode {
+    positionNode: Node;
+    rotationNode: Node;
+
+    constructor(positionNode: Node, rotationNode: Node);
+}
+
+export const rotate: (
+    positionNode: NodeRepresentation,
+    rotationNode: NodeRepresentation,
+) => ShaderNodeObject<RotateNode>;

package/types/src/nodes/utils/SetNode.d.ts

@@ -0,0 +1,11 @@
+import TempNode from "../core/TempNode.js";
+
+declare class SetNode extends TempNode {
+    sourceNode: Node;
+    components: string[];
+    targetNode: Node;
+
+    constructor(sourceNode: Node, components: string[], targetNode: Node);
+}
+
+export default SetNode;

package/types/src/nodes/utils/SplitNode.d.ts

@@ -0,0 +1,15 @@
+import Node from "../core/Node.js";
+import { SwizzleOption } from "../tsl/TSLCore.js";
+
+/** swizzle node */
+export default class SplitNode extends Node {
+    node: Node;
+    components: string;
+
+    /**
+     * @param node the input node
+     * @param components swizzle like string, default = "x"
+     */
+    constructor(node: Node, components?: SwizzleOption);
+    getVectorLength(): number;
+}

package/types/src/nodes/utils/SpriteSheetUVNode.d.ts

@@ -0,0 +1,16 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export default class SpriteSheetUVNode extends Node {
+    countNode: Node;
+    uvNode: Node;
+    frameNode: Node;
+
+    constructor(countNode: Node, uvNode?: Node, frameNode?: Node);
+}
+
+export const spritesheetUV: (
+    countNode: NodeRepresentation,
+    uvNode?: NodeRepresentation,
+    frameNode?: NodeRepresentation,
+) => ShaderNodeObject<SpriteSheetUVNode>;

package/types/src/nodes/utils/SpriteUtils.d.ts

@@ -0,0 +1,6 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const billboarding: (
+    args?: { position?: NodeRepresentation | null; horizontal?: boolean; vertical?: boolean },
+) => ShaderNodeObject<Node>;

package/types/src/nodes/utils/StorageArrayElementNode.d.ts

@@ -0,0 +1,19 @@
+import StorageBufferNode from "../accessors/StorageBufferNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import ArrayElementNode from "./ArrayElementNode.js";
+
+export default class StorageArrayElementNode extends ArrayElementNode {
+    node: StorageBufferNode;
+
+    readonly isStorageArrayElementNode: true;
+
+    constructor(storageBufferNode: StorageBufferNode, indexNode: Node);
+
+    get storageBufferNode(): StorageBufferNode;
+    set storageBufferNode(value: StorageBufferNode);
+}
+
+export const storageElement: (
+    storageBufferNode: NodeRepresentation,
+    indexNode: NodeRepresentation,
+) => ShaderNodeObject<StorageArrayElementNode>;

package/types/src/nodes/utils/TimerNode.d.ts

@@ -0,0 +1,25 @@
+import UniformNode from "../core/UniformNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type TimerNodeScope =
+    | typeof TimerNode.LOCAL
+    | typeof TimerNode.GLOBAL
+    | typeof TimerNode.DELTA
+    | typeof TimerNode.FRAME;
+
+export default class TimerNode extends UniformNode<number> {
+    static LOCAL: "local";
+    static GLOBAL: "global";
+    static DELTA: "delta";
+    static FRAME: "frame";
+
+    scope: TimerNodeScope;
+    scale: number;
+
+    constructor(scope?: TimerNodeScope, scale?: number, value?: number);
+}
+
+export const timerLocal: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const timerGlobal: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const timerDelta: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const frameId: ShaderNodeObject<TimerNode>;