@needle-tools/three 0.169.12 → 0.169.14

package/types/src/core/InstancedBufferAttribute.d.ts

@@ -0,0 +1,32 @@
+import { BufferAttribute, TypedArray } from "./BufferAttribute.js";
+
+/**
+ * An instanced version of {@link THREE.BufferAttribute | BufferAttribute}.
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/InstancedBufferAttribute | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/InstancedBufferAttribute.js | Source}
+ */
+export class InstancedBufferAttribute extends BufferAttribute {
+    /**
+     * Create a new instance of {@link THREE.InstancedBufferAttribute | InstancedBufferAttribute}
+     * @param array
+     * @param itemSize
+     * @param normalized
+     * @param meshPerAttribute
+     */
+    constructor(array: TypedArray, itemSize: number, normalized?: boolean, meshPerAttribute?: number);
+
+    /**
+     * Defines how often a value of this buffer attribute should be repeated.
+     * A value of one means that each value of the instanced attribute is used for a single instance.
+     * A value of two means that each value is used for two consecutive instances (and so on).
+     * @defaultValue `1`
+     */
+    meshPerAttribute: number;
+
+    /**
+     * Read-only flag to check if a given object is of type {@link InstancedBufferAttribute}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isInstancedBufferAttribute: true;
+}

package/types/src/core/InstancedBufferGeometry.d.ts

@@ -0,0 +1,37 @@
+import { BufferGeometry } from "./BufferGeometry.js";
+
+/**
+ * An instanced version of {@link THREE.BufferGeometry | BufferGeometry}.
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/InstancedBufferGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/InstancedBufferGeometry.js | Source}
+ */
+export class InstancedBufferGeometry extends BufferGeometry {
+    /**
+     * Create a new instance of {@link InstancedBufferGeometry}
+     */
+    constructor();
+
+    /**
+     * @defaultValue `InstancedBufferGeometry`
+     */
+    type: string;
+
+    /**
+     * Read-only flag to check if a given object is of type {@link InstancedBufferGeometry}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isInstancedBufferGeometry: true;
+
+    /**
+     * @defaultValue `Infinity`
+     */
+    instanceCount: number;
+
+    /**
+     * Copies the given {@link InstancedBufferGeometry} to this instance.
+     * @param source
+     * @override
+     */
+    copy(source: InstancedBufferGeometry): this;
+}

package/types/src/core/InstancedInterleavedBuffer.d.ts

@@ -0,0 +1,22 @@
+import { TypedArray } from "./BufferAttribute.js";
+import { InterleavedBuffer } from "./InterleavedBuffer.js";
+
+/**
+ * An instanced version of {@link THREE.InterleavedBuffer | InterleavedBuffer}.
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/InstancedInterleavedBuffer | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/InstancedInterleavedBuffer.js | Source}
+ */
+export class InstancedInterleavedBuffer extends InterleavedBuffer {
+    /**
+     * Create a new instance of {@link InstancedInterleavedBuffer}
+     * @param array
+     * @param itemSize
+     * @param meshPerAttribute
+     */
+    constructor(array: TypedArray, stride: number, meshPerAttribute?: number);
+
+    /**
+     * @defaultValue `1`
+     */
+    meshPerAttribute: number;
+}

package/types/src/core/InterleavedBuffer.d.ts

@@ -0,0 +1,150 @@
+import { Usage } from "../constants.js";
+import { TypedArray } from "./BufferAttribute.js";
+import { InterleavedBufferAttribute } from "./InterleavedBufferAttribute.js";
+
+/**
+ * **"Interleaved"** means that multiple attributes, possibly of different types, (e.g., _position, normal, uv, color_) are packed into a single array buffer.
+ * An introduction into interleaved arrays can be found here: {@link https://blog.tojicode.com/2011/05/interleaved-array-basics.html | Interleaved array basics}
+ * @see Example: {@link https://threejs.org/examples/#webgl_buffergeometry_points_interleaved | webgl / buffergeometry / points / interleaved}
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/InterleavedBuffer | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/InterleavedBuffer.js | Source}
+ */
+export class InterleavedBuffer {
+    readonly isInterleavedBuffer: true;
+
+    /**
+     * Create a new instance of {@link InterleavedBuffer}
+     * @param array A {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray | TypedArray} with a shared buffer. Stores the geometry data.
+     * @param stride The number of typed-array elements per vertex. Expects a `Integer`
+     */
+    constructor(array: TypedArray, stride: number);
+
+    /**
+     * A {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray | TypedArray} with a shared buffer. Stores the geometry data.
+     */
+    array: TypedArray;
+
+    /**
+     * The number of {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray | TypedArray} elements per vertex.
+     * @remarks Expects a `Integer`
+     */
+    stride: number;
+
+    /**
+     * Defines the intended usage pattern of the data store for optimization purposes.
+     * Corresponds to the {@link BufferAttribute.usage | usage} parameter of
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/bufferData | WebGLRenderingContext.bufferData}.
+     * @remarks
+     * After the initial use of a buffer, its usage cannot be changed. Instead, instantiate a new one and set the desired usage before the next render.
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/BufferAttributeUsage | Buffer Attribute Usage Constants} for all possible values.
+     * @see {@link BufferAttribute.setUsage | setUsage}
+     * @defaultValue {@link THREE.StaticDrawUsage | THREE.StaticDrawUsage}.
+     */
+    usage: Usage;
+
+    /**
+     * This can be used to only update some components of stored data. Use the {@link .addUpdateRange} function to add
+     * ranges to this array.
+     */
+    updateRanges: Array<{
+        /**
+         * Position at which to start update.
+         */
+        start: number;
+        /**
+         * The number of components to update.
+         */
+        count: number;
+    }>;
+
+    /**
+     * A version number, incremented every time the {@link BufferAttribute.needsUpdate | needsUpdate} property is set to true.
+     * @remarks Expects a `Integer`
+     * @defaultValue `0`
+     */
+    version: number;
+
+    /**
+     * Gives the total number of elements in the array.
+     * @remarks Expects a `Integer`
+     * @defaultValue 0
+     */
+    count: number;
+
+    /**
+     * Flag to indicate that this attribute has changed and should be re-sent to the GPU.
+     * Set this to true when you modify the value of the array.
+     * @remarks Setting this to true also increments the {@link BufferAttribute.version | version}.
+     * @remarks _set-only property_.
+     */
+    set needsUpdate(value: boolean);
+
+    /**
+     * {@link http://en.wikipedia.org/wiki/Universally_unique_identifier | UUID} of this object instance.
+     * @remarks This gets automatically assigned and shouldn't be edited.
+     */
+    uuid: string;
+
+    /**
+     * Calls {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set | TypedArray.set}( {@link value}, {@link offset} )
+     * on the {@link BufferAttribute.array | array}.
+     * @param value The source `TypedArray`.
+     * @param offset index of the {@link BufferAttribute.array | array} at which to start copying. Expects a `Integer`. Default `0`.
+     * @throws `RangeError` When {@link offset} is negative or is too large.
+     */
+    set(value: ArrayLike<number>, offset: number): this;
+
+    /**
+     * Set {@link BufferAttribute.usage | usage}
+     * @remarks
+     * After the initial use of a buffer, its usage cannot be changed. Instead, instantiate a new one and set the desired usage before the next render.
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/BufferAttributeUsage | Buffer Attribute Usage Constants} for all possible values.
+     * @see {@link BufferAttribute.usage | usage}
+     * @param value Corresponds to the {@link BufferAttribute.usage | usage} parameter of
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/bufferData | WebGLRenderingContext.bufferData}.
+     */
+    setUsage(value: Usage): this;
+
+    /**
+     * Adds a range of data in the data array to be updated on the GPU. Adds an object describing the range to the
+     * {@link .updateRanges} array.
+     */
+    addUpdateRange(start: number, count: number): void;
+
+    /**
+     * Clears the {@link .updateRanges} array.
+     */
+    clearUpdateRanges(): void;
+
+    /**
+     * Copies another {@link InterleavedBuffer} to this {@link InterleavedBuffer} instance.
+     * @param source
+     */
+    copy(source: InterleavedBuffer): this;
+
+    /**
+     * Copies data from {@link attribute}[{@link index2}] to {@link InterleavedBuffer.array | array}[{@link index1}].
+     * @param index1 Expects a `Integer`
+     * @param attribute
+     * @param index2 Expects a `Integer`
+     */
+    copyAt(index1: number, attribute: InterleavedBufferAttribute, index2: number): this;
+
+    /**
+     * Creates a clone of this {@link InterleavedBuffer}.
+     * @param data This object holds shared array buffers required for properly cloning geometries with interleaved attributes.
+     */
+    clone(data: {}): InterleavedBuffer;
+
+    /**
+     * Serializes this {@link InterleavedBuffer}.
+     * Converting to {@link https://github.com/mrdoob/three.js/wiki/JSON-Geometry-format-4 | JSON Geometry format v4},
+     * @param data This object holds shared array buffers required for properly serializing geometries with interleaved attributes.
+     */
+    toJSON(data: {}): {
+        uuid: string;
+        buffer: string;
+        type: string;
+        stride: number;
+    };
+}

package/types/src/core/InterleavedBufferAttribute.d.ts

@@ -0,0 +1,201 @@
+import { Matrix3 } from "../math/Matrix3.js";
+import { Matrix4 } from "../math/Matrix4.js";
+import { BufferAttribute, TypedArray } from "./BufferAttribute.js";
+import { InterleavedBuffer } from "./InterleavedBuffer.js";
+
+/**
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/InterleavedBufferAttribute | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/InterleavedBufferAttribute.js | Source}
+ */
+export class InterleavedBufferAttribute {
+    /**
+     * Create a new instance of {@link THREE.InterleavedBufferAttribute | InterleavedBufferAttribute}.
+     * @param interleavedBuffer
+     * @param itemSize
+     * @param offset
+     * @param normalized Default `false`.
+     */
+    constructor(interleavedBuffer: InterleavedBuffer, itemSize: number, offset: number, normalized?: boolean);
+
+    /**
+     * Optional name for this attribute instance.
+     * @defaultValue `''`
+     */
+    name: string;
+
+    /**
+     * The {@link InterleavedBuffer | InterleavedBuffer} instance passed in the constructor.
+     */
+    data: InterleavedBuffer;
+
+    /**
+     * How many values make up each item.
+     * @remarks Expects a `Integer`
+     */
+    itemSize: number;
+
+    /**
+     * The offset in the underlying array buffer where an item starts.
+     * @remarks Expects a `Integer`
+     */
+    offset: number;
+
+    /**
+     * @defaultValue `false`
+     */
+    normalized: boolean;
+
+    /**
+     * The value of {@link data | .data}.{@link InterleavedBuffer.count | count}.
+     * If the buffer is storing a 3-component item (such as a _position, normal, or color_), then this will count the number of such items stored.
+     * @remarks _get-only property_.
+     * @remarks Expects a `Integer`
+     */
+    get count(): number;
+
+    /**
+     * The value of {@link InterleavedBufferAttribute.data | data}.{@link InterleavedBuffer.array | array}.
+     * @remarks _get-only property_.
+     */
+    get array(): TypedArray;
+
+    /**
+     * Flag to indicate that the {@link data | .data} ({@link InterleavedBuffer}) attribute has changed and should be re-sent to the GPU.
+     * @remarks Setting this to have the same result of setting true also increments the {@link InterleavedBuffer.needsUpdate | InterleavedBuffer.needsUpdate} of {@link data | .data}.
+     * @remarks Setting this to true also increments the {@link InterleavedBuffer.version | InterleavedBuffer.version}.
+     * @remarks _set-only property_.
+     */
+    set needsUpdate(value: boolean);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link InterleavedBufferAttribute}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isInterleavedBufferAttribute: true;
+
+    /**
+     * Applies matrix {@link Matrix4 | m} to every Vector3 element of this InterleavedBufferAttribute.
+     * @param m
+     */
+    applyMatrix4(m: Matrix4): this;
+
+    /**
+     * Applies normal matrix {@link Matrix3 | m} to every Vector3 element of this InterleavedBufferAttribute.
+     * @param m
+     */
+    applyNormalMatrix(m: Matrix3): this;
+
+    /**
+     * Applies matrix {@link Matrix4 | m} to every Vector3 element of this InterleavedBufferAttribute, interpreting the elements as a direction vectors.
+     * @param m
+     */
+    transformDirection(m: Matrix4): this;
+
+    /**
+     * Returns the given component of the vector at the given index.
+     */
+    getComponent(index: number, component: number): number;
+
+    /**
+     * Sets the given component of the vector at the given index.
+     */
+    setComponent(index: number, component: number, value: number): this;
+
+    /**
+     * Returns the x component of the item at the given index.
+     * @param index Expects a `Integer`
+     */
+    getX(index: number): number;
+
+    /**
+     * Sets the x component of the item at the given index.
+     * @param index Expects a `Integer`
+     * @param x Expects a `Float`
+     */
+    setX(index: number, x: number): this;
+
+    /**
+     * Returns the y component of the item at the given index.
+     * @param index Expects a `Integer`
+     */
+    getY(index: number): number;
+
+    /**
+     * Sets the y component of the item at the given index.
+     * @param index Expects a `Integer`
+     * @param y Expects a `Float`
+     */
+    setY(index: number, y: number): this;
+
+    /**
+     * Returns the z component of the item at the given index.
+     * @param index Expects a `Integer`
+     */
+    getZ(index: number): number;
+
+    /**
+     * Sets the z component of the item at the given index.
+     * @param index Expects a `Integer`
+     * @param z Expects a `Float`
+     */
+    setZ(index: number, z: number): this;
+
+    /**
+     * Returns the w component of the item at the given index.
+     * @param index Expects a `Integer`
+     */
+    getW(index: number): number;
+
+    /**
+     * Sets the w component of the item at the given index.
+     * @param index Expects a `Integer`
+     * @param w Expects a `Float`
+     */
+    setW(index: number, z: number): this;
+
+    /**
+     * Sets the x and y components of the item at the given index.
+     * @param index Expects a `Integer`
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
+    setXY(index: number, x: number, y: number): this;
+    /**
+     * Sets the x, y and z components of the item at the given index.
+     * @param index Expects a `Integer`
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     * @param z Expects a `Float`
+     */
+    setXYZ(index: number, x: number, y: number, z: number): this;
+
+    /**
+     * Sets the x, y, z and w components of the item at the given index.
+     * @param index Expects a `Integer`
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     * @param z Expects a `Float`
+     * @param w Expects a `Float`
+     */
+    setXYZW(index: number, x: number, y: number, z: number, w: number): this;
+
+    /**
+     * Creates a clone of this {@link InterleavedBufferAttribute}.
+     * @param data This object holds shared array buffers required for properly cloning geometries with interleaved attributes.
+     */
+    clone(data?: {}): BufferAttribute;
+
+    /**
+     * Serializes this {@link InterleavedBufferAttribute}.
+     * Converting to {@link https://github.com/mrdoob/three.js/wiki/JSON-Geometry-format-4 | JSON Geometry format v4},
+     * @param data This object holds shared array buffers required for properly serializing geometries with interleaved attributes.
+     */
+    toJSON(data?: {}): {
+        isInterleavedBufferAttribute: true;
+        itemSize: number;
+        data: string;
+        offset: number;
+        normalized: boolean;
+    };
+}

