@types/three 0.164.1 → 0.166.0

three/examples/jsm/renderers/common/Binding.d.ts

@@ -0,0 +1,8 @@
+declare class Binding {
+    name: string;
+    visibility: number;
+    constructor(name?: string);
+    setVisibility(visibility: number): void;
+    clone(): Binding & this;
+}
+export default Binding;

three/examples/jsm/renderers/common/Bindings.d.ts

@@ -0,0 +1,42 @@
+import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
+import Attributes from "./Attributes.js";
+import Backend from "./Backend.js";
+import BindGroup from "./BindGroup.js";
+import DataMap from "./DataMap.js";
+import Info from "./Info.js";
+import Nodes from "./nodes/Nodes.js";
+import Pipelines from "./Pipelines.js";
+import RenderObject from "./RenderObject.js";
+import Textures from "./Textures.js";
+interface BindGroupData {
+    bindGroup?: BindGroup | undefined;
+}
+declare class Bindings extends DataMap<{
+    bindGroup: {
+        key: BindGroup;
+        value: BindGroupData;
+    };
+}> {
+    backend: Backend;
+    textures: Textures;
+    pipelines: Pipelines;
+    attributes: Attributes;
+    nodes: Nodes;
+    info: Info;
+    constructor(
+        backend: Backend,
+        nodes: Nodes,
+        textures: Textures,
+        attributes: Attributes,
+        pipelines: Pipelines,
+        info: Info,
+    );
+    getForRender(renderObject: RenderObject): BindGroup[];
+    getForCompute(computeNode: ComputeNode): BindGroup[];
+    updateForCompute(computeNode: ComputeNode): void;
+    updateForRender(renderObject: RenderObject): void;
+    _updateBindings(object: ComputeNode | RenderObject, bindings: BindGroup[]): void;
+    _init(bindGroup: BindGroup): void;
+    _update(object: ComputeNode | RenderObject, bindGroup: BindGroup, bindings: BindGroup[]): void;
+}
+export default Bindings;

three/examples/jsm/renderers/common/Buffer.d.ts

@@ -0,0 +1,11 @@
+import Binding from "./Binding.js";
+declare class Buffer extends Binding {
+    readonly isBuffer: true;
+    bytesPerElement: number;
+    _buffer: Float32Array | null;
+    constructor(name?: string, buffer?: Float32Array | null);
+    get byteLength(): number;
+    get buffer(): Float32Array | null;
+    update(): boolean;
+}
+export default Buffer;

three/examples/jsm/renderers/common/BufferUtils.d.ts

@@ -0,0 +1,4 @@
+declare function getFloatLength(floatLength: number): number;
+declare function getVectorLength(count: number, vectorLength?: number): number;
+declare function getStrideLength(vectorLength: number): number;
+export { getFloatLength, getStrideLength, getVectorLength };

three/examples/jsm/renderers/common/ChainMap.d.ts

@@ -0,0 +1,9 @@
+type RecursiveWeakMap<K extends readonly object[], V> = WeakMap<K[number], V | RecursiveWeakMap<K, V>>;
+export default class ChainMap<K extends readonly object[], V> {
+    weakMap: RecursiveWeakMap<K, V>;
+    constructor();
+    get(keys: K): V | undefined;
+    set(keys: K, value: V): V;
+    delete(keys: K): boolean;
+}
+export {};

three/examples/jsm/renderers/common/ClippingContext.d.ts

@@ -0,0 +1,18 @@
+import { Camera, Material, Matrix3, Matrix4, Plane, Vector4 } from "three";
+import Renderer from "./Renderer.js";
+declare class ClippingContext {
+    version: number;
+    globalClippingCount: number;
+    localClippingCount: number;
+    localClippingEnabled: boolean | undefined;
+    localClipIntersection: boolean;
+    planes: Vector4[];
+    parentVersion: number;
+    viewNormalMatrix: Matrix3;
+    viewMatrix?: Matrix4 | undefined;
+    constructor();
+    projectPlanes(source: readonly Plane[], offset: number): void;
+    updateGlobal(renderer: Renderer, camera: Camera): void;
+    update(parent: ClippingContext, material: Material): void;
+}
+export default ClippingContext;

