@types/three 0.164.0 → 0.165.0

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 Binding from "./Binding.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: Binding[] | 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(): Binding[];
+    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;