package/types/src/core/Layers.d.ts

@@ -0,0 +1,72 @@
+/**
+ * A {@link THREE.Layers | Layers} object assigns an {@link THREE.Object3D | Object3D} to 1 or more of 32 layers numbered `0` to `31` - internally the
+ * layers are stored as a {@link https://en.wikipedia.org/wiki/Mask_(computing) | bit mask}, and
+ * by default all Object3Ds are a member of layer `0`.
+ * @remarks
+ * This can be used to control visibility - an object must share a layer with a {@link Camera | camera} to be visible when that camera's view is rendered.
+ * @remarks
+ * All classes that inherit from {@link THREE.Object3D | Object3D} have an {@link THREE.Object3D.layers | Object3D.layers} property which is an instance of this class.
+ * @see Example: {@link https://threejs.org/examples/#webgl_layers | WebGL / layers}
+ * @see Example: {@link https://threejs.org/examples/#webxr_vr_layers | Webxr / vr / layers}
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/Layers | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/Layers.js | Source}
+ */
+export class Layers {
+    /**
+     * Create a new Layers object, with membership initially set to layer 0.
+     */
+    constructor();
+
+    /**
+     * A bit mask storing which of the 32 layers this layers object is currently a member of.
+     * @defaultValue `1 | 0`
+     * @remarks Expects a `Integer`
+     */
+    mask: number;
+
+    /**
+     * Set membership to `layer`, and remove membership all other layers.
+     * @param layer An integer from 0 to 31.
+     */
+    set(layer: number): void;
+
+    /**
+     * Add membership of this `layer`.
+     * @param layer An integer from 0 to 31.
+     */
+    enable(layer: number): void;
+
+    /**
+     * Add membership to all layers.
+     */
+    enableAll(): void;
+
+    /**
+     * Toggle membership of `layer`.
+     * @param layer An integer from 0 to 31.
+     */
+    toggle(layer: number): void;
+
+    /**
+     * Remove membership of this `layer`.
+     * @param layer An integer from 0 to 31.
+     */
+    disable(layer: number): void;
+
+    /**
+     * Remove membership from all layers.
+     */
+    disableAll(): void;
+
+    /**
+     * Returns true if this and the passed `layers` object have at least one layer in common.
+     * @param layers A Layers object
+     */
+    test(layers: Layers): boolean;
+
+    /**
+     * Returns true if the given layer is enabled.
+     * @param layer An integer from 0 to 31.
+     */
+    isEnabled(layer: number): boolean;
+}