@needle-tools/three 0.169.12 → 0.169.13

package/types/examples/jsm/controls/TransformControls.d.ts

@@ -0,0 +1,249 @@
+import { Camera, Controls, Mesh, Object3D, Quaternion, Raycaster, Vector3 } from "three";
+
+type TransformControlsMode = "translate" | "rotate" | "scale";
+
+export interface TransformControlsEventMap {
+    /**
+     * Fires if any type of change (object or property change) is performed. Property changes are separate events you
+     * can add event listeners to. The event type is "propertyname-changed".
+     */
+    change: {};
+
+    /**
+     * Fires if a pointer (mouse/touch) becomes active.
+     */
+    mouseDown: { mode: TransformControlsMode };
+
+    /**
+     * Fires if a pointer (mouse/touch) is no longer active.
+     */
+    mouseUp: { mode: TransformControlsMode };
+
+    /**
+     * Fires if the controlled 3D object is changed.
+     */
+    objectChange: {};
+
+    "camera-changed": { value: unknown };
+    "object-changed": { value: unknown };
+    "enabled-changed": { value: unknown };
+    "axis-changed": { value: unknown };
+    "mode-changed": { value: unknown };
+    "translationSnap-changed": { value: unknown };
+    "rotationSnap-changed": { value: unknown };
+    "scaleSnap-changed": { value: unknown };
+    "space-changed": { value: unknown };
+    "size-changed": { value: unknown };
+    "dragging-changed": { value: unknown };
+    "showX-changed": { value: unknown };
+    "showY-changed": { value: unknown };
+    "showZ-changed": { value: unknown };
+    "worldPosition-changed": { value: unknown };
+    "worldPositionStart-changed": { value: unknown };
+    "worldQuaternion-changed": { value: unknown };
+    "worldQuaternionStart-changed": { value: unknown };
+    "cameraPosition-changed": { value: unknown };
+    "cameraQuaternion-changed": { value: unknown };
+    "pointStart-changed": { value: unknown };
+    "pointEnd-changed": { value: unknown };
+    "rotationAxis-changed": { value: unknown };
+    "rotationAngle-changed": { value: unknown };
+    "eye-changed": { value: unknown };
+}
+
+/**
+ * This class can be used to transform objects in 3D space by adapting a similar interaction model of DCC tools like
+ * Blender. Unlike other controls, it is not intended to transform the scene's camera.
+ *
+ * TransformControls expects that its attached 3D object is part of the scene graph.
+ */
+declare class TransformControls extends Controls<TransformControlsEventMap> {
+    /**
+     * The camera of the rendered scene.
+     */
+    camera: Camera;
+
+    /**
+     * The current transformation axis.
+     */
+    axis: "X" | "Y" | "Z" | "E" | "XY" | "YZ" | "XZ" | "XYZ" | "XYZE" | null;
+
+    /**
+     * The current transformation mode. Possible values are "translate", "rotate" and "scale". Default is `translate`.
+     */
+    mode: TransformControlsMode;
+
+    /**
+     * By default, 3D objects are continuously translated. If you set this property to a numeric value (world units),
+     * you can define in which steps the 3D object should be translated. Default is `null`.
+     */
+    translationSnap: number | null;
+
+    /**
+     * By default, 3D objects are continuously rotated. If you set this property to a numeric value (radians), you can
+     * define in which steps the 3D object should be rotated. Default is `null`.
+     */
+    rotationSnap: number | null;
+
+    /**
+     * Defines in which coordinate space transformations should be performed. Possible values are "world" and "local".
+     * Default is `world`.
+     */
+    space: "world" | "local";
+
+    /**
+     * The size of the helper UI (axes/planes). Default is *1*.
+     */
+    size: number;
+
+    /**
+     * Whether or not dragging is currently performed. Read-only property.
+     */
+    dragging: boolean;
+
+    /**
+     * Whether or not the x-axis helper should be visible. Default is `true`.
+     */
+    showX: boolean;
+
+    /**
+     * Whether or not the y-axis helper should be visible. Default is `true`.
+     */
+    showY: boolean;
+
+    /**
+     * Whether or not the z-axis helper should be visible. Default is `true`.
+     */
+    showZ: boolean;
+
+    /**
+     * Creates a new instance of TransformControls.
+     * @param camera The camera of the rendered scene.
+     * @param domElement The HTML element used for event listeners. (optional)
+     */
+    constructor(camera: Camera, domElement?: HTMLElement);
+
+    /**
+     * Returns the visual representation of the controls. Add the helper to your scene to visually transform the
+     * attached 3D object.
+     */
+    getHelper(): TransformControlsRoot;
+
+    pointerHover(pointer: PointerEvent | null): void;
+    pointerDown(pointer: PointerEvent | null): void;
+    pointerMove(pointer: PointerEvent | null): void;
+    pointerUp(pointer: PointerEvent | null): void;
+
+    /**
+     * Sets the 3D object that should be transformed and ensures the controls UI is visible.
+     * @param object The 3D object that should be transformed.
+     */
+    attach(object: Object3D): this;
+
+    /**
+     * Removes the current 3D object from the controls and makes the helper UI invisible.
+     */
+    detach(): this;
+
+    /**
+     * Resets the object's position, rotation and scale to when the current transform began.
+     */
+    reset(): void;
+
+    /**
+     * Returns the {@link Raycaster} object that is used for user interaction. This object is shared between all
+     * instances of TransformControls. If you set the [.layers]{@link Object3D.layers} property of the
+     * TransformControls, you will also want to set the [.layers]{@link Raycaster.layers} property on the
+     * {@link Raycaster} with a matching value, or else the TransformControls won't work as expected.
+     */
+    getRaycaster(): Raycaster;
+
+    /**
+     * Returns the transformation mode.
+     */
+    getMode(): TransformControlsMode;
+
+    /**
+     * Sets the transformation mode.
+     * @param mode The transformation mode.
+     */
+    setMode(mode: TransformControlsMode): void;
+
+    /**
+     * Sets the translation snap.
+     * @param translationSnap The translation snap.
+     */
+    setTranslationSnap(translationSnap: number | null): void;
+
+    /**
+     * Sets the rotation snap.
+     * @param rotationSnap The rotation snap.
+     */
+    setRotationSnap(rotationSnap: number | null): void;
+
+    /**
+     * Sets the scale snap.
+     * @param scaleSnap The scale snap.
+     */
+    setScaleSnap(scaleSnap: number | null): void;
+
+    /**
+     * Sets the size of the helper UI.
+     * @param size The size of the helper UI.
+     */
+    setSize(size: number): void;
+
+    /**
+     * Sets the coordinate space in which transformations are applied.
+     * @param space The coordinate space in which transformations are applied.
+     */
+    setSpace(space: "world" | "local"): void;
+}
+
+declare class TransformControlsRoot extends Object3D {
+    readonly isTransformControlsRoot: true;
+
+    controls: TransformControls;
+
+    constructor(controls: TransformControls);
+}
+
+declare class TransformControlsGizmo extends Object3D {
+    isTransformControlsGizmo: true;
+
+    gizmo: {
+        translate: Object3D;
+        rotate: Object3D;
+        scale: Object3D;
+    };
+    helper: {
+        translate: Object3D;
+        rotate: Object3D;
+        scale: Object3D;
+    };
+    picker: {
+        translate: Object3D;
+        rotate: Object3D;
+        scale: Object3D;
+    };
+
+    constructor();
+}
+
+declare class TransformControlsPlane extends Mesh {
+    readonly isTransformControlsPlane: true;
+
+    constructor();
+
+    mode: TransformControlsMode;
+
+    axis: "X" | "Y" | "Z" | "XY" | "YZ" | "XZ" | "XYZ" | "E";
+
+    space: "local" | "world";
+
+    eye: Vector3;
+    worldPosition: Vector3;
+    worldQuaternion: Quaternion;
+}
+
+export { TransformControls, TransformControlsGizmo, TransformControlsPlane };

