@needle-tools/three 0.169.12 → 0.169.13

package/types/src/renderers/common/extras/PMREMGenerator.d.ts

@@ -0,0 +1,9 @@
+import { RenderTarget } from "../../../core/RenderTarget.js";
+import { Scene } from "../../../scenes/Scene.js";
+import Renderer from "../Renderer.js";
+
+export default class PMREMGenerator {
+    constructor(renderer: Renderer);
+
+    fromScene(scene: Scene, sigma?: number, near?: number, far?: number): RenderTarget;
+}

package/types/src/renderers/common/nodes/NodeBuilderState.d.ts

@@ -0,0 +1,31 @@
+import NodeMaterialObserver from "../../../materials/nodes/manager/NodeMaterialObserver.js";
+import Node from "../../../nodes/core/Node.js";
+import NodeAttribute from "../../../nodes/core/NodeAttribute.js";
+import BindGroup from "../BindGroup.js";
+declare class NodeBuilderState {
+    vertexShader: string | null;
+    fragmentShader: string | null;
+    computeShader: string | null;
+    transforms: never[];
+    nodeAttributes: NodeAttribute[];
+    bindings: BindGroup[];
+    updateNodes: Node[];
+    updateBeforeNodes: Node[];
+    updateAfterNodes: Node[];
+    monitor: NodeMaterialObserver;
+    usedTimes: number;
+    constructor(
+        vertexShader: string | null,
+        fragmentShader: string | null,
+        computeShader: string | null,
+        nodeAttributes: NodeAttribute[],
+        bindings: BindGroup[],
+        updateNodes: Node[],
+        updateBeforeNodes: Node[],
+        updateAfterNodes: Node[],
+        monitor: NodeMaterialObserver,
+        transforms?: never[],
+    );
+    createBindings(): BindGroup[];
+}
+export default NodeBuilderState;

package/types/src/renderers/common/nodes/NodeLibrary.d.ts

