@needle-tools/three 0.169.12 → 0.169.13

package/types/examples/jsm/objects/Water2.d.ts

@@ -0,0 +1,21 @@
+import { BufferGeometry, ColorRepresentation, Mesh, ShaderMaterial, Texture, Vector2 } from "three";
+
+export interface WaterOptions {
+    color?: ColorRepresentation | undefined;
+    textureWidth?: number | undefined;
+    textureHeight?: number | undefined;
+    clipBias?: number | undefined;
+    flowDirection?: Vector2 | undefined;
+    flowSpeed?: number | undefined;
+    reflectivity?: number | undefined;
+    scale?: number | undefined;
+    shader?: object | undefined;
+    flowMap?: Texture | undefined;
+    normalMap0?: Texture | undefined;
+    normalMap1?: Texture | undefined;
+}
+
+export class Water extends Mesh {
+    material: ShaderMaterial;
+    constructor(geometry: BufferGeometry, options: WaterOptions);
+}

package/types/examples/jsm/objects/Water2Mesh.d.ts

@@ -0,0 +1,42 @@
+import { TempNode, TextureNode, UniformNode, Vector2, Vector3 } from "three/tsl";
+import { BufferGeometry, Color, ColorRepresentation, Mesh, NodeMaterial, Texture } from "three/webgpu";
+
+export interface WaterMeshOptions {
+    normalMap0: Texture;
+    normalMap1: Texture;
+    flowMap?: Texture | null | undefined;
+
+    color?: ColorRepresentation | undefined;
+    flowDirection?: Vector2 | undefined;
+    flowSpeed?: number | undefined;
+    reflectivity?: number | undefined;
+    scale?: number | undefined;
+}
+
+declare class WaterMesh extends Mesh<BufferGeometry, NodeMaterial> {
+    readonly isWater: true;
+
+    constructor(geometry: BufferGeometry, options: WaterMeshOptions);
+}
+
+declare class WaterNode extends TempNode {
+    waterBody: WaterMesh;
+
+    normalMap0: TextureNode;
+    normalMap1: TextureNode;
+    flowMap: TextureNode;
+
+    color: UniformNode<Color>;
+    flowDirection: UniformNode<Vector2>;
+    flowSpeed: UniformNode<number>;
+    reflectivity: UniformNode<number>;
+    scale: UniformNode<number>;
+    flowConfig: UniformNode<Vector3>;
+
+    constructor(options: WaterMeshOptions, waterBody: WaterMesh);
+
+    updateFlow(delta: number): void;
+}
+
+export { WaterMesh };
+export type { WaterNode };

package/types/examples/jsm/objects/WaterMesh.d.ts

@@ -0,0 +1,31 @@
+import { TextureNode, UniformNode } from "three/tsl";
+import { BufferGeometry, Color, ColorRepresentation, Mesh, NodeMaterial, Texture, Vector3 } from "three/webgpu";
+
+export interface WaterMeshOptions {
+    resolution?: number | undefined;
+    waterNormals: Texture;
+    alpha?: number | undefined;
+    size?: number | undefined;
+    sunColor?: ColorRepresentation | undefined;
+    sunDirection?: Vector3 | undefined;
+    waterColor?: ColorRepresentation | undefined;
+    distortionScale?: number | undefined;
+}
+
+declare class WaterMesh extends Mesh<BufferGeometry, NodeMaterial> {
+    readonly isWater: true;
+
+    resolution: number;
+
+    waterNormals: TextureNode;
+    alpha: UniformNode<number>;
+    size: UniformNode<number>;
+    sunColor: UniformNode<Color>;
+    sunDirection: UniformNode<Vector3>;
+    waterColor: UniformNode<Color>;
+    distortionScale: UniformNode<number>;
+
+    constructor(geometry: BufferGeometry, options: WaterMeshOptions);
+}
+
+export { WaterMesh };

package/types/examples/jsm/physics/AmmoPhysics.d.ts

@@ -0,0 +1,9 @@
+import { Mesh, Object3D, Vector3 } from "three";
+
+export interface AmmoPhysicsObject {
+    addScene: (scene: Object3D) => void;
+    addMesh: (mesh: Mesh, mass?: number) => void;
+    setMeshPosition: (mesh: Mesh, position: Vector3, index?: number) => void;
+}
+
+export function AmmoPhysics(): Promise<AmmoPhysicsObject>;

package/types/examples/jsm/physics/JoltPhysics.d.ts