package/types/examples/jsm/csm/CSM.d.ts

@@ -0,0 +1,55 @@
+import { Camera, DirectionalLight, Material, Object3D, Vector2, Vector3 } from "three";
+import { CSMFrustum } from "./CSMFrustum.js";
+
+export type CSMMode = "uniform" | "logarithmic" | "practical" | "custom";
+
+export interface CSMParameters {
+    camera?: Camera;
+    parent?: Object3D;
+    cascades?: number;
+    maxFar?: number;
+    mode?: CSMMode;
+    shadowMapSize?: number;
+    shadowBias?: number;
+    lightDirection?: Vector3;
+    lightIntensity?: number;
+    lightNear?: number;
+    lightFar?: number;
+    lightMargin?: number;
+    customSplitsCallback?: (cascades: number, cameraNear: number, cameraFar: number, breaks: number[]) => void;
+}
+
+export class CSM {
+    constructor(data: CSMParameters);
+    camera: Camera;
+    parent: Object3D;
+    cascades: number;
+    maxFar: number;
+    mode: CSMMode;
+    shadowMapSize: number;
+    shadowBias: number;
+    lightDirection: Vector3;
+    lightIntensity: number;
+    lightNear: number;
+    lightFar: number;
+    lightMargin: number;
+    customSplitsCallback: (cascades: number, cameraNear: number, cameraFar: number, breaks: number[]) => void;
+    fade: boolean;
+    mainFrustum: CSMFrustum;
+    frustums: CSMFrustum[];
+    breaks: number[];
+    lights: DirectionalLight[];
+    shaders: Map<unknown, string>;
+    createLights(): void;
+    initCascades(): void;
+    updateShadowBounds(): void;
+    getBreaks(): void;
+    update(): void;
+    injectInclude(): void;
+    setupMaterial(material: Material): void;
+    updateUniforms(): void;
+    getExtendedBreaks(target: Vector2[]): void;
+    updateFrustums(): void;
+    remove(): void;
+    dispose(): void;
+}

