@types/three 0.164.1 → 0.166.0

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

@@ -1,11 +1,13 @@
+/// <reference types="webxr" />
 import {
+    Box2,
+    BufferAttribute,
     BufferGeometry,
     Camera,
     Color,
     ColorSpace,
-    CoordinateSystem,
     FramebufferTexture,
-    Group,
+    GeometryGroup,
     Material,
     Object3D,
     Plane,
@@ -20,259 +22,216 @@ import {
 import Node from "../../nodes/core/Node.js";
 import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
 import LightsNode from "../../nodes/lighting/LightsNode.js";
-import Color4 from "./../common/Color4.js";
+import Animation from "./Animation.js";
+import Attributes from "./Attributes.js";
 import Backend from "./Backend.js";
+import Background from "./Background.js";
+import Bindings from "./Bindings.js";
+import Color4 from "./Color4.js";
+import Geometries from "./Geometries.js";
 import Info from "./Info.js";
-
+import Nodes from "./nodes/Nodes.js";
+import Pipelines from "./Pipelines.js";
+import RenderBundle from "./RenderBundle.js";
+import RenderBundles from "./RenderBundles.js";
+import RenderContext from "./RenderContext.js";
+import RenderContexts from "./RenderContexts.js";
+import RenderList, { Bundle, RenderItem } from "./RenderList.js";
+import RenderLists from "./RenderLists.js";
+import RenderObjects from "./RenderObjects.js";
+import Textures from "./Textures.js";
 export interface RendererParameters {
     logarithmicDepthBuffer?: boolean | undefined;
     alpha?: boolean | undefined;
 }
-
-/**
- * Generic Renderer interface containing either a WebGL or WebGPU backend.
- */
-export default class Renderer {
-    /**
-     * @default true
-     */
+declare class Renderer {
     readonly isRenderer: true;
-
     domElement: HTMLCanvasElement;
-
-    /**
-     * The renderer backend; could be WebGLBackend or WebGPUBackend
-     */
     backend: Backend;
-
-    /**
-     * @default true
-     */
     autoClear: boolean;
-
-    /**
-     * @default true
-     */
     autoClearColor: boolean;
-
-    /**
-     * @default true
-     */
     autoClearDepth: boolean;
-
-    /**
-     * @default true
-     */
     autoClearStencil: boolean;
-
-    /**
-     * @default SRGBColorSpace
-     */
+    alpha: boolean;
+    logarithmicDepthBuffer: boolean;
     outputColorSpace: ColorSpace;
-
-    /**
-     * @default NoToneMapping
-     */
     toneMapping: ToneMapping;
-
-    /**
-     * @default 1.0
-     */
     toneMappingExposure: number;
-
-    /**
-     * @default true
-     */
     sortObjects: boolean;
-
-    /**
-     * @default true
-     */
     depth: boolean;
-
-    /**
-     * @default false
-     */
     stencil: boolean;
-
     clippingPlanes: readonly Plane[];
-
-    toneMappingNode: Node | null;
-
     info: Info;
-
-    shadowMap: { enabled: boolean; type: ShadowMapType };
-
-    xr: { enabled: boolean };
-
-    localClippingEnabled?: boolean;
-
+    toneMappingNode: Node | null;
+    _pixelRatio: number;
+    _width: number;
+    _height: number;
+    _viewport: Vector4;
+    _scissor: Vector4;
+    _scissorTest: boolean;
+    _attributes: Attributes | null;
+    _geometries: Geometries | null;
+    _nodes: Nodes | null;
+    _animation: Animation | null;
+    _bindings: Bindings | null;
+    _objects: RenderObjects | null;
+    _pipelines: Pipelines | null;
+    _bundles: RenderBundles | null;
+    _renderLists: RenderLists | null;
+    _renderContexts: RenderContexts | null;
+    _textures: Textures | null;
+    _background: Background | null;
+    _currentRenderContext: RenderContext | null;
+    _opaqueSort: ((a: RenderItem, b: RenderItem) => number) | null;
+    _transparentSort: ((a: RenderItem, b: RenderItem) => number) | null;
+    _frameBufferTarget: RenderTarget | null;
+    _clearColor: Color4;
+    _clearDepth: number;
+    _clearStencil: number;
+    _renderTarget: RenderTarget | null;
+    _activeCubeFace: number;
+    _activeMipmapLevel: number;
+    _renderObjectFunction:
+        | ((
+            object: Object3D,
+            scene: Scene,
+            camera: Camera,
+            geometry: BufferGeometry,
+            material: Material,
+            group: GeometryGroup,
+            lightsNode: LightsNode,
+        ) => void)
+        | null;
+    _currentRenderObjectFunction:
+        | ((
+            object: Object3D,
+            scene: Scene,
+            camera: Camera,
+            geometry: BufferGeometry,
+            material: Material,
+            group: GeometryGroup,
+            lightsNode: LightsNode,
+        ) => void)
+        | null;
+    _currentRenderBundle: RenderBundle | null;
+    _handleObjectFunction: (
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
+        lightsNode: LightsNode,
+        group: GeometryGroup,
+        passId?: string,
+    ) => void;
+    _initialized: boolean;
+    _initPromise: Promise<void> | null;
+    _compilationPromises: Promise<void>[] | null;
+    shadowMap: {
+        enabled: boolean;
+        type: ShadowMapType | null;
+    };
+    xr: {
+        enabled: boolean;
+    };
+    debug: {
+        checkShaderErrors: boolean;
+        onShaderError:
+            | ((
+                gl: WebGL2RenderingContext,
+                programGPU: WebGLProgram,
+                glVertexShader: WebGLShader,
+                glFragmentShader: WebGLShader,
+            ) => void)
+            | null;
+    };
+    localClippingEnabled?: boolean | undefined;
     constructor(backend: Backend, parameters?: RendererParameters);
-
     init(): Promise<void>;
-
-    get coordinateSystem(): CoordinateSystem;
-
+    get coordinateSystem(): import("three").CoordinateSystem;
     compileAsync(scene: Scene, camera: Camera, targetScene?: Scene | null): Promise<void>;
-
     renderAsync(scene: Scene, camera: Camera): Promise<void>;
-
-    render(scene: Scene, camera: Camera): void;
-
+    _renderBundle(bundle: Bundle, sceneRef: Scene, lightsNode: LightsNode): void;
+    render(scene: Scene, camera: Camera): Promise<void> | undefined;
+    _getFrameBufferTarget(): RenderTarget<Texture> | null;
+    _renderScene(scene: Scene, camera: Camera, useFrameBufferTarget?: boolean): RenderContext;
     getMaxAnisotropy(): number;
-
     getActiveCubeFace(): number;
-
     getActiveMipmapLevel(): number;
-
-    setAnimationLoop(callback: ((time: DOMHighResTimeStamp) => void) | null): Promise<void>;
-
-    /**
-     * Sets the pixel ratio of the Renderer.
-     */
-    setPixelRatio(value?: number): void;
-
-    /**
-     * Sets the width and height of the output canvas and optionally updates the CSS style on the DOM element.
-     */
-    setSize(width: number, height: number, updateStyle?: boolean): void;
-
-    /**
-     * Gets the Rendering Context of the renderer.
-     */
-    getContext(): RenderingContext;
-
-    /**
-     * Gets the current pixel ratio of the renderer.
-     */
+    setAnimationLoop(callback: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null): Promise<void>;
+    getArrayBufferAsync(attribute: BufferAttribute): Promise<ArrayBuffer>;
+    getContext(): void;
     getPixelRatio(): number;
-
     getDrawingBufferSize(target: Vector2): Vector2;
-
     getSize(target: Vector2): Vector2;
-
+    setPixelRatio(value?: number): void;
     setDrawingBufferSize(width: number, height: number, pixelRatio: number): void;
-
-    /**
-     * Sets the custom opaque sort function for the RenderLists. Pass null to use the default painterSortStable function.
-     */
-    setOpaqueSort(method: (a: unknown, b: unknown) => number): void;
-
-    /**
-     * Sets the custom transparent sort function for the RenderLists. Pass null to use the default reversePainterSortStable function.
-     */
-    setTransparentSort(method: (a: unknown, b: unknown) => number): void;
-
-    /**
-     * Copies the scissor area into target.
-     */
+    setSize(width: number, height: number, updateStyle?: boolean): void;
+    setOpaqueSort(method: ((a: RenderItem, b: RenderItem) => number) | null): void;
+    setTransparentSort(method: ((a: RenderItem, b: RenderItem) => number) | null): void;
     getScissor(target: Vector4): Vector4;
-
-    /**
-     * Sets the scissor area from (x, y) to (x + width, y + height).
-     */
+    setScissor(x: Vector4): void;
     setScissor(x: number, y: number, width: number, height: number): void;
-
-    /**
-     * Returns true if scissor test is enabled; returns false otherwise.
-     */
     getScissorTest(): boolean;
-
-    /**
-     * Enable the scissor test. When this is enabled, only the pixels within the defined scissor area will be affected by further renderer actions.
-     */
     setScissorTest(boolean: boolean): void;
-
-    /**
-     * Copies the viewport into target.
-     */
     getViewport(target: Vector4): Vector4;
-
-    /**
-     * Sets the viewport to render from (x, y) to (x + width, y + height).
-     * (x, y) is the lower-left corner of the region.
-     */
+    setViewport(x: Vector4): void;
     setViewport(x: number, y: number, width: number, height: number, minDepth?: number, maxDepth?: number): void;
-
-    /**
-     * Returns a Color4 instance with the current clear color.
-     */
     getClearColor(target: Color4): Color4;
-
-    /**
-     * Sets the clear color, using color for the color and alpha for the opacity.
-     */
     setClearColor(color: Color, alpha?: number): void;
-
-    /**
-     * Returns a float with the current clear alpha. Ranges from 0 to 1.
-     */
     getClearAlpha(): number;
-
     setClearAlpha(alpha: number): void;
-
     getClearDepth(): number;
-
     setClearDepth(depth: number): void;
-
     getClearStencil(): number;
-
     setClearStencil(stencil: number): void;
-
-    isOccluded(object: Object3D): boolean;
-
-    /**
-     * Tells the renderer to clear its color, depth or stencil drawing buffer(s).
-     * Arguments default to true
-     */
-    clear(color?: boolean, depth?: boolean, stencil?: boolean): void;
-
-    /**
-     * Clear the color buffer. Equivalent to calling .clear( true, false, false ).
-     */
-    clearColor(): void;
-
-    /**
-     * Clear the depth buffer. Equivalent to calling .clear( false, true, false ).
-     */
-    clearDepth(): void;
-
-    /**
-     * Clear the stencil buffer. Equivalent to calling .clear( false, false, true ).
-     */
-    clearStencil(): void;
-
-    /**
-     * Tells the renderer to clear its color, depth or stencil drawing buffer(s).
-     * Arguments default to true
-     */
+    isOccluded(object: Object3D): boolean | null;
+    clear(color?: boolean, depth?: boolean, stencil?: boolean): Promise<void> | undefined;
+    clearColor(): Promise<void> | undefined;
+    clearDepth(): Promise<void> | undefined;
+    clearStencil(): Promise<void> | undefined;
     clearAsync(color?: boolean, depth?: boolean, stencil?: boolean): Promise<void>;
-
+    clearColorAsync(): Promise<void>;
+    clearDepthAsync(): Promise<void>;
+    clearStencilAsync(): Promise<void>;
     get currentColorSpace(): ColorSpace;
-
     dispose(): void;
-
     setRenderTarget(renderTarget: RenderTarget | null, activeCubeFace?: number, activeMipmapLevel?: number): void;
-
-    getRenderTarget(): RenderTarget | null;
-
-    setRenderObjectFunction(renderObjectFunction: () => {}): void;
-
-    getRenderObjectFunction(): () => {};
-
-    /**
-     * Runs a compute pipeline
-     */
+    getRenderTarget(): RenderTarget<Texture> | null;
+    setRenderObjectFunction(
+        renderObjectFunction:
+            | ((
+                object: Object3D,
+                scene: Scene,
+                camera: Camera,
+                geometry: BufferGeometry,
+                material: Material,
+                group: GeometryGroup,
+                lightsNode: LightsNode,
+            ) => void)
+            | null,
+    ): void;
+    getRenderObjectFunction():
+        | ((
+            object: Object3D<import("three").Object3DEventMap>,
+            scene: Scene,
+            camera: Camera,
+            geometry: BufferGeometry<import("three").NormalBufferAttributes>,
+            material: Material,
+            group: GeometryGroup,
+            lightsNode: LightsNode,
+        ) => void)
+        | null;
     computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
-
-    hasFeatureAsync(name: string): Promise<boolean>;
-
-    hasFeature(name: string): boolean;
-
+    hasFeatureAsync(name: string): Promise<void>;
+    hasFeature(name: string): false | void;
     copyFramebufferToTexture(framebufferTexture: FramebufferTexture): void;
-
-    copyTextureToTexture(position: Vector2, srcTexture: Texture, dstTexture: Texture, level?: number): void;
-
+    copyTextureToTexture(
+        srcTexture: Texture,
+        dstTexture: Texture,
+        srcRegion?: Box2 | null,
+        dstPosition?: Vector2 | null,
+        level?: number,
+    ): void;
     readRenderTargetPixelsAsync(
         renderTarget: RenderTarget,
         x: number,
@@ -280,19 +239,38 @@ export default class Renderer {
         width: number,
         height: number,
         index?: number,
-    ): Promise<Float32Array | Uint16Array | Uint8Array | Int8Array | Int16Array | Uint32Array | Int32Array>;
-
+    ): Promise<import("three").TypedArray>;
+    _projectObject(object: Object3D, camera: Camera, groupOrder: number, renderList: RenderList): void;
+    _renderBundles(bundles: Bundle[], sceneRef: Scene, lightsNode: LightsNode): void;
+    _renderObjects(renderList: RenderItem[], camera: Camera, scene: Scene, lightsNode: LightsNode): void;
     renderObject(
         object: Object3D,
         scene: Scene,
         camera: Camera,
         geometry: BufferGeometry,
         material: Material,
-        group: Group,
+        group: GeometryGroup,
+        lightsNode: LightsNode,
+    ): void;
+    _renderObjectDirect(
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
+        lightsNode: LightsNode,
+        group: GeometryGroup,
+        passId?: string,
+    ): void;
+    _createObjectPipeline(
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
         lightsNode: LightsNode,
+        group: GeometryGroup,
+        passId?: string,
     ): void;
-
     get compute(): (computeNodes: ComputeNode | ComputeNode[]) => Promise<void>;
-
     get compile(): (scene: Scene, camera: Camera, targetScene?: Scene | null) => Promise<void>;
 }
+export default Renderer;

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

@@ -0,0 +1,27 @@
+import { Texture } from "three";
+import Binding from "./Binding.js";
+
+declare class SampledTexture extends Binding {
+    id: number;
+    texture: Texture | null;
+    version: number;
+    store: boolean;
+    readonly isSampledTexture: true;
+    constructor(name: string, texture: Texture | null);
+    get needsBindingsUpdate(): boolean;
+    update(): boolean;
+}
+
+declare class SampledArrayTexture extends SampledTexture {
+    readonly isSampledArrayTexture: true;
+}
+
+declare class Sampled3DTexture extends SampledTexture {
+    readonly isSampled3DTexture: true;
+}
+
+declare class SampledCubeTexture extends SampledTexture {
+    readonly isSampledCubeTexture: true;
+}
+
+export { Sampled3DTexture, SampledArrayTexture, SampledCubeTexture, SampledTexture };

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

@@ -0,0 +1,11 @@
+import TextureNode from "../../nodes/accessors/TextureNode.js";
+import Binding from "./Binding.js";
+
+declare class Sampler extends Binding {
+    texture: TextureNode | null;
+    version: number;
+    readonly isSampler: true;
+    constructor(name: string, texture: TextureNode | null);
+}
+
+export default Sampler;

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

@@ -0,0 +1,7 @@
+import { BufferAttribute, TypedArray } from "three";
+
+export default class StorageBufferAttribute extends BufferAttribute {
+    readonly isStorageBufferAttribute: true;
+
+    constructor(array: TypedArray, itemSize: number);
+}

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

@@ -0,0 +1,7 @@
+import { InstancedBufferAttribute, TypedArray } from "three";
+
+export default class StorageInstancedBufferAttribute extends InstancedBufferAttribute {
+    readonly isStorageInstancedBufferAttribute: true;
+
+    constructor(array: TypedArray | number, itemSize: number);
+}

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

@@ -0,0 +1,64 @@
+import { DepthTexture, RenderTarget, Texture, Vector3 } from "three";
+import Backend from "./Backend.js";
+import DataMap from "./DataMap.js";
+import Info from "./Info.js";
+import Renderer from "./Renderer.js";
+type SizeVector3Unitialized = Vector3 & {
+    width?: number;
+    height?: number;
+    depth?: number;
+};
+type SizeVector3 = Vector3 & {
+    width: number;
+    height: number;
+    depth: number;
+};
+interface RenderTargetData {
+    depthTextureMips?: {
+        [activeMipmapLevel: number]: DepthTexture;
+    };
+    width?: number;
+    height?: number;
+    textures?: Texture[];
+    depthTexture?: DepthTexture;
+    depth?: boolean;
+    stencil?: boolean;
+    renderTarget?: RenderTarget;
+    sampleCount?: number;
+    initialized?: boolean;
+}
+interface TextureData {
+    initialized?: boolean;
+    version?: number;
+    isDefaultTexture?: boolean;
+}
+interface TextureOptions {
+    width?: number;
+    height?: number;
+    depth?: number;
+    needsMipmaps?: boolean;
+    levels?: number;
+}
+declare class Textures extends DataMap<{
+    renderTarget: {
+        key: RenderTarget;
+        value: RenderTargetData;
+    };
+    texture: {
+        key: Texture;
+        value: TextureData;
+    };
+}> {
+    renderer: Renderer;
+    backend: Backend;
+    info: Info;
+    constructor(renderer: Renderer, backend: Backend, info: Info);
+    updateRenderTarget(renderTarget: RenderTarget, activeMipmapLevel?: number): void;
+    updateTexture(texture: Texture, options?: TextureOptions): void;
+    getSize(texture: Texture, target?: SizeVector3Unitialized): SizeVector3;
+    getMipLevels(texture: Texture, width: number, height: number): number;
+    needsMipmaps(texture: Texture): boolean;
+    isEnvironmentTexture(texture: Texture): boolean;
+    _destroyTexture(texture: Texture): void;
+}
+export default Textures;

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

@@ -0,0 +1,40 @@
+import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from "three";
+declare class Uniform<TValue> {
+    name: string;
+    value: TValue;
+    boundary: number;
+    itemSize: number;
+    offset: number;
+    constructor(name: string, value: TValue);
+    setValue(value: TValue): void;
+    getValue(): TValue;
+}
+declare class NumberUniform extends Uniform<number> {
+    readonly isNumberUniform: true;
+    constructor(name: string, value?: number);
+}
+declare class Vector2Uniform extends Uniform<Vector2> {
+    readonly isVector2Uniform: true;
+    constructor(name: string, value?: Vector2);
+}
+declare class Vector3Uniform extends Uniform<Vector3> {
+    readonly isVector3Uniform: true;
+    constructor(name: string, value?: Vector3);
+}
+declare class Vector4Uniform extends Uniform<Vector4> {
+    readonly isVector4Uniform: true;
+    constructor(name: string, value?: Vector4);
+}
+declare class ColorUniform extends Uniform<Color> {
+    readonly isColorUniform: true;
+    constructor(name: string, value?: Color);
+}
+declare class Matrix3Uniform extends Uniform<Matrix3> {
+    readonly isMatrix3Uniform: true;
+    constructor(name: string, value?: Matrix3);
+}
+declare class Matrix4Uniform extends Uniform<Matrix4> {
+    readonly isMatrix4Uniform: true;
+    constructor(name: string, value?: Matrix4);
+}
+export { ColorUniform, Matrix3Uniform, Matrix4Uniform, NumberUniform, Vector2Uniform, Vector3Uniform, Vector4Uniform };

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

@@ -0,0 +1,6 @@
+import Buffer from "./Buffer.js";
+declare class UniformBuffer extends Buffer {
+    readonly isUniformBuffer: true;
+    constructor(name?: string, buffer?: null);
+}
+export default UniformBuffer;

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

@@ -0,0 +1,32 @@
+import {
+    ColorNodeUniform,
+    Matrix3NodeUniform,
+    Matrix4NodeUniform,
+    NodeUniformGPU,
+    NumberNodeUniform,
+    Vector2NodeUniform,
+    Vector3NodeUniform,
+    Vector4NodeUniform,
+} from "./nodes/NodeUniform.js";
+import UniformBuffer from "./UniformBuffer.js";
+declare class UniformsGroup extends UniformBuffer {
+    readonly isUniformsGroup: true;
+    _values: number[] | null;
+    uniforms: NodeUniformGPU[];
+    constructor(name?: string);
+    addUniform(uniform: NodeUniformGPU): this;
+    removeUniform(uniform: NodeUniformGPU): this;
+    get values(): number[];
+    get buffer(): Float32Array;
+    get byteLength(): number;
+    update(): boolean;
+    updateByType(uniform: NodeUniformGPU): boolean | undefined;
+    updateNumber(uniform: NumberNodeUniform): boolean;
+    updateVector2(uniform: Vector2NodeUniform): boolean;
+    updateVector3(uniform: Vector3NodeUniform): boolean;
+    updateVector4(uniform: Vector4NodeUniform): boolean;
+    updateColor(uniform: ColorNodeUniform): boolean;
+    updateMatrix3(uniform: Matrix3NodeUniform): boolean;
+    updateMatrix4(uniform: Matrix4NodeUniform): boolean;
+}
+export default UniformsGroup;