@@ -0,0 +1,10 @@
+import { Mesh, Object3D, Vector3Like } from "three";
+
+export interface JoltPhysicsObject {
+    addScene: (scene: Object3D) => void;
+    addMesh: (mesh: Mesh, mass?: number, restitution?: number) => void;
+    setMeshPosition: (mesh: Mesh, position: Vector3Like, index?: number) => void;
+    setMeshVelocity: (mesh: Mesh, velocity: Vector3Like, index?: number) => void;
+}
+
+export function JoltPhysics(): Promise<JoltPhysicsObject>;

package/types/examples/jsm/physics/RapierPhysics.d.ts

@@ -0,0 +1,12 @@
+import { Mesh, Object3D } from "three";
+
+type Vector = { x: number; y: number; z: number };
+
+export interface RapierPhysicsObject {
+    addScene: (scene: Object3D) => void;
+    addMesh: (mesh: Mesh, mass?: number, restitution?: number) => void;
+    setMeshPosition: (mesh: Mesh, position: Vector, index?: number) => void;
+    setMeshVelocity: (mesh: Mesh, velocity: Vector, index?: number) => void;
+}
+
+export function RapierPhysics(): Promise<RapierPhysicsObject>;

package/types/examples/jsm/postprocessing/AfterimagePass.d.ts

@@ -0,0 +1,14 @@
+import { IUniform, ShaderMaterial, WebGLRenderTarget } from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export class AfterimagePass extends Pass {
+    constructor(damp?: number);
+    shader: object;
+    uniforms: Record<string, IUniform>;
+    textureComp: WebGLRenderTarget;
+    textureOld: WebGLRenderTarget;
+    shaderMaterial: ShaderMaterial;
+    compFsQuad: FullScreenQuad;
+    copyFsQuad: FullScreenQuad;
+}

package/types/examples/jsm/postprocessing/BloomPass.d.ts

@@ -0,0 +1,14 @@
+import { ShaderMaterial, WebGLRenderTarget } from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export class BloomPass extends Pass {
+    constructor(strength?: number, kernelSize?: number, sigma?: number);
+    renderTargetX: WebGLRenderTarget;
+    renderTargetY: WebGLRenderTarget;
+    copyUniforms: object;
+    materialCopy: ShaderMaterial;
+    convolutionUniforms: object;
+    materialConvolution: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+}

package/types/examples/jsm/postprocessing/BokehPass.d.ts

@@ -0,0 +1,23 @@
+import { Camera, Color, MeshDepthMaterial, Scene, ShaderMaterial, WebGLRenderTarget } from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export interface BokehPassParamters {
+    focus?: number;
+    aspect?: number;
+    aperture?: number;
+    maxblur?: number;
+}
+
+export class BokehPass extends Pass {
+    constructor(scene: Scene, camera: Camera, params: BokehPassParamters);
+    scene: Scene;
+    camera: Camera;
+    renderTargetColor: WebGLRenderTarget;
+    renderTargetDepth: WebGLRenderTarget;
+    materialDepth: MeshDepthMaterial;
+    materialBokeh: ShaderMaterial;
+    uniforms: object;
+    fsQuad: FullScreenQuad;
+    oldClearColor: Color;
+}

package/types/examples/jsm/postprocessing/ClearPass.d.ts

@@ -0,0 +1,9 @@
+import { ColorRepresentation } from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export class ClearPass extends Pass {
+    constructor(clearColor?: ColorRepresentation, clearAlpha?: number);
+    clearColor: ColorRepresentation;
+    clearAlpha: number;
+}

package/types/examples/jsm/postprocessing/CubeTexturePass.d.ts

@@ -0,0 +1,14 @@
+import { CubeTexture, Mesh, PerspectiveCamera, Scene } from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export class CubeTexturePass extends Pass {
+    constructor(camera: PerspectiveCamera, envMap?: CubeTexture, opacity?: number);
+    camera: PerspectiveCamera;
+    cubeShader: object;
+    cubeMesh: Mesh;
+    envMap: CubeTexture;
+    opacity: number;
+    cubeScene: Scene;
+    cubeCamera: PerspectiveCamera;
+}

package/types/examples/jsm/postprocessing/DotScreenPass.d.ts

@@ -0,0 +1,10 @@
+import { ShaderMaterial, Vector2 } from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export class DotScreenPass extends Pass {
+    constructor(center?: Vector2, angle?: number, scale?: number);
+    uniforms: object;
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+}

package/types/examples/jsm/postprocessing/EffectComposer.d.ts