package/types/examples/jsm/csm/CSMFrustum.d.ts

@@ -0,0 +1,19 @@
+import { Matrix4, Vector3 } from "three";
+
+export interface CSMFrustumVerticies {
+    near: Vector3[];
+    far: Vector3[];
+}
+
+export interface CSMFrustumParameters {
+    projectionMatrix?: Matrix4;
+    maxFar?: number;
+}
+
+export class CSMFrustum {
+    constructor(data?: CSMFrustumParameters);
+    vertices: CSMFrustumVerticies;
+    setFromProjectionMatrix(projectionMatrix: Matrix4, maxFar: number): CSMFrustumVerticies;
+    split(breaks: number[], target: CSMFrustum[]): void;
+    toSpace(cameraMatrix: Matrix4, target: CSMFrustum): void;
+}

package/types/examples/jsm/csm/CSMHelper.d.ts

@@ -0,0 +1,27 @@
+import {
+    Box3Helper,
+    BufferGeometry,
+    Group,
+    LineBasicMaterial,
+    LineSegments,
+    Mesh,
+    MeshBasicMaterial,
+    PlaneGeometry,
+} from "three";
+
+import { CSM } from "./CSM.js";
+
+export class CSMHelper<TCSM extends CSM = CSM> extends Group {
+    constructor(csm: TCSM);
+    csm: TCSM;
+    displayFrustum: boolean;
+    displayPlanes: boolean;
+    displayShadowBounds: boolean;
+    frustumLines: LineSegments<BufferGeometry, LineBasicMaterial>;
+    cascadeLines: Box3Helper[];
+    cascadePlanes: Array<Mesh<PlaneGeometry, MeshBasicMaterial>>;
+    shadowLines: Box3Helper[];
+    updateVisibility(): void;
+    update(): void;
+    dispose(): void;
+}

package/types/examples/jsm/csm/CSMShader.d.ts

@@ -0,0 +1,4 @@
+export interface CSMShader {
+    lights_fragment_begin: string;
+    lights_pars_begin: string;
+}

package/types/examples/jsm/curves/CurveExtras.d.ts

@@ -0,0 +1,68 @@
+import { Curve, Vector3 } from "three";
+
+export class GrannyKnot extends Curve<Vector3> {
+    constructor();
+}
+
+export class HeartCurve extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
+
+export class VivianiCurve extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
+
+export class KnotCurve extends Curve<Vector3> {
+    constructor();
+}
+
+export class HelixCurve extends Curve<Vector3> {
+    constructor();
+}
+
+export class TrefoilKnot extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
+
+export class TorusKnot extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
+
+export class CinquefoilKnot extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
+
+export class TrefoilPolynomialKnot extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
+
+export class FigureEightPolynomialKnot extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
+
+export class DecoratedTorusKnot4a extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
+
+export class DecoratedTorusKnot4b extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
+
+export class DecoratedTorusKnot5a extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
+
+export class DecoratedTorusKnot5c extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}

package/types/examples/jsm/curves/NURBSCurve.d.ts

@@ -0,0 +1,17 @@
+import { Curve, Vector2, Vector3, Vector4 } from "three";
+
+export class NURBSCurve extends Curve<Vector3> {
+    degree: number;
+    knots: number[];
+    controlPoints: Vector2[] | Vector3[] | Vector4[];
+    startKnot: number;
+    endKnot: number;
+
+    constructor(
+        degree: number,
+        knots: number[],
+        controlPoints: Vector2[] | Vector3[] | Vector4[],
+        startKnot?: number,
+        endKnot?: number,
+    );
+}

