@needle-tools/three 0.169.12 → 0.169.13

package/types/src/scenes/Fog.d.ts

@@ -0,0 +1,77 @@
+import { Color, ColorRepresentation } from "../math/Color.js";
+
+export interface FogJSON {
+    type: string;
+    name: string;
+    color: number;
+    near: number;
+    far: number;
+}
+
+/**
+ * This class contains the parameters that define linear fog, i.e., that grows linearly denser with the distance.
+ *  @example
+ * ```typescript
+ * const scene = new THREE.Scene();
+ * scene.fog = new THREE.Fog(0xcccccc, 10, 15);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/scenes/Fog | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/scenes/Fog.js | Source}
+ */
+export class Fog {
+    /**
+     * The color parameter is passed to the {@link THREE.Color | Color} constructor to set the color property
+     * @remarks
+     * Color can be a hexadecimal integer or a CSS-style string.
+     * @param color
+     * @param near Expects a `Float`
+     * @param far Expects a `Float`
+     */
+    constructor(color: ColorRepresentation, near?: number, far?: number);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link Fog}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isFog: true;
+
+    /**
+     * Optional name of the object
+     * @remarks _(doesn't need to be unique)_.
+     * @defaultValue `""`
+     */
+    name: string;
+
+    /**
+     * Fog color.
+     * @remarks If set to black, far away objects will be rendered black.
+     */
+    color: Color;
+
+    /**
+     * The minimum distance to start applying fog.
+     * @remarks Objects that are less than **near** units from the active camera won't be affected by fog.
+     * @defaultValue `1`
+     * @remarks Expects a `Float`
+     */
+    near: number;
+
+    /**
+     * The maximum distance at which fog stops being calculated and applied.
+     * @remarks Objects that are more than **far** units away from the active camera won't be affected by fog.
+     * @defaultValue `1000`
+     * @remarks Expects a `Float`
+     */
+    far: number;
+
+    /**
+     * Returns a new {@link Fog} instance with the same parameters as this one.
+     */
+    clone(): Fog;
+
+    /**
+     * Return {@link Fog} data in JSON format.
+     */
+    toJSON(): FogJSON;
+}

package/types/src/scenes/FogExp2.d.ts

@@ -0,0 +1,66 @@
+import { Color, ColorRepresentation } from "../math/Color.js";
+
+export interface FogExp2JSON {
+    type: string;
+    name: string;
+    color: number;
+    density: number;
+}
+
+/**
+ * This class contains the parameters that define exponential squared fog, which gives a clear view near the camera and a faster than exponentially densening fog farther from the camera.
+ * @example
+ * ```typescript
+ * const scene = new THREE.Scene();
+ * scene.fog = new THREE.FogExp2(0xcccccc, 0.002);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_terrain | webgl geometry terrain}
+ * @see {@link https://threejs.org/docs/index.html#api/en/scenes/FogExp2 | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/scenes/FogExp2.js | Source}
+ */
+export class FogExp2 {
+    /**
+     * The color parameter is passed to the {@link THREE.Color | Color} constructor to set the color property
+     * @remarks Color can be a hexadecimal integer or a CSS-style string.
+     * @param color
+     * @param density Expects a `Float`
+     */
+    constructor(color: ColorRepresentation, density?: number);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link FogExp2}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isFogExp2: true;
+
+    /**
+     * Optional name of the object
+     * @remarks _(doesn't need to be unique)_.
+     * @defaultValue `""`
+     */
+    name: string;
+
+    /**
+     * Fog color.
+     * @remarks If set to black, far away objects will be rendered black.
+     */
+    color: Color;
+
+    /**
+     * Defines how fast the fog will grow dense.
+     * @defaultValue `0.00025`
+     * @remarks Expects a `Float`
+     */
+    density: number;
+
+    /**
+     * Returns a new {@link FogExp2} instance with the same parameters as this one.
+     */
+    clone(): FogExp2;
+
+    /**
+     * Return {@link FogExp2} data in JSON format.
+     */
+    toJSON(): FogExp2JSON;
+}

package/types/src/scenes/Scene.d.ts