@@ -0,0 +1,31 @@
+import { Clock, WebGLRenderer, WebGLRenderTarget } from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+import { ShaderPass } from "./ShaderPass.js";
+
+export { FullScreenQuad } from "./Pass.js";
+export { Pass };
+
+export class EffectComposer {
+    constructor(renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget);
+    renderer: WebGLRenderer;
+    renderTarget1: WebGLRenderTarget;
+    renderTarget2: WebGLRenderTarget;
+    writeBuffer: WebGLRenderTarget;
+    readBuffer: WebGLRenderTarget;
+    passes: Pass[];
+    copyPass: ShaderPass;
+    clock: Clock;
+    renderToScreen: boolean;
+
+    swapBuffers(): void;
+    addPass(pass: Pass): void;
+    insertPass(pass: Pass, index: number): void;
+    removePass(pass: Pass): void;
+    isLastEnabledPass(passIndex: number): boolean;
+    render(deltaTime?: number): void;
+    reset(renderTarget?: WebGLRenderTarget): void;
+    setSize(width: number, height: number): void;
+    setPixelRatio(pixelRatio: number): void;
+    dispose(): void;
+}

package/types/examples/jsm/postprocessing/FilmPass.d.ts

@@ -0,0 +1,10 @@
+import { ShaderMaterial } from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export class FilmPass extends Pass {
+    constructor(intensity?: number, grayscale?: boolean);
+    uniforms: object;
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+}

package/types/examples/jsm/postprocessing/GTAOPass.d.ts

@@ -0,0 +1,121 @@
+import {
+    Box3,
+    Camera,
+    Color,
+    ColorRepresentation,
+    DataTexture,
+    DepthTexture,
+    MeshNormalMaterial,
+    Scene,
+    ShaderMaterial,
+    Texture,
+    WebGLRenderer,
+    WebGLRenderTarget,
+} from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export class GTAOPass extends Pass {
+    width: number;
+    height: number;
+    clear: boolean;
+    camera: Camera;
+    scene: Scene;
+    output: number;
+    blendIntensity: number;
+
+    pdRings: number;
+    pdRadiusExponent: number;
+    pdSamples: number;
+
+    gtaoNoiseTexture: DataTexture;
+    pdNoiseTexture: DataTexture;
+
+    gtaoRenderTarget: WebGLRenderTarget;
+    pdRenderTarget: WebGLRenderTarget;
+
+    gtaoMaterial: ShaderMaterial;
+
+    normalMaterial: MeshNormalMaterial;
+
+    pdMaterial: ShaderMaterial;
+
+    depthRenderMaterial: ShaderMaterial;
+
+    copyMaterial: ShaderMaterial;
+
+    blendMaterial: ShaderMaterial;
+
+    fsQuad: FullScreenQuad;
+
+    originalClearColor: Color;
+
+    depthTexture: DepthTexture;
+    normalTexture: Texture;
+
+    constructor(
+        scene: Scene,
+        camera: Camera,
+        width?: number | undefined,
+        height?: number | undefined,
+        parameters?: { depthTexture?: DepthTexture | undefined; normalTexture?: Texture | undefined } | undefined,
+    );
+
+    get gtaoMap(): Texture;
+
+    setGBuffer(depthTexture?: DepthTexture | undefined, normalTexture?: Texture | undefined): void;
+
+    setSceneClipBox(box: Box3): void;
+
+    updateGtaoMaterial(parameters: {
+        radius?: number | undefined;
+        distanceExponent?: number | undefined;
+        thickness?: number | undefined;
+        distanceFallOff?: number | undefined;
+        scale?: number | undefined;
+        samples?: number | undefined;
+        screenSpaceRadius?: boolean | undefined;
+    }): void;
+
+    updatePdMaterial(parameters: {
+        lumaPhi?: number | undefined;
+        depthPhi?: number | undefined;
+        normalPhi?: number | undefined;
+        radius?: number | undefined;
+        radiusExponent?: number | undefined;
+        rings?: number | undefined;
+        samples?: number | undefined;
+    }): void;
+
+    renderPass(
+        renderer: WebGLRenderer,
+        passMaterial: ShaderMaterial,
+        renderTarget: WebGLRenderTarget | null,
+        clearColor?: ColorRepresentation | undefined,
+        clearAlpha?: number | undefined,
+    ): void;
+
+    renderOverride(
+        renderer: WebGLRenderer,
+        overrideMaterial: MeshNormalMaterial,
+        renderTarget: WebGLRenderTarget | null,
+        clearColor?: ColorRepresentation | undefined,
+        clearAlpha?: number | undefined,
+    ): void;
+
+    overrideVisibility(): void;
+
+    restoreVisibility(): void;
+
+    generateNoise(size?: number): DataTexture;
+
+    static OUTPUT: {
+        Off: -1;
+        Default: 0;
+        Diffuse: 1;
+        Depth: 2;
+        Normal: 3;
+        AO: 4;
+        Denoise: 5;
+    };
+}