package/types/examples/jsm/curves/NURBSSurface.d.ts

@@ -0,0 +1,13 @@
+import { Vector2, Vector3, Vector4 } from "three";
+
+export class NURBSSurface {
+    constructor(
+        degree1: number,
+        degree2: number,
+        knots1: number[],
+        knots2: number[],
+        controlPoints: Vector2[][] | Vector3[][] | Vector4[][],
+    );
+
+    getPoint(t1: number, t2: number, target: Vector3): void;
+}

package/types/examples/jsm/curves/NURBSUtils.d.ts

@@ -0,0 +1,146 @@
+import { Vector3, Vector4 } from "three";
+
+/**
+ * Finds knot vector span.
+ * @param p degree
+ * @param u parametric value
+ * @param U knot vector
+ * @returns the span
+ */
+export function findSpan(p: number, u: number, U: readonly number[]): number;
+
+/**
+ * Calculate basis functions. See The NURBS Book, page 70, algorithm A2.2
+ * @param span span in which u lies
+ * @param u parametric point
+ * @param p degrees
+ * @param U knot vector
+ * @returns array[p+1] with basis function values
+ */
+export function calcBasisFunctions(span: number, u: number, p: number, U: readonly number[]): number[];
+
+/**
+ * Calculate B-Spline curve points. See The NURBS Book, page 82, algorithm A3.1.
+ * @param p degree of B-Spline
+ * @param U knot vector
+ * @param P control points (x, y, z, w)
+ * @param u parametric point
+ * @returns point for given u
+ */
+export function calcBSplinePoint(p: number, U: readonly number[], P: readonly Vector4[], u: number): Vector4;
+
+/**
+ * Calculate basis functions derivatives. See The NURBS Book, page 72, algorithm A2.3.
+ * @param span span in which u lies
+ * @param u parametric point
+ * @param p degree
+ * @param n number of derivatives to calculate
+ * @param U knot vector
+ * @returns array[n+1][p+1] with basis functions derivatives
+ */
+export function calcBasisFunctionDerivatives(
+    span: number,
+    u: number,
+    p: number,
+    n: number,
+    U: readonly number[],
+): number[][];
+
+/**
+ * Calculate derivatives of a B-Spline. See The NURBS Book, page 93, algorithm A3.2.
+ * @param p degree
+ * @param U knot vector
+ * @param P control points
+ * @param u Parametric points
+ * @param nd number of derivatives
+ * @returns array[d+1] with derivatives
+ */
+export function calcBSplineDerivatives(
+    p: number,
+    U: readonly number[],
+    P: readonly Vector4[],
+    u: number,
+    nd: number,
+): Vector4[];
+
+/**
+ * Calculate "K over I"
+ * @returns k!/(i!(k-i)!
+ */
+export function calcKoverI(k: number, i: number): number;
+
+/**
+ * Calculate derivatives (0-nd) of rational curve. See The NURBS Book, page 127, algorithm A4.2.
+ * @param Pders result of function calcBSplineDerivatives
+ * @returns array with derivatives for rational curve.
+ */
+export function calcRationalCurveDerivatives(Pders: readonly Vector4[]): Vector3[];
+
+/**
+ * Calculate NURBS curve derivatives. See The NURBS Book, page 127, algorithm A4.2.
+ * @param p degree
+ * @param U knot vector
+ * @param P control points in homogeneous space
+ * @param u parametric points
+ * @param nd number of derivatives
+ * @returns array with derivatives
+ */
+export function calcNURBSDerivatives(
+    p: number,
+    U: readonly number[],
+    P: readonly Vector4[],
+    u: number,
+    nd: number,
+): Vector3[];
+
+/**
+ * Calculate rational B-Spline surface point. See The NURBS Book, page 134, algorithm A4.3.
+ * @param p degree of B-Spline surface
+ * @param q degree of B-Spline surface
+ * @param U knot vector
+ * @param V knot vector
+ * @param P control points (x, y, z, w)
+ * @param u parametric value
+ * @param v parametric value
+ * @param target
+ * @returns point for given (u, v)
+ */
+export function calcSurfacePoint(
+    p: number,
+    q: number,
+    U: readonly number[],
+    V: readonly number[],
+    P: readonly (readonly Vector4[])[],
+    u: number,
+    v: number,
+    target: Vector3,
+): Vector3;
+
+/**
+ * Calculate rational B-Spline volume point. See The NURBS Book, page 134, algorithm A4.3.
+ * @param p degree of B-Spline volume
+ * @param q degree of B-Spline volume
+ * @param r degree of B-Spline volume
+ * @param U knot vector
+ * @param V knot vector
+ * @param W knot vector
+ * @param P control points (x, y, z, w)
+ * @param u parametric value
+ * @param v parametric value
+ * @param w parametric value
+ * @param target
+ * @returns point for given (u, v, w)
+ */
+export function calcVolumePoint(
+    p: number,
+    q: number,
+    r: number,
+    U: readonly number[],
+    V: readonly number[],
+    W: readonly number[],
+    P: readonly (readonly (readonly Vector4[])[])[],
+    u: number,
+    v: number,
+    w: number,
+    target: Vector3,
+): Vector3;