three/examples/jsm/renderers/common/Color4.d.ts

@@ -1,9 +1,10 @@
-import { Color, ColorRepresentation } from "../../../../src/math/Color.js";
-
-export default class Color4 extends Color {
+import { Color, ColorRepresentation } from "three";
+declare class Color4 extends Color {
+    a: number;
+    constructor(color?: ColorRepresentation);
     constructor(r: number, g: number, b: number, a?: number);
-
     set(...args: [color: ColorRepresentation] | [r: number, g: number, b: number, a?: number]): this;
-
+    copy(color: Color): this;
     clone(): this;
 }
+export default Color4;

three/examples/jsm/renderers/common/ComputePipeline.d.ts

@@ -0,0 +1,8 @@
+import Pipeline from "./Pipeline.js";
+import ProgrammableStage from "./ProgrammableStage.js";
+declare class ComputePipeline extends Pipeline {
+    computeProgram: ProgrammableStage;
+    readonly isComputePipeline: true;
+    constructor(cacheKey: string, computeProgram: ProgrammableStage);
+}
+export default ComputePipeline;

three/examples/jsm/renderers/common/Constants.d.ts

@@ -0,0 +1,9 @@
+export declare const AttributeType: {
+    readonly VERTEX: 1;
+    readonly INDEX: 2;
+    readonly STORAGE: 4;
+};
+export type AttributeType = (typeof AttributeType)[keyof typeof AttributeType];
+export declare const GPU_CHUNK_BYTES = 16;
+export declare const BlendColorFactor = 211;
+export declare const OneMinusBlendColorFactor = 212;

three/examples/jsm/renderers/common/CubeRenderTarget.d.ts

@@ -0,0 +1,7 @@
+import { RenderTargetOptions, Texture, WebGLCubeRenderTarget, WebGLRenderer } from "three";
+declare class CubeRenderTarget extends WebGLCubeRenderTarget {
+    readonly isCubeRenderTarget: true;
+    constructor(size?: number, options?: RenderTargetOptions);
+    fromEquirectangularTexture(renderer: WebGLRenderer, texture: Texture): this;
+}
+export default CubeRenderTarget;

three/examples/jsm/renderers/common/DataMap.d.ts

@@ -0,0 +1,20 @@
+declare class DataMap<
+    M extends {
+        [key: string]: {
+            key: object;
+            value: unknown;
+        };
+    },
+> {
+    data: WeakMap<M[keyof M]["key"], M[keyof M]["value"]>;
+    constructor();
+    get<K extends M[keyof M]["key"]>(object: K): Extract<M[keyof M], {
+        key: K;
+    }>["value"];
+    delete<K extends M[keyof M]["key"]>(object: K): Extract<M[keyof M], {
+        key: K;
+    }>["value"];
+    has(object: M[keyof M]["key"]): boolean;
+    dispose(): void;
+}
+export default DataMap;

three/examples/jsm/renderers/common/Geometries.d.ts

@@ -0,0 +1,28 @@
+import { BufferAttribute, BufferGeometry, InterleavedBuffer, InterleavedBufferAttribute } from "three";
+import Attributes from "./Attributes.js";
+import { AttributeType } from "./Constants.js";
+import DataMap from "./DataMap.js";
+import Info from "./Info.js";
+import RenderObject from "./RenderObject.js";
+interface GeometryData {
+    initialized?: boolean | undefined;
+}
+declare class Geometries extends DataMap<{
+    geometry: {
+        key: BufferGeometry;
+        value: GeometryData;
+    };
+}> {
+    attributes: Attributes;
+    info: Info;
+    wireframes: WeakMap<BufferGeometry, BufferAttribute>;
+    attributeCall: WeakMap<BufferAttribute | InterleavedBufferAttribute | InterleavedBuffer, number>;
+    constructor(attributes: Attributes, info: Info);
+    has(renderObject: RenderObject | BufferGeometry): boolean;
+    updateForRender(renderObject: RenderObject): void;
+    initGeometry(renderObject: RenderObject): void;
+    updateAttributes(renderObject: RenderObject): void;
+    updateAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
+    getIndex(renderObject: RenderObject): BufferAttribute | null;
+}
+export default Geometries;

three/examples/jsm/renderers/common/Info.d.ts

@@ -1,22 +1,34 @@
 import { Object3D } from "three";
-
-export default class Info {
+declare class Info {
     autoReset: boolean;
-
     frame: number;
     calls: number;
-
-    render: { calls: number; drawCalls: number; triangles: number; points: number; lines: number; timestamp: number };
-
-    compute: { calls: number; computeCalls: number; timestamp: number };
-
-    memory: { geometries: number; textures: number };
-
+    render: {
+        calls: number;
+        frameCalls: number;
+        drawCalls: number;
+        triangles: number;
+        points: number;
+        lines: number;
+        timestamp: number;
+        previousFrameCalls: number;
+        timestampCalls: number;
+    };
+    compute: {
+        calls: number;
+        frameCalls: number;
+        timestamp: number;
+        previousFrameCalls: number;
+        timestampCalls: number;
+    };
+    memory: {
+        geometries: number;
+        textures: number;
+    };
+    constructor();
     update(object: Object3D, count: number, instanceCount: number): void;
-
     updateTimestamp(type: "render" | "compute", time: number): void;
-
     reset(): void;
-
     dispose(): void;
 }
+export default Info;

three/examples/jsm/renderers/common/Pipeline.d.ts

@@ -0,0 +1,6 @@
+declare class Pipeline {
+    cacheKey: string;
+    usedTimes: number;
+    constructor(cacheKey: string);
+}
+export default Pipeline;

three/examples/jsm/renderers/common/Pipelines.d.ts

@@ -0,0 +1,68 @@
+import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
+import Backend from "./Backend.js";
+import Binding from "./Binding.js";
+import Bindings from "./Bindings.js";
+import ComputePipeline from "./ComputePipeline.js";
+import DataMap from "./DataMap.js";
+import Nodes from "./nodes/Nodes.js";
+import Pipeline from "./Pipeline.js";
+import ProgrammableStage from "./ProgrammableStage.js";
+import RenderObject from "./RenderObject.js";
+import RenderPipeline from "./RenderPipeline.js";
+interface ComputeNodeData {
+    version: number;
+    pipeline: ComputePipeline;
+}
+interface RenderObjectData {
+    pipeline: RenderPipeline;
+}
+declare class Pipelines extends DataMap<{
+    computeNode: {
+        key: ComputeNode;
+        value: ComputeNodeData;
+    };
+    renderObject: {
+        key: RenderObject;
+        value: RenderObjectData;
+    };
+}> {
+    backend: Backend;
+    nodes: Nodes;
+    bindings: Bindings | null;
+    caches: Map<string, Pipeline>;
+    programs: {
+        vertex: Map<string, ProgrammableStage>;
+        fragment: Map<string, ProgrammableStage>;
+        compute: Map<string, ProgrammableStage>;
+    };
+    constructor(backend: Backend, nodes: Nodes);
+    getForCompute(computeNode: ComputeNode, bindings: Binding[]): ComputePipeline;
+    getForRender(renderObject: RenderObject, promises?: Promise<void>[] | null): RenderPipeline;
+    delete(object: ComputeNode | RenderObject): never;
+    dispose(): void;
+    updateForRender(renderObject: RenderObject): void;
+    _getComputePipeline(
+        computeNode: ComputeNode,
+        stageCompute: ProgrammableStage,
+        cacheKey: string,
+        bindings: Binding[],
+    ): ComputePipeline;
+    _getRenderPipeline(
+        renderObject: RenderObject,
+        stageVertex: ProgrammableStage,
+        stageFragment: ProgrammableStage,
+        cacheKey: string,
+        promises: Promise<void>[] | null,
+    ): RenderPipeline;
+    _getComputeCacheKey(computeNode: ComputeNode, stageCompute: ProgrammableStage): string;
+    _getRenderCacheKey(
+        renderObject: RenderObject,
+        stageVertex: ProgrammableStage,
+        stageFragment: ProgrammableStage,
+    ): string;
+    _releasePipeline(pipeline: Pipeline): void;
+    _releaseProgram(program: ProgrammableStage): void;
+    _needsComputeUpdate(computeNode: ComputeNode): boolean;
+    _needsRenderUpdate(renderObject: RenderObject): true | void;
+}
+export default Pipelines;

three/examples/jsm/renderers/common/PostProcessing.d.ts

@@ -10,4 +10,6 @@ export default class PostProcessing {
     render(): void;
 
     renderAsync(): Promise<void>;
+
+    set needsUpdate(value: boolean);
 }

three/examples/jsm/renderers/common/ProgrammableStage.d.ts

@@ -0,0 +1,15 @@
+import NodeAttribute from "../../nodes/core/NodeAttribute.js";
+declare class ProgrammableStage {
+    id: number;
+    code: string;
+    stage: "compute" | "vertex" | "fragment";
+    attributes: NodeAttribute[] | null;
+    usedTimes: number;
+    constructor(
+        code: string,
+        type: "compute" | "vertex" | "fragment",
+        transforms?: null,
+        attributes?: NodeAttribute[] | null,
+    );
+}
+export default ProgrammableStage;

three/examples/jsm/renderers/common/RenderBundle.d.ts

@@ -0,0 +1,8 @@
+import { Camera, Object3D } from "three";
+declare class RenderBundle {
+    scene: Object3D;
+    camera: Camera;
+    constructor(scene: Object3D, camera: Camera);
+    clone(): RenderBundle & this;
+}
+export default RenderBundle;

three/examples/jsm/renderers/common/RenderBundles.d.ts

@@ -0,0 +1,10 @@
+import { Camera, Object3D } from "three";
+import ChainMap from "./ChainMap.js";
+import RenderBundle from "./RenderBundle.js";
+declare class RenderBundles {
+    lists: ChainMap<readonly [Object3D, Camera], RenderBundle>;
+    constructor();
+    get(scene: Object3D, camera: Camera): RenderBundle;
+    dispose(): void;
+}
+export default RenderBundles;

three/examples/jsm/renderers/common/RenderContext.d.ts

@@ -0,0 +1,38 @@
+import { DepthTexture, RenderTarget, Texture, Vector4 } from "three";
+import ClippingContext from "./ClippingContext.js";
+declare class RenderContext {
+    id: number;
+    color: boolean;
+    clearColor: boolean;
+    clearColorValue: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    depth: boolean;
+    clearDepth: boolean;
+    clearDepthValue: number;
+    stencil: boolean;
+    clearStencil: boolean;
+    clearStencilValue: number;
+    viewport: boolean;
+    viewportValue: Vector4;
+    scissor: boolean;
+    scissorValue: Vector4;
+    textures: Texture[] | null;
+    depthTexture: DepthTexture | null;
+    activeCubeFace: number;
+    sampleCount: number;
+    width: number;
+    height: number;
+    readonly isRenderContext: true;
+    clippingContext?: ClippingContext | undefined;
+    depthClearValue?: number | undefined;
+    stencilClearValue?: number | undefined;
+    renderTarget?: RenderTarget | undefined;
+    activeMipmapLevel?: number | undefined;
+    occlusionQueryCount?: number | undefined;
+    constructor();
+}
+export default RenderContext;

three/examples/jsm/renderers/common/RenderContexts.d.ts

@@ -0,0 +1,13 @@
+import { Camera, RenderTarget, Scene } from "three";
+import ChainMap from "./ChainMap.js";
+import RenderContext from "./RenderContext.js";
+declare class RenderContexts {
+    chainMaps: {
+        [attachmentState: string]: ChainMap<readonly [Scene, Camera], RenderContext> | undefined;
+    };
+    constructor();
+    get(scene: Scene, camera: Camera, renderTarget?: RenderTarget | null): RenderContext;
+    getChainMap(attachmentState: string): ChainMap<readonly [Scene, Camera], RenderContext>;
+    dispose(): void;
+}
+export default RenderContexts;

three/examples/jsm/renderers/common/RenderList.d.ts

@@ -0,0 +1,62 @@
+import { BufferGeometry, Camera, GeometryGroup, Light, Material, Object3D } from "three";
+import { LightsNode } from "../../nodes/Nodes.js";
+export interface Bundle {
+    object: Object3D;
+    camera: Camera;
+    renderList: RenderList;
+}
+export interface RenderItem {
+    id: number | null;
+    object: Object3D | null;
+    geometry: BufferGeometry | null;
+    material: Material | null;
+    groupOrder: number | null;
+    renderOrder: number | null;
+    z: number | null;
+    group: GeometryGroup | null;
+}
+declare class RenderList {
+    renderItems: RenderItem[];
+    renderItemsIndex: number;
+    opaque: RenderItem[];
+    transparent: RenderItem[];
+    bundles: Bundle[];
+    lightsNode: LightsNode;
+    lightsArray: Light[];
+    occlusionQueryCount: number;
+    constructor();
+    begin(): this;
+    getNextRenderItem(
+        object: Object3D,
+        geometry: BufferGeometry,
+        material: Material,
+        groupOrder: number,
+        z: number,
+        group: GeometryGroup | null,
+    ): RenderItem;
+    push(
+        object: Object3D,
+        geometry: BufferGeometry,
+        material: Material,
+        groupOrder: number,
+        z: number,
+        group: GeometryGroup | null,
+    ): void;
+    unshift(
+        object: Object3D,
+        geometry: BufferGeometry,
+        material: Material,
+        groupOrder: number,
+        z: number,
+        group: GeometryGroup | null,
+    ): void;
+    pushBundle(group: Bundle): void;
+    pushLight(light: Light): void;
+    getLightsNode(): LightsNode;
+    sort(
+        customOpaqueSort: ((a: RenderItem, b: RenderItem) => number) | null,
+        customTransparentSort: ((a: RenderItem, b: RenderItem) => number) | null,
+    ): void;
+    finish(): void;
+}
+export default RenderList;

three/examples/jsm/renderers/common/RenderLists.d.ts

@@ -0,0 +1,10 @@
+import { Camera, Object3D } from "three";
+import ChainMap from "./ChainMap.js";
+import RenderList from "./RenderList.js";
+declare class RenderLists {
+    lists: ChainMap<readonly [Object3D, Camera], RenderList>;
+    constructor();
+    get(scene: Object3D, camera: Camera): RenderList;
+    dispose(): void;
+}
+export default RenderLists;

three/examples/jsm/renderers/common/RenderObject.d.ts

@@ -0,0 +1,73 @@
+import {
+    BufferAttribute,
+    BufferGeometry,
+    Camera,
+    InterleavedBuffer,
+    InterleavedBufferAttribute,
+    Material,
+    Object3D,
+    Scene,
+} from "three";
+import LightsNode from "../../nodes/lighting/LightsNode.js";
+import BindGroup from "./BindGroup.js";
+import ClippingContext from "./ClippingContext.js";
+import Geometries from "./Geometries.js";
+import NodeBuilderState from "./nodes/NodeBuilderState.js";
+import Nodes from "./nodes/Nodes.js";
+import RenderContext from "./RenderContext.js";
+import Renderer from "./Renderer.js";
+import RenderPipeline from "./RenderPipeline.js";
+export default class RenderObject {
+    _nodes: Nodes;
+    _geometries: Geometries;
+    id: number;
+    renderer: Renderer;
+    object: Object3D;
+    material: Material;
+    scene: Scene;
+    camera: Camera;
+    lightsNode: LightsNode;
+    context: RenderContext;
+    geometry: BufferGeometry;
+    version: number;
+    drawRange: {
+        start: number;
+        count: number;
+    } | null;
+    attributes: Array<BufferAttribute | InterleavedBufferAttribute> | null;
+    pipeline: RenderPipeline | null;
+    vertexBuffers: Array<BufferAttribute | InterleavedBuffer> | null;
+    clippingContext: ClippingContext;
+    clippingContextVersion: number;
+    initialNodesCacheKey: string;
+    initialCacheKey: string;
+    _nodeBuilderState: NodeBuilderState | null;
+    _bindings: BindGroup[] | null;
+    onDispose: (() => void) | null;
+    readonly isRenderObject: true;
+    onMaterialDispose: () => void;
+    constructor(
+        nodes: Nodes,
+        geometries: Geometries,
+        renderer: Renderer,
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
+        lightsNode: LightsNode,
+        renderContext: RenderContext,
+    );
+    updateClipping(parent: ClippingContext): void;
+    get clippingNeedsUpdate(): boolean;
+    getNodeBuilderState(): NodeBuilderState;
+    getBindings(): BindGroup[];
+    getIndex(): BufferAttribute | null;
+    getChainArray(): readonly [Object3D<import("three").Object3DEventMap>, Material, RenderContext, LightsNode];
+    getAttributes(): (InterleavedBufferAttribute | BufferAttribute)[];
+    getVertexBuffers(): (InterleavedBuffer | BufferAttribute)[] | null;
+    getMaterialCacheKey(): string;
+    get needsUpdate(): boolean;
+    getNodesCacheKey(): string;
+    getCacheKey(): string;
+    dispose(): void;
+}

three/examples/jsm/renderers/common/RenderObjects.d.ts

@@ -0,0 +1,59 @@
+import { Camera, Material, Object3D, Scene } from "three";
+import LightsNode from "../../nodes/lighting/LightsNode.js";
+import Bindings from "./Bindings.js";
+import ChainMap from "./ChainMap.js";
+import Geometries from "./Geometries.js";
+import Info from "./Info.js";
+import Nodes from "./nodes/Nodes.js";
+import Pipelines from "./Pipelines.js";
+import RenderContext from "./RenderContext.js";
+import Renderer from "./Renderer.js";
+import RenderObject from "./RenderObject.js";
+declare class RenderObjects {
+    renderer: Renderer;
+    nodes: Nodes;
+    geometries: Geometries;
+    pipelines: Pipelines;
+    bindings: Bindings;
+    info: Info;
+    chainMaps: {
+        [passId: string]: ChainMap<readonly [Object3D, Material, RenderContext, LightsNode], RenderObject>;
+    };
+    constructor(
+        renderer: Renderer,
+        nodes: Nodes,
+        geometries: Geometries,
+        pipelines: Pipelines,
+        bindings: Bindings,
+        info: Info,
+    );
+    get(
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
+        lightsNode: LightsNode,
+        renderContext: RenderContext,
+        passId: string | undefined,
+    ): RenderObject;
+    getChainMap(
+        passId?: string,
+    ): ChainMap<
+        readonly [Object3D<import("three").Object3DEventMap>, Material, RenderContext, LightsNode],
+        RenderObject
+    >;
+    dispose(): void;
+    createRenderObject(
+        nodes: Nodes,
+        geometries: Geometries,
+        renderer: Renderer,
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
+        lightsNode: LightsNode,
+        renderContext: RenderContext,
+        passId: string | undefined,
+    ): RenderObject;
+}
+export default RenderObjects;

three/examples/jsm/renderers/common/RenderPipeline.d.ts

@@ -0,0 +1,8 @@
+import Pipeline from "./Pipeline.js";
+import ProgrammableStage from "./ProgrammableStage.js";
+declare class RenderPipeline extends Pipeline {
+    vertexProgram: ProgrammableStage;
+    fragmentProgram: ProgrammableStage;
+    constructor(cacheKey: string, vertexProgram: ProgrammableStage, fragmentProgram: ProgrammableStage);
+}
+export default RenderPipeline;