package/types/examples/jsm/postprocessing/GlitchPass.d.ts

@@ -0,0 +1,16 @@
+import { DataTexture, ShaderMaterial } from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export class GlitchPass extends Pass {
+    constructor(dt_size?: number);
+    uniforms: object;
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+    goWild: boolean;
+    curF: number;
+    randX: number;
+
+    generateTrigger(): void;
+    generateHeightmap(dt_size: number): DataTexture;
+}

package/types/examples/jsm/postprocessing/HalftonePass.d.ts

@@ -0,0 +1,37 @@
+import { IUniform, ShaderMaterial } from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export interface HalftonePassParameters {
+    shape?: number;
+    radius?: number;
+    rotateR?: number;
+    rotateB?: number;
+    rotateG?: number;
+    scatter?: number;
+    blending?: number;
+    blendingMode?: number;
+    greyscale?: boolean;
+    disable?: boolean;
+}
+
+export class HalftonePass extends Pass {
+    constructor(width: number, height: number, params: HalftonePassParameters);
+    uniforms: {
+        tDiffuse: IUniform;
+        shape: IUniform<number>;
+        radius: IUniform<number>;
+        rotateR: IUniform<number>;
+        rotateG: IUniform<number>;
+        rotateB: IUniform<number>;
+        scatter: IUniform<number>;
+        width: IUniform<number>;
+        height: IUniform<number>;
+        blending: IUniform<number>;
+        blendingMode: IUniform<number>;
+        greyscale: IUniform<boolean>;
+        disable: IUniform<boolean>;
+    };
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+}

package/types/examples/jsm/postprocessing/LUTPass.d.ts

@@ -0,0 +1,13 @@
+import { Data3DTexture, DataTexture } from "three";
+import { ShaderPass } from "./ShaderPass.js";
+
+export interface LUTPassParameters {
+    lut?: DataTexture | Data3DTexture;
+    intensity?: number;
+}
+
+export class LUTPass extends ShaderPass {
+    lut?: DataTexture | Data3DTexture;
+    intensity?: number;
+    constructor(params: LUTPassParameters);
+}

package/types/examples/jsm/postprocessing/MaskPass.d.ts

@@ -0,0 +1,14 @@
+import { Camera, Scene } from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export class MaskPass extends Pass {
+    constructor(scene: Scene, camera: Camera);
+    scene: Scene;
+    camera: Camera;
+    inverse: boolean;
+}
+
+export class ClearMaskPass extends Pass {
+    constructor();
+}

package/types/examples/jsm/postprocessing/OutlinePass.d.ts

@@ -0,0 +1,64 @@
+import {
+    Camera,
+    Color,
+    Matrix4,
+    MeshBasicMaterial,
+    MeshDepthMaterial,
+    Object3D,
+    Scene,
+    ShaderMaterial,
+    Texture,
+    Vector2,
+    WebGLRenderTarget,
+} from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export class OutlinePass extends Pass {
+    constructor(resolution: Vector2, scene: Scene, camera: Camera, selectedObjects?: Object3D[]);
+    renderScene: Scene;
+    renderCamera: Camera;
+    selectedObjects: Object3D[];
+    visibleEdgeColor: Color;
+    hiddenEdgeColor: Color;
+    edgeGlow: number;
+    usePatternTexture: boolean;
+    edgeThickness: number;
+    edgeStrength: number;
+    downSampleRatio: number;
+    pulsePeriod: number;
+    resolution: Vector2;
+    patternTexture: Texture;
+
+    maskBufferMaterial: MeshBasicMaterial;
+    renderTargetMaskBuffer: WebGLRenderTarget;
+    depthMaterial: MeshDepthMaterial;
+    prepareMaskMaterial: ShaderMaterial;
+    renderTargetDepthBuffer: WebGLRenderTarget;
+    renderTargetMaskDownSampleBuffer: WebGLRenderTarget;
+    renderTargetBlurBuffer1: WebGLRenderTarget;
+    renderTargetBlurBuffer2: WebGLRenderTarget;
+    edgeDetectionMaterial: ShaderMaterial;
+    renderTargetEdgeBuffer1: WebGLRenderTarget;
+    renderTargetEdgeBuffer2: WebGLRenderTarget;
+    separableBlurMaterial1: ShaderMaterial;
+    separableBlurMaterial2: ShaderMaterial;
+    overlayMaterial: ShaderMaterial;
+    copyUniforms: object;
+    materialCopy: ShaderMaterial;
+    oldClearColor: Color;
+    oldClearAlpha: number;
+    fsQuad: FullScreenQuad;
+    tempPulseColor1: Color;
+    tempPulseColor2: Color;
+    textureMatrix: Matrix4;
+
+    updateSelectionCache(): void;
+    changeVisibilityOfSelectedObjects(bVisible: boolean): void;
+    changeVisibilityOfNonSelectedObjects(bVisible: boolean): void;
+    updateTextureMatrix(): void;
+    getPrepareMaskMaterial(): ShaderMaterial;
+    getEdgeDetectionMaterial(): ShaderMaterial;
+    getSeperableBlurMaterial(): ShaderMaterial;
+    getOverlayMaterial(): ShaderMaterial;
+}