@@ -0,0 +1,56 @@
+import { ToneMapping } from "../../../constants.js";
+import { Light } from "../../../lights/Light.js";
+import { Material } from "../../../materials/Material.js";
+import NodeMaterial from "../../../materials/nodes/NodeMaterial.js";
+import Node from "../../../nodes/core/Node.js";
+import { ColorSpaceMethod } from "../../../nodes/display/ColorSpaceNode.js";
+import AnalyticLightNode from "../../../nodes/lighting/AnalyticLightNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../../../nodes/tsl/TSLCore.js";
+declare class NodeLibrary {
+    lightNodes: WeakMap<{
+        new(): Light;
+    }, {
+        new(light: Light): AnalyticLightNode<Light>;
+    }>;
+    materialNodes: Map<string, {
+        new(): NodeMaterial;
+    }>;
+    toneMappingNodes: Map<
+        ToneMapping,
+        (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>
+    >;
+    colorSpaceNodes: Map<ColorSpaceMethod, (color: NodeRepresentation) => ShaderNodeObject<Node>>;
+    constructor();
+    fromMaterial(material: Material): Material | null;
+    addColorSpace(
+        colorSpaceNode: (color: NodeRepresentation) => ShaderNodeObject<Node>,
+        colorSpace: ColorSpaceMethod,
+    ): void;
+    getColorSpaceFunction(colorSpace: ColorSpaceMethod): ((color: NodeRepresentation) => ShaderNodeObject<Node>) | null;
+    addToneMapping(
+        toneMappingNode: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>,
+        toneMapping: ToneMapping,
+    ): void;
+    getToneMappingFunction(
+        toneMapping: ToneMapping,
+    ): ((color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>) | null;
+    getMaterialNodeClass(materialType: string): (new() => NodeMaterial) | null;
+    addMaterial(materialNodeClass: {
+        new(): NodeMaterial;
+    }, materialClass: {
+        new(): Material;
+    }): void;
+    getLightNodeClass(light: Light): (new(light: Light) => AnalyticLightNode<Light>) | null;
+    addLight<TLight extends Light>(lightNodeClass: {
+        new(light: TLight): AnalyticLightNode<TLight>;
+    }, lightClass: {
+        new(): TLight;
+    }): void;
+    addType<TNodeClass, TType>(nodeClass: TNodeClass, type: TType, library: Map<TType, TNodeClass>): void;
+    addClass<TNodeClass, TBaseClass extends object>(
+        nodeClass: TNodeClass,
+        baseClass: TBaseClass,
+        library: WeakMap<TBaseClass, TNodeClass>,
+    ): void;
+}
+export default NodeLibrary;

package/types/src/renderers/common/nodes/NodeSampledTexture.d.ts

@@ -0,0 +1,29 @@
+import TextureNode from "../../../nodes/accessors/TextureNode.js";
+import UniformGroupNode from "../../../nodes/core/UniformGroupNode.js";
+import { SampledTexture } from "../SampledTexture.js";
+
+type GPUStorageTextureAccess = "read-only" | "read-write" | "write-only";
+
+declare class NodeSampledTexture extends SampledTexture {
+    textureNode: TextureNode | undefined;
+    groupNode: UniformGroupNode;
+
+    access: "read-write" | "read-only" | "write-only";
+
+    constructor(
+        name: string,
+        textureNode: TextureNode | undefined,
+        groupNode: UniformGroupNode,
+        access?: GPUStorageTextureAccess | null,
+    );
+}
+
+declare class NodeSampledCubeTexture extends NodeSampledTexture {
+    readonly isSampledCubeTexture: true;
+}
+
+declare class NodeSampledTexture3D extends NodeSampledTexture {
+    readonly isSampledTexture3D = true;
+}
+
+export { NodeSampledCubeTexture, NodeSampledTexture, NodeSampledTexture3D };

package/types/src/renderers/common/nodes/NodeSampler.d.ts

@@ -0,0 +1,12 @@
+import TextureNode from "../../../nodes/accessors/TextureNode.js";
+import UniformGroupNode from "../../../nodes/core/UniformGroupNode.js";
+import Sampler from "../Sampler.js";
+
+declare class NodeSampler extends Sampler {
+    textureNode: TextureNode | undefined;
+    groupNode: UniformGroupNode;
+    constructor(name: string, textureNode: TextureNode | undefined, groupNode: UniformGroupNode);
+    update(): void;
+}
+
+export default NodeSampler;

package/types/src/renderers/common/nodes/NodeUniform.d.ts

@@ -0,0 +1,68 @@
+import { Color } from "../../../math/Color.js";
+import { Matrix3 } from "../../../math/Matrix3.js";
+import { Matrix4 } from "../../../math/Matrix4.js";
+import { Vector2 } from "../../../math/Vector2.js";
+import { Vector3 } from "../../../math/Vector3.js";
+import { Vector4 } from "../../../math/Vector4.js";
+import NodeUniform from "../../../nodes/core/NodeUniform.js";
+import {
+    ColorUniform,
+    Matrix3Uniform,
+    Matrix4Uniform,
+    NumberUniform,
+    Vector2Uniform,
+    Vector3Uniform,
+    Vector4Uniform,
+} from "../Uniform.js";
+declare class NumberNodeUniform extends NumberUniform {
+    nodeUniform: NodeUniform<number>;
+    constructor(nodeUniform: NodeUniform<number>);
+    getValue(): number;
+}
+declare class Vector2NodeUniform extends Vector2Uniform {
+    nodeUniform: NodeUniform<Vector2>;
+    constructor(nodeUniform: NodeUniform<Vector2>);
+    getValue(): Vector2;
+}
+declare class Vector3NodeUniform extends Vector3Uniform {
+    nodeUniform: NodeUniform<Vector3>;
+    constructor(nodeUniform: NodeUniform<Vector3>);
+    getValue(): Vector3;
+}
+declare class Vector4NodeUniform extends Vector4Uniform {
+    nodeUniform: NodeUniform<Vector4>;
+    constructor(nodeUniform: NodeUniform<Vector4>);
+    getValue(): Vector4;
+}
+declare class ColorNodeUniform extends ColorUniform {
+    nodeUniform: NodeUniform<Color>;
+    constructor(nodeUniform: NodeUniform<Color>);
+    getValue(): Color;
+}
+declare class Matrix3NodeUniform extends Matrix3Uniform {
+    nodeUniform: NodeUniform<Matrix3>;
+    constructor(nodeUniform: NodeUniform<Matrix3>);
+    getValue(): Matrix3;
+}
+declare class Matrix4NodeUniform extends Matrix4Uniform {
+    nodeUniform: NodeUniform<Matrix4>;
+    constructor(nodeUniform: NodeUniform<Matrix4>);
+    getValue(): Matrix4;
+}
+export {
+    ColorNodeUniform,
+    Matrix3NodeUniform,
+    Matrix4NodeUniform,
+    NumberNodeUniform,
+    Vector2NodeUniform,
+    Vector3NodeUniform,
+    Vector4NodeUniform,
+};
+export type NodeUniformGPU =
+    | NumberNodeUniform
+    | Vector2NodeUniform
+    | Vector3NodeUniform
+    | Vector4NodeUniform
+    | ColorNodeUniform
+    | Matrix3NodeUniform
+    | Matrix4NodeUniform;

package/types/src/renderers/common/nodes/NodeUniformsGroup.d.ts

@@ -0,0 +1,10 @@
+import { UniformGroupNode, UniformNode } from "../../../nodes/Nodes.js";
+import UniformsGroup from "../UniformsGroup.js";
+declare class NodeUniformsGroup extends UniformsGroup {
+    id: number;
+    groupNode: UniformGroupNode;
+    readonly isNodeUniformsGroup: true;
+    constructor(name: string, groupNode: UniformGroupNode);
+    getNodes(): UniformNode<unknown>[];
+}
+export default NodeUniformsGroup;

package/types/src/renderers/common/nodes/Nodes.d.ts

@@ -0,0 +1,114 @@
+import { Camera } from "../../../cameras/Camera.js";
+import { Object3D } from "../../../core/Object3D.js";
+import { Material } from "../../../materials/Material.js";
+import { Color } from "../../../math/Color.js";
+import Node from "../../../nodes/core/Node.js";
+import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
+import UniformGroupNode from "../../../nodes/core/UniformGroupNode.js";
+import ComputeNode from "../../../nodes/gpgpu/ComputeNode.js";
+import LightsNode from "../../../nodes/lighting/LightsNode.js";
+import { NodeFrame } from "../../../nodes/Nodes.js";
+import { ShaderNodeObject } from "../../../nodes/TSL.js";
+import { Fog } from "../../../scenes/Fog.js";
+import { FogExp2 } from "../../../scenes/FogExp2.js";
+import { Scene } from "../../../scenes/Scene.js";
+import { CubeTexture } from "../../../textures/CubeTexture.js";
+import { Texture } from "../../../textures/Texture.js";
+import Backend from "../Backend.js";
+import ChainMap from "../ChainMap.js";
+import DataMap from "../DataMap.js";
+import Renderer from "../Renderer.js";
+import RenderObject from "../RenderObject.js";
+import NodeBuilderState from "./NodeBuilderState.js";
+import NodeUniformsGroup from "./NodeUniformsGroup.js";
+interface NodeUniformsGroupData {
+    renderId?: number | undefined;
+    frameId?: number | undefined;
+}
+interface RenderObjectData {
+    nodeBuilderState?: NodeBuilderState | undefined;
+}
+interface ComputeNodeData {
+    nodeBuilderState?: NodeBuilderState | undefined;
+}
+interface SceneData {
+    background?: Color | Texture | CubeTexture | undefined;
+    backgroundNode?: Node | undefined;
+    fog?: Fog | FogExp2 | undefined;
+    fogNode?: Node | undefined;
+    environment?: Texture | undefined;
+    environmentNode?: Node | undefined;
+}
+declare module "../../../scenes/Scene.js" {
+    interface Scene {
+        environmentNode?: Node | null | undefined;
+        backgroundNode?: Node | null | undefined;
+        fogNode?: Node | null | undefined;
+    }
+}
+declare class Nodes extends DataMap<{
+    nodeUniformsGroup: {
+        key: NodeUniformsGroup;
+        value: NodeUniformsGroupData;
+    };
+    renderObject: {
+        key: RenderObject;
+        value: RenderObjectData;
+    };
+    computeNode: {
+        key: ComputeNode;
+        value: ComputeNodeData;
+    };
+    scene: {
+        key: Scene;
+        value: SceneData;
+    };
+}> {
+    renderer: Renderer;
+    backend: Backend;
+    nodeFrame: NodeFrame;
+    nodeBuilderCache: Map<string, NodeBuilderState>;
+    callHashCache: ChainMap<readonly [Scene, LightsNode], {
+        callId: number;
+        cacheKey: string;
+    }>;
+    groupsData: ChainMap<readonly [UniformGroupNode, NodeUniformsGroup], {
+        version?: number;
+    }>;
+    constructor(renderer: Renderer, backend: Backend);
+    updateGroup(nodeUniformsGroup: NodeUniformsGroup): boolean;
+    getForRenderCacheKey(renderObject: RenderObject): string;
+    getForRender(renderObject: RenderObject): NodeBuilderState;
+    delete(
+        object: NodeUniformsGroup | RenderObject | ComputeNode | Scene,
+    ): SceneData | RenderObjectData | NodeUniformsGroupData | ComputeNodeData;
+    getForCompute(computeNode: ComputeNode): NodeBuilderState;
+    _createNodeBuilderState(nodeBuilder: NodeBuilder): NodeBuilderState;
+    getEnvironmentNode(scene: Scene): Node | null;
+    getBackgroundNode(scene: Scene): Node | null;
+    getFogNode(scene: Scene): Node | null;
+    getCacheKey(scene: Scene, lightsNode: LightsNode): string;
+    updateScene(scene: Scene): void;
+    get isToneMappingState(): boolean;
+    updateBackground(scene: Scene): void;
+    updateFog(scene: Scene): void;
+    updateEnvironment(scene: Scene): void;
+    getNodeFrame(
+        renderer?: Renderer,
+        scene?: Scene | null,
+        object?: Object3D | null,
+        camera?: Camera | null,
+        material?: Material | null,
+    ): NodeFrame;
+    getNodeFrameForRender(renderObject: RenderObject): NodeFrame;
+    getOutputCacheKey(): string;
+    hasOutputChange(outputTarget: Texture): boolean;
+    getOutputNode(outputTexture: Texture): ShaderNodeObject<Node>;
+    updateBefore(renderObject: RenderObject): void;
+    updateAfter(renderObject: RenderObject): void;
+    updateForCompute(computeNode: ComputeNode): void;
+    updateForRender(renderObject: RenderObject): void;
+    needsRefresh(renderObject: RenderObject): boolean;
+    dispose(): void;
+}
+export default Nodes;

package/types/src/renderers/common/nodes/StandardNodeLibrary.d.ts

@@ -0,0 +1,5 @@
+import NodeLibrary from "./NodeLibrary.js";
+declare class StandardNodeLibrary extends NodeLibrary {
+    constructor();
+}
+export default StandardNodeLibrary;

package/types/src/renderers/shaders/ShaderChunk.d.ts

@@ -0,0 +1,143 @@
+// Renderers / Shaders /////////////////////////////////////////////////////////////////////
+export const ShaderChunk: {
+    alphahash_fragment: string;
+    alphahash_pars_fragment: string;
+    alphamap_fragment: string;
+    alphamap_pars_fragment: string;
+    alphatest_fragment: string;
+    alphatest_pars_fragment: string;
+    aomap_fragment: string;
+    aomap_pars_fragment: string;
+    batching_pars_vertex: string;
+    begin_vertex: string;
+    beginnormal_vertex: string;
+    bsdfs: string;
+    iridescence_fragment: string;
+    bumpmap_pars_fragment: string;
+    clipping_planes_fragment: string;
+    clipping_planes_pars_fragment: string;
+    clipping_planes_pars_vertex: string;
+    clipping_planes_vertex: string;
+    color_fragment: string;
+    color_pars_fragment: string;
+    color_pars_vertex: string;
+    color_vertex: string;
+    common: string;
+    cube_uv_reflection_fragment: string;
+    defaultnormal_vertex: string;
+    displacementmap_pars_vertex: string;
+    displacementmap_vertex: string;
+    emissivemap_fragment: string;
+    emissivemap_pars_fragment: string;
+    colorspace_fragment: string;
+    colorspace_pars_fragment: string;
+    envmap_fragment: string;
+    envmap_common_pars_fragment: string;
+    envmap_pars_fragment: string;
+    envmap_pars_vertex: string;
+    envmap_physical_pars_fragment: string;
+    envmap_vertex: string;
+    fog_vertex: string;
+    fog_pars_vertex: string;
+    fog_fragment: string;
+    fog_pars_fragment: string;
+    gradientmap_pars_fragment: string;
+    lightmap_pars_fragment: string;
+    lights_lambert_fragment: string;
+    lights_lambert_pars_fragment: string;
+    lights_pars_begin: string;
+    lights_toon_fragment: string;
+    lights_toon_pars_fragment: string;
+    lights_phong_fragment: string;
+    lights_phong_pars_fragment: string;
+    lights_physical_fragment: string;
+    lights_physical_pars_fragment: string;
+    lights_fragment_begin: string;
+    lights_fragment_maps: string;
+    lights_fragment_end: string;
+    logdepthbuf_fragment: string;
+    logdepthbuf_pars_fragment: string;
+    logdepthbuf_pars_vertex: string;
+    logdepthbuf_vertex: string;
+    map_fragment: string;
+    map_pars_fragment: string;
+    map_particle_fragment: string;
+    map_particle_pars_fragment: string;
+    metalnessmap_fragment: string;
+    metalnessmap_pars_fragment: string;
+    morphcolor_vertex: string;
+    morphnormal_vertex: string;
+    morphtarget_pars_vertex: string;
+    morphtarget_vertex: string;
+    normal_fragment_begin: string;
+    normal_fragment_maps: string;
+    normal_pars_fragment: string;
+    normal_pars_vertex: string;
+    normal_vertex: string;
+    normalmap_pars_fragment: string;
+    clearcoat_normal_fragment_begin: string;
+    clearcoat_normal_fragment_maps: string;
+    clearcoat_pars_fragment: string;
+    iridescence_pars_fragment: string;
+    opaque_fragment: string;
+    packing: string;
+    premultiplied_alpha_fragment: string;
+    project_vertex: string;
+    dithering_fragment: string;
+    dithering_pars_fragment: string;
+    roughnessmap_fragment: string;
+    roughnessmap_pars_fragment: string;
+    shadowmap_pars_fragment: string;
+    shadowmap_pars_vertex: string;
+    shadowmap_vertex: string;
+    shadowmask_pars_fragment: string;
+    skinbase_vertex: string;
+    skinning_pars_vertex: string;
+    skinning_vertex: string;
+    skinnormal_vertex: string;
+    specularmap_fragment: string;
+    specularmap_pars_fragment: string;
+    tonemapping_fragment: string;
+    tonemapping_pars_fragment: string;
+    transmission_fragment: string;
+    transmission_pars_fragment: string;
+    uv_pars_fragment: string;
+    uv_pars_vertex: string;
+    uv_vertex: string;
+    worldpos_vertex: string;
+
+    background_vert: string;
+    background_frag: string;
+    backgroundCube_vert: string;
+    backgroundCube_frag: string;
+    cube_vert: string;
+    cube_frag: string;
+    depth_vert: string;
+    depth_frag: string;
+    distanceRGBA_vert: string;
+    distanceRGBA_frag: string;
+    equirect_vert: string;
+    equirect_frag: string;
+    linedashed_vert: string;
+    linedashed_frag: string;
+    meshbasic_vert: string;
+    meshbasic_frag: string;
+    meshlambert_vert: string;
+    meshlambert_frag: string;
+    meshmatcap_vert: string;
+    meshmatcap_frag: string;
+    meshnormal_vert: string;
+    meshnormal_frag: string;
+    meshphong_vert: string;
+    meshphong_frag: string;
+    meshphysical_vert: string;
+    meshphysical_frag: string;
+    meshtoon_vert: string;
+    meshtoon_frag: string;
+    points_vert: string;
+    points_frag: string;
+    shadow_vert: string;
+    shadow_frag: string;
+    sprite_vert: string;
+    sprite_frag: string;
+};

package/types/src/renderers/shaders/ShaderLib.d.ts

@@ -0,0 +1,29 @@
+import { IUniform } from "./UniformsLib.js";
+
+export interface ShaderLibShader {
+    uniforms: { [uniform: string]: IUniform };
+    vertexShader: string;
+    fragmentShader: string;
+}
+
+declare const ShaderLib: {
+    [name: string]: ShaderLibShader;
+    basic: ShaderLibShader;
+    lambert: ShaderLibShader;
+    phong: ShaderLibShader;
+    standard: ShaderLibShader;
+    matcap: ShaderLibShader;
+    points: ShaderLibShader;
+    dashed: ShaderLibShader;
+    depth: ShaderLibShader;
+    normal: ShaderLibShader;
+    sprite: ShaderLibShader;
+    background: ShaderLibShader;
+    cube: ShaderLibShader;
+    equirect: ShaderLibShader;
+    distanceRGBA: ShaderLibShader;
+    shadow: ShaderLibShader;
+    physical: ShaderLibShader;
+};
+
+export { ShaderLib };