package/types/examples/jsm/curves/NURBSVolume.d.ts

@@ -0,0 +1,23 @@
+import { Vector3, Vector4 } from "three";
+
+export class NURBSVolume {
+    degree1: number;
+    degree2: number;
+    degree3: number;
+    knots1: readonly number[];
+    knots2: readonly number[];
+    knots3: readonly number[];
+    controlPoints: Vector4[][][];
+
+    constructor(
+        degree1: number,
+        degree2: number,
+        degree3: number,
+        knots1: readonly number[],
+        knots2: readonly number[],
+        knots3: readonly number[],
+        controlPoints: Vector4[][][],
+    );
+
+    getPoint(t1: number, t2: number, t3: number, target: Vector3): void;
+}

package/types/examples/jsm/effects/AnaglyphEffect.d.ts

@@ -0,0 +1,17 @@
+import { Camera, Matrix3, Scene, WebGLRenderer } from "three";
+
+declare class AnaglyphEffect {
+    colorMatrixLeft: Matrix3;
+
+    colorMatrixRight: Matrix3;
+
+    setSize: (width: number, height: number) => void;
+
+    render: (scene: Scene, camera: Camera) => void;
+
+    dispose: () => void;
+
+    constructor(renderer: WebGLRenderer, width?: number, height?: number);
+}
+
+export { AnaglyphEffect };

package/types/examples/jsm/effects/AsciiEffect.d.ts

@@ -0,0 +1,18 @@
+import { Camera, Scene, WebGLRenderer } from "three";
+
+export interface AsciiEffectOptions {
+    resolution?: number;
+    scale?: number;
+    color?: boolean;
+    alpha?: boolean;
+    block?: boolean;
+    invert?: boolean;
+}
+
+export class AsciiEffect {
+    constructor(renderer: WebGLRenderer, charSet?: string, options?: AsciiEffectOptions);
+    domElement: HTMLElement;
+
+    render(scene: Scene, camera: Camera): void;
+    setSize(width: number, height: number): void;
+}

package/types/examples/jsm/effects/OutlineEffect.d.ts

@@ -0,0 +1,28 @@
+import { Camera, Scene, Vector2, Vector4, WebGLRenderer, WebGLRenderTarget, WebGLShadowMap } from "three";
+
+export interface OutlineEffectParameters {
+    defaultThickness?: number | undefined;
+    defaultColor?: number[] | undefined;
+    defaultAlpha?: number | undefined;
+    defaultKeepAlive?: boolean | undefined;
+}
+
+export class OutlineEffect {
+    constructor(renderer: WebGLRenderer, parameters?: OutlineEffectParameters);
+    enabled: boolean;
+    autoClear: boolean;
+    domElement: HTMLElement;
+    shadowMap: WebGLShadowMap;
+
+    clear(color?: boolean, depth?: boolean, stencil?: boolean): void;
+    getPixelRatio(): number;
+    getSize(target: Vector2): Vector2;
+    render(scene: Scene, camera: Camera): void;
+    renderOutline(scene: Scene, camera: Camera): void;
+    setRenderTarget(renderTarget: WebGLRenderTarget | null): void;
+    setPixelRatio(value: number): void;
+    setScissor(x: Vector4 | number, y?: number, width?: number, height?: number): void;
+    setScissorTest(enable: boolean): void;
+    setSize(width: number, height: number, updateStyle?: boolean): void;
+    setViewport(x: Vector4 | number, y?: number, width?: number, height?: number): void;
+}