package/types/examples/jsm/postprocessing/OutputPass.d.ts

@@ -0,0 +1,10 @@
+import { ShaderMaterial } from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export class OutputPass extends Pass {
+    constructor();
+    uniforms: object;
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+}

package/types/examples/jsm/postprocessing/Pass.d.ts

@@ -0,0 +1,31 @@
+import { Material, WebGLRenderer, WebGLRenderTarget } from "three";
+
+export class Pass {
+    constructor();
+
+    isPass: boolean;
+    enabled: boolean;
+    needsSwap: boolean;
+    clear: boolean;
+    renderToScreen: boolean;
+
+    setSize(width: number, height: number): void;
+    render(
+        renderer: WebGLRenderer,
+        writeBuffer: WebGLRenderTarget,
+        readBuffer: WebGLRenderTarget,
+        deltaTime: number,
+        maskActive: boolean,
+    ): void;
+
+    dispose(): void;
+}
+
+export class FullScreenQuad {
+    constructor(material?: Material);
+
+    render(renderer: WebGLRenderer): void;
+    dispose(): void;
+
+    material: Material;
+}

package/types/examples/jsm/postprocessing/RenderPass.d.ts

@@ -0,0 +1,23 @@
+import { Camera, Color, Material, Scene } from "three";
+
+import { Pass } from "./Pass.js";
+
+export class RenderPass extends Pass {
+    constructor(
+        scene: Scene,
+        camera: Camera,
+        overrideMaterial?: Material | null,
+        clearColor?: Color | null,
+        clearAlpha?: number | null,
+    );
+
+    scene: Scene;
+    camera: Camera;
+
+    overrideMaterial: Material | null;
+
+    clearColor: Color | null;
+    clearAlpha: number | null;
+
+    clearDepth: boolean;
+}

package/types/examples/jsm/postprocessing/RenderPixelatedPass.d.ts

@@ -0,0 +1,30 @@
+import { Camera, MeshNormalMaterial, Scene, ShaderMaterial, Vector2, WebGLRenderTarget } from "three";
+
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export interface RenderPixelatedPassParameters {
+    normalEdgeStrength?: number;
+    depthEdgeStrength?: number;
+}
+
+export class RenderPixelatedPass extends Pass {
+    constructor(pixelSize: number, scene: Scene, camera: Camera, options?: RenderPixelatedPassParameters);
+    pixelSize: number;
+    resolution: Vector2;
+    renderResolution: Vector2;
+
+    pixelatedMaterial: ShaderMaterial;
+    normalMaterial: MeshNormalMaterial;
+
+    fsQuad: FullScreenQuad;
+    scene: Scene;
+    camera: Camera;
+
+    normalEdgeStrength: RenderPixelatedPassParameters["normalEdgeStrength"];
+    depthEdgeStrength: RenderPixelatedPassParameters["depthEdgeStrength"];
+
+    beautyRenderTarget: WebGLRenderTarget;
+    normalRenderTarget: WebGLRenderTarget;
+
+    setPixelSize(pixelSize: number): void;
+}

package/types/examples/jsm/postprocessing/RenderTransitionPass.d.ts

@@ -0,0 +1,33 @@
+import { Camera, Object3D, ShaderMaterial, Texture, WebGLRenderer, WebGLRenderTarget } from "three";
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export class RenderTransitionPass extends Pass {
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+
+    sceneA: Object3D;
+    cameraA: Camera;
+    sceneB: Object3D;
+    cameraB: Camera;
+
+    renderTargetA: WebGLRenderTarget;
+    renderTargetB: WebGLRenderTarget;
+
+    constructor(sceneA: Object3D, cameraA: Camera, sceneB: Object3D, cameraB: Camera);
+
+    setTransition(value: number): void;
+
+    useTexture(value: boolean): void;
+
+    setTexture(value: Texture | null): void;
+
+    setTextureThreshold(value: number): void;
+
+    setSize(width: number, height: number): void;
+
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget): void;
+
+    dispose(): void;
+
+    createMaterial(): ShaderMaterial;
+}