@@ -0,0 +1,118 @@
+import { JSONMeta, Object3D, Object3DJSON, Object3DJSONObject } from "../core/Object3D.js";
+import { Material } from "../materials/Material.js";
+import { Color } from "../math/Color.js";
+import { Euler, EulerTuple } from "../math/Euler.js";
+import { CubeTexture } from "../textures/CubeTexture.js";
+import { Texture } from "../textures/Texture.js";
+import { Fog, FogJSON } from "./Fog.js";
+import { FogExp2, FogExp2JSON } from "./FogExp2.js";
+
+export interface SceneJSONObject extends Object3DJSONObject {
+    fog?: FogJSON | FogExp2JSON;
+
+    backgroundBlurriness?: number;
+    backgroundIntensity?: number;
+    backgroundRotation: EulerTuple;
+
+    environmentIntensity?: number;
+    environmentRotation: EulerTuple;
+}
+
+export interface SceneJSON extends Object3DJSON {
+    object: SceneJSONObject;
+}
+
+/**
+ * Scenes allow you to set up what and where is to be rendered by three.js
+ * @remarks
+ * This is where you place objects, lights and cameras.
+ * @see Example: {@link https://threejs.org/examples/#webgl_multiple_scenes_comparison | webgl multiple scenes comparison}
+ * @see {@link https://threejs.org/docs/index.html#manual/en/introduction/Creating-a-scene | Manual: Creating a scene}
+ * @see {@link https://threejs.org/docs/index.html#api/en/scenes/Scene | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/scenes/Scene.js | Source}
+ */
+export class Scene extends Object3D {
+    /**
+     * Create a new {@link Scene} object.
+     */
+    constructor();
+
+    /**
+     * Read-only flag to check if a given object is of type {@link Scene}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isScene: true;
+
+    /**
+     * @defaultValue `Scene`
+     */
+    type: "Scene";
+
+    /**
+     * A {@link Fog | fog} instance defining the type of fog that affects everything rendered in the scene.
+     * @defaultValue `null`
+     */
+    fog: Fog | FogExp2 | null;
+
+    /**
+     * Sets the blurriness of the background. Only influences environment maps assigned to {@link THREE.Scene.background | Scene.background}.
+     * @defaultValue `0`
+     * @remarks Expects a `Float` between `0` and `1`.
+     */
+    backgroundBlurriness: number;
+
+    /**
+     * Attenuates the color of the background. Only applies to background textures.
+     * @defaultValue `1`
+     * @remarks Expects a `Float`
+     */
+    backgroundIntensity: number;
+
+    /**
+     * Forces everything in the {@link Scene} to be rendered with the defined material.
+     * @defaultValue `null`
+     */
+    overrideMaterial: Material | null;
+
+    /**
+     * Defines the background of the scene.
+     * @remarks Valid inputs are:
+     *  - A {@link THREE.Color | Color} for defining a uniform colored background.
+     *  - A {@link THREE.Texture | Texture} for defining a (flat) textured background.
+     *  - Texture cubes ({@link THREE.CubeTexture | CubeTexture}) or equirectangular textures for defining a skybox.</li>
+     * @defaultValue `null`
+     */
+    background: Color | Texture | CubeTexture | null;
+
+    /**
+     * The rotation of the background in radians. Only influences environment maps assigned to {@link .background}.
+     * Default is `(0,0,0)`.
+     */
+    backgroundRotation: Euler;
+
+    /**
+     * Sets the environment map for all physical materials in the scene.
+     * However, it's not possible to overwrite an existing texture assigned to {@link THREE.MeshStandardMaterial.envMap | MeshStandardMaterial.envMap}.
+     * @defaultValue `null`
+     */
+    environment: Texture | null;
+
+    /**
+     * Attenuates the color of the environment. Only influences environment maps assigned to {@link Scene.environment}.
+     * @default 1
+     */
+    environmentIntensity: number;
+
+    /**
+     * The rotation of the environment map in radians. Only influences physical materials in the scene when
+     * {@link .environment} is used. Default is `(0,0,0)`.
+     */
+    environmentRotation: Euler;
+
+    /**
+     * Convert the {@link Scene} to three.js {@link https://github.com/mrdoob/three.js/wiki/JSON-Object-Scene-format-4 | JSON Object/Scene format}.
+     * @param meta Object containing metadata such as textures or images for the scene.
+     */
+    toJSON(meta?: JSONMeta): SceneJSON;
+}

package/types/src/textures/CanvasTexture.d.ts

@@ -0,0 +1,51 @@
+import {
+    MagnificationTextureFilter,
+    Mapping,
+    MinificationTextureFilter,
+    PixelFormat,
+    TextureDataType,
+    Wrapping,
+} from "../constants.js";
+import { OffscreenCanvas, Texture } from "./Texture.js";
+
+/**
+ * Creates a texture from a {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/canvas | canvas element}.
+ * @remarks
+ * This is almost the same as the base {@link Texture | Texture} class,
+ * except that it sets {@link Texture.needsUpdate | needsUpdate} to `true` immediately.
+ * @see {@link THREE.Texture | Texture}
+ * @see {@link https://threejs.org/docs/index.html#api/en/textures/CanvasTexture | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/textures/CanvasTexture.js | Source}
+ */
+export class CanvasTexture extends Texture {
+    /**
+     * This creates a new {@link THREE.CanvasTexture | CanvasTexture} object.
+     * @param canvas The HTML canvas element from which to load the texture.
+     * @param mapping See {@link Texture.mapping | .mapping}. Default {@link THREE.Texture.DEFAULT_MAPPING}
+     * @param wrapS See {@link Texture.wrapS | .wrapS}. Default {@link THREE.ClampToEdgeWrapping}
+     * @param wrapT See {@link Texture.wrapT | .wrapT}. Default {@link THREE.ClampToEdgeWrapping}
+     * @param magFilter See {@link Texture.magFilter | .magFilter}. Default {@link THREE.LinearFilter}
+     * @param minFilter  See {@link Texture.minFilter | .minFilter}. Default {@link THREE.LinearMipmapLinearFilter}
+     * @param format See {@link Texture.format | .format}. Default {@link THREE.RGBAFormat}
+     * @param type See {@link Texture.type | .type}. Default {@link THREE.UnsignedByteType}
+     * @param anisotropy See {@link Texture.anisotropy | .anisotropy}. Default {@link THREE.Texture.DEFAULT_ANISOTROPY}
+     */
+    constructor(
+        canvas: TexImageSource | OffscreenCanvas,
+        mapping?: Mapping,
+        wrapS?: Wrapping,
+        wrapT?: Wrapping,
+        magFilter?: MagnificationTextureFilter,
+        minFilter?: MinificationTextureFilter,
+        format?: PixelFormat,
+        type?: TextureDataType,
+        anisotropy?: number,
+    );
+
+    /**
+     * Read-only flag to check if a given object is of type {@link CanvasTexture}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isCanvasTexture: true;
+}

package/types/src/textures/CompressedArrayTexture.d.ts

@@ -0,0 +1,68 @@
+import { CompressedPixelFormat, TextureDataType, Wrapping } from "../constants.js";
+import { CompressedTexture, CompressedTextureMipmap } from "./CompressedTexture.js";
+
+/**
+ * Creates an texture 2D array based on data in compressed form, for example from a
+ * {@link https://en.wikipedia.org/wiki/DirectDraw_Surface | DDS} file.
+ * @remarks For use with the {@link THREE.CompressedTextureLoader | CompressedTextureLoader}.
+ * @see {@link https://threejs.org/docs/index.html#api/en/textures/CompressedArrayTexture | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/textures/CompressedArrayTexture.js | Source}
+ */
+export class CompressedArrayTexture extends CompressedTexture {
+    /**
+     * Read-only flag to check if a given object is of type {@link CompressedArrayTexture}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isCompressedArrayTexture: true;
+
+    /**
+     * Overridden with a object containing width and height.
+     * @override
+     */
+    get image(): { width: number; height: number; depth: number };
+    set image(value: { width: number; height: number; depth: number });
+
+    /**
+     * This defines how the texture is wrapped in the depth direction.
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+     * @defaultValue {@link THREE.ClampToEdgeWrapping}
+     */
+    wrapR: Wrapping;
+
+    /**
+     * A set of all layers which need to be updated in the texture. See {@link CompressedArrayTexture.addLayerUpdate}.
+     */
+    layerUpdates: Set<number>;
+
+    /**
+     * Create a new instance of {@link CompressedArrayTexture}
+     * @param mipmaps The mipmaps array should contain objects with data, width and height. The mipmaps should be of the
+     * correct format and type.
+     * @param width The width of the biggest mipmap.
+     * @param height The height of the biggest mipmap.
+     * @param depth The number of layers of the 2D array texture
+     * @param format The format used in the mipmaps. See {@link THREE.CompressedPixelFormat}.
+     * @param type See {@link Texture.type | .type}. Default {@link THREE.UnsignedByteType}
+     */
+    constructor(
+        mipmaps: CompressedTextureMipmap[],
+        width: number,
+        height: number,
+        depth: number,
+        format: CompressedPixelFormat,
+        type?: TextureDataType,
+    );
+
+    /**
+     * Describes that a specific layer of the texture needs to be updated. Normally when {@link Texture.needsUpdate} is
+     * set to true, the entire compressed texture array is sent to the GPU. Marking specific layers will only transmit
+     * subsets of all mipmaps associated with a specific depth in the array which is often much more performant.
+     */
+    addLayerUpdate(layerIndex: number): void;
+
+    /**
+     * Resets the layer updates registry. See {@link CompressedArrayTexture.addLayerUpdate}.
+     */
+    clearLayoutUpdates(): void;
+}

package/types/src/textures/CompressedCubeTexture.d.ts

@@ -0,0 +1,13 @@
+import { CompressedPixelFormat, TextureDataType } from "../constants.js";
+import { CompressedTexture } from "./CompressedTexture.js";
+
+export class CompressedCubeTexture extends CompressedTexture {
+    readonly isCompressedCubeTexture: true;
+    readonly isCubeTexture: true;
+
+    constructor(
+        images: Array<{ width: number; height: number }>,
+        format?: CompressedPixelFormat,
+        type?: TextureDataType,
+    );
+}

package/types/src/textures/CompressedTexture.d.ts

@@ -0,0 +1,95 @@
+import {
+    ColorSpace,
+    CompressedPixelFormat,
+    MagnificationTextureFilter,
+    Mapping,
+    MinificationTextureFilter,
+    TextureDataType,
+    Wrapping,
+} from "../constants.js";
+import { TypedArray } from "../core/BufferAttribute.js";
+import { Texture } from "./Texture.js";
+
+export interface CompressedTextureMipmap {
+    data: TypedArray;
+    width: number;
+    height: number;
+}
+
+/**
+ * Creates a texture based on data in compressed form, for example from a {@link https://en.wikipedia.org/wiki/DirectDraw_Surface | DDS} file.
+ * @remarks For use with the {@link THREE.CompressedTextureLoader | CompressedTextureLoader}.
+ * @see {@link https://threejs.org/docs/index.html#api/en/textures/CompressedTexture | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/textures/CompressedTexture.js | Source}
+ */
+export class CompressedTexture extends Texture {
+    /**
+     * This creates a new {@link THREE.CompressedTexture | CompressedTexture} object.
+     * @param mipmaps The mipmaps array should contain objects with data, width and height. The mipmaps should be of the
+     * correct format and type.
+     * @param width The width of the biggest mipmap.
+     * @param height The height of the biggest mipmap.
+     * @param format The format used in the mipmaps. See {@link THREE.CompressedPixelFormat}.
+     * @param type See {@link Texture.type | .type}. Default {@link THREE.UnsignedByteType}
+     * @param mapping See {@link Texture.mapping | .mapping}. Default {@link THREE.Texture.DEFAULT_MAPPING}
+     * @param wrapS See {@link Texture.wrapS | .wrapS}. Default {@link THREE.ClampToEdgeWrapping}
+     * @param wrapT See {@link Texture.wrapT | .wrapT}. Default {@link THREE.ClampToEdgeWrapping}
+     * @param magFilter See {@link Texture.magFilter | .magFilter}. Default {@link THREE.LinearFilter}
+     * @param minFilter  See {@link Texture.minFilter | .minFilter}. Default {@link THREE.LinearMipmapLinearFilter}
+     * @param anisotropy See {@link Texture.anisotropy | .anisotropy}. Default {@link THREE.Texture.DEFAULT_ANISOTROPY}
+     * @param colorSpace See {@link Texture.colorSpace .colorSpace}. Default {@link NoColorSpace}
+     */
+    constructor(
+        mipmaps?: CompressedTextureMipmap[],
+        width?: number,
+        height?: number,
+        format?: CompressedPixelFormat,
+        type?: TextureDataType,
+        mapping?: Mapping,
+        wrapS?: Wrapping,
+        wrapT?: Wrapping,
+        magFilter?: MagnificationTextureFilter,
+        minFilter?: MinificationTextureFilter,
+        anisotropy?: number,
+        colorSpace?: ColorSpace,
+    );
+
+    /**
+     * Read-only flag to check if a given object is of type {@link CompressedTexture}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isCompressedTexture: true;
+
+    /**
+     * Overridden with a object containing width and height.
+     * @override
+     */
+    get image(): { width: number; height: number };
+    set image(value: { width: number; height: number });
+
+    /**
+     *  The mipmaps array should contain objects with data, width and height. The mipmaps should be of the correct
+     *  format and type.
+     */
+    mipmaps: CompressedTextureMipmap[] | undefined;
+
+    /**
+     * @override
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+     * @see {@link THREE.CompressedPixelFormat}
+     */
+    format: CompressedPixelFormat;
+
+    /**
+     * @override No flipping for cube textures. (also flipping doesn't work for compressed textures)
+     * @defaultValue `false`
+     */
+    flipY: boolean;
+
+    /**
+     * @override Can't generate mipmaps for compressed textures. mips must be embedded in DDS files
+     * @defaultValue `false`
+     */
+    generateMipmaps: boolean;
+}

package/types/src/textures/CubeTexture.d.ts

@@ -0,0 +1,90 @@
+import {
+    ColorSpace,
+    CubeTextureMapping,
+    MagnificationTextureFilter,
+    MinificationTextureFilter,
+    PixelFormat,
+    TextureDataType,
+    Wrapping,
+} from "../constants.js";
+import { Texture } from "./Texture.js";
+
+/**
+ * Creates a cube texture made up of six images.
+ * @remarks
+ * {@link CubeTexture} is almost equivalent in functionality and usage to {@link Texture}.
+ * The only differences are that the images are an array of _6_ images as opposed to a single image,
+ * and the mapping options are {@link THREE.CubeReflectionMapping} (default) or {@link THREE.CubeRefractionMapping}
+ * @example
+ * ```typescript
+ * const loader = new THREE.CubeTextureLoader();
+ * loader.setPath('textures/cube/pisa/');
+ * const textureCube = loader.load(['px.png', 'nx.png', 'py.png', 'ny.png', 'pz.png', 'nz.png']);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffffff,
+ *     envMap: textureCube
+ * });
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/textures/CubeTexture | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/textures/CubeTexture.js | Source}
+ */
+export class CubeTexture extends Texture {
+    /**
+     * This creates a new {@link THREE.CubeTexture | CubeTexture} object.
+     * @param images
+     * @param mapping See {@link CubeTexture.mapping | .mapping}. Default {@link THREE.CubeReflectionMapping}
+     * @param wrapS See {@link Texture.wrapS | .wrapS}. Default {@link THREE.ClampToEdgeWrapping}
+     * @param wrapT See {@link Texture.wrapT | .wrapT}. Default {@link THREE.ClampToEdgeWrapping}
+     * @param magFilter See {@link Texture.magFilter | .magFilter}. Default {@link THREE.LinearFilter}
+     * @param minFilter  See {@link Texture.minFilter | .minFilter}. Default {@link THREE.LinearMipmapLinearFilter}
+     * @param format See {@link Texture.format | .format}. Default {@link THREE.RGBAFormat}
+     * @param type See {@link Texture.type | .type}. Default {@link THREE.UnsignedByteType}
+     * @param anisotropy See {@link Texture.anisotropy | .anisotropy}. Default {@link THREE.Texture.DEFAULT_ANISOTROPY}
+     * @param colorSpace See {@link Texture.colorSpace | .colorSpace}. Default {@link NoColorSpace}
+     */
+    constructor(
+        images?: any[], // HTMLImageElement or HTMLCanvasElement
+        mapping?: CubeTextureMapping,
+        wrapS?: Wrapping,
+        wrapT?: Wrapping,
+        magFilter?: MagnificationTextureFilter,
+        minFilter?: MinificationTextureFilter,
+        format?: PixelFormat,
+        type?: TextureDataType,
+        anisotropy?: number,
+        colorSpace?: ColorSpace,
+    );
+
+    /**
+     * Read-only flag to check if a given object is of type {@link CubeTexture}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isCubeTexture: true;
+
+    /**
+     * An image object, typically created using the {@link THREE.CubeTextureLoader.load | CubeTextureLoader.load()} method.
+     * @see {@link Texture.image}
+     */
+    get image(): any;
+    set image(data: any);
+
+    /**
+     * An image object, typically created using the {@link THREE.CubeTextureLoader.load | CubeTextureLoader.load()} method.
+     * @see {@link Texture.image}
+     */
+    get images(): any;
+    set images(data: any);
+
+    /**
+     * @inheritDoc
+     * @defaultValue {@link THREE.CubeReflectionMapping}
+     */
+    mapping: CubeTextureMapping;
+
+    /**
+     * @inheritDoc
+     * @defaultValue `false`
+     */
+    flipY: boolean;
+}

package/types/src/textures/Data3DTexture.d.ts

@@ -0,0 +1,96 @@
+import { MagnificationTextureFilter, MinificationTextureFilter, Wrapping } from "../constants.js";
+import { Texture } from "./Texture.js";
+import { Texture3DImageData } from "./types.js";
+
+/**
+ * Creates a three-dimensional texture from raw data, with parameters to divide it into width, height, and depth
+ * @example
+ * ```typescript
+ * This creates a[name] with repeating data, 0 to 255
+ * // create a buffer with some data
+ * const sizeX = 64;
+ * const sizeY = 64;
+ * const sizeZ = 64;
+ * const data = new Uint8Array(sizeX * sizeY * sizeZ);
+ * let i = 0;
+ * for (let z = 0; z & lt; sizeZ; z++) {
+ *     for (let y = 0; y & lt; sizeY; y++) {
+ *         for (let x = 0; x & lt; sizeX; x++) {
+ *             data[i] = i % 256;
+ *             i++;
+ *         }
+ *     }
+ * }
+ * // use the buffer to create the texture
+ * const texture = new THREE.Data3DTexture(data, sizeX, sizeY, sizeZ);
+ * texture.needsUpdate = true;
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl2_materials_texture3d | WebGL2 / materials / texture3d}
+ * @see Example: {@link https://threejs.org/examples/#webgl2_materials_texture3d_partialupdate | WebGL2 / materials / texture3d / partialupdate}
+ * @see Example: {@link https://threejs.org/examples/#webgl2_volume_cloud | WebGL2 / volume / cloud}
+ * @see Example: {@link https://threejs.org/examples/#webgl2_volume_perlin | WebGL2 / volume / perlin}
+ * @see {@link https://threejs.org/docs/index.html#api/en/textures/Data3DTexture | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/textures/Data3DTexture.js | Source}
+ */
+export class Data3DTexture extends Texture {
+    /**
+     * Create a new instance of {@link Data3DTexture}
+     * @param data {@link https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView | ArrayBufferView} of the texture. Default `null`.
+     * @param width Width of the texture. Default `1`.
+     * @param height Height of the texture. Default `1`.
+     * @param depth Depth of the texture. Default `1`.
+     */
+    constructor(data?: BufferSource | null, width?: number, height?: number, depth?: number);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link Data3DTexture}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isData3DTexture: true;
+
+    /**
+     * Overridden with a record type holding data, width and height and depth.
+     * @override
+     */
+    get image(): Texture3DImageData;
+    set image(data: Texture3DImageData);
+
+    /**
+     * @override
+     * @defaultValue {@link THREE.NearestFilter}
+     */
+    magFilter: MagnificationTextureFilter;
+
+    /**
+     * @override
+     * @defaultValue {@link THREE.NearestFilter}
+     */
+    minFilter: MinificationTextureFilter;
+
+    /**
+     * @override
+     * @defaultValue {@link THREE.ClampToEdgeWrapping}
+     */
+    wrapR: Wrapping;
+
+    /**
+     * @override
+     * @defaultValue `false`
+     */
+    flipY: boolean;
+
+    /**
+     * @override
+     * @defaultValue `false`
+     */
+    generateMipmaps: boolean;
+
+    /**
+     * @override
+     * @defaultValue `1`
+     */
+    unpackAlignment: number;
+}
+
+export {};