@nativescript/canvas-three 2.0.0-webgpu.26 → 2.0.0-webgpu.28

package/three/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/three/src/textures/CanvasTexture.d.ts

@@ -0,0 +1,34 @@
+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/three/src/textures/CompressedArrayTexture.d.ts

@@ -0,0 +1,61 @@
+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/three/src/textures/CompressedCubeTexture.d.ts

@@ -0,0 +1,9 @@
+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/three/src/textures/CompressedTexture.d.ts

@@ -0,0 +1,74 @@
+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/three/src/textures/CubeTexture.d.ts

@@ -0,0 +1,82 @@
+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/three/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 {};

package/three/src/textures/DataArrayTexture.d.ts

@@ -0,0 +1,123 @@
+import { MagnificationTextureFilter, MinificationTextureFilter } from '../constants.js';
+import { Texture } from './Texture.js';
+import { Texture3DImageData } from './types.js';
+
+/**
+ * Creates an array of textures directly from raw data, width and height and depth
+ * @example
+ * ```typescript
+ * This creates a[name] where each texture has a different color.
+ * // create a buffer with color data
+ * const width = 512;
+ * const height = 512;
+ * const depth = 100;
+ * const size = width * height;
+ * const data = new Uint8Array(4 * size * depth);
+ * for (let i = 0; i & lt; depth; i++) {
+ *     const color = new THREE.Color(Math.random(), Math.random(), Math.random());
+ *     const r = Math.floor(color.r * 255);
+ *     const g = Math.floor(color.g * 255);
+ *     const b = Math.floor(color.b * 255);
+ *     for (let j = 0; j & lt; size; j++) {
+ *         const stride = (i * size + j) * 4;
+ *         data[stride] = r;
+ *         data[stride + 1] = g;
+ *         data[stride + 2] = b;
+ *         data[stride + 3] = 255;
+ *     }
+ * }
+ * // used the buffer to create a [name]
+ * const texture = new THREE.DataArrayTexture(data, width, height, depth);
+ * texture.needsUpdate = true;
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl2_materials_texture2darray | WebGL2 / materials / texture2darray}
+ * @see Example: {@link https://threejs.org/examples/#webgl2_rendertarget_texture2darray | WebGL2 / rendertarget / texture2darray}
+ * @see {@link https://threejs.org/docs/index.html#api/en/textures/DataArrayTexture | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/textures/DataArrayTexture.js | Source}
+ */
+export class DataArrayTexture extends Texture {
+	/**
+	 * Read-only flag to check if a given object is of type {@link DataArrayTexture}.
+	 * @remarks This is a _constant_ value
+	 * @defaultValue `true`
+	 */
+	readonly isDataArrayTexture: 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: boolean;
+
+	/**
+	 * @override
+	 * @defaultValue `false`
+	 */
+	generateMipmaps: boolean;
+
+	/**
+	 * @override
+	 * @defaultValue `false`
+	 */
+	flipY: boolean;
+
+	/**
+	 * @override
+	 * @defaultValue `1`
+	 */
+	unpackAlignment: number;
+
+	/**
+	 * A set of all layers which need to be updated in the texture. See {@link DataArrayTexture.addLayerUpdate}.
+	 */
+	layerUpdates: Set<number>;
+
+	/**
+	 * This creates a new {@link THREE.DataArrayTexture | DataArrayTexture} object.
+	 * @remarks The interpretation of the data depends on {@link format} and {@link type}.
+	 * @remarks If the {@link type} is {@link THREE.UnsignedByteType}, a {@link Uint8Array} will be useful for addressing the texel data
+	 * @remarks If the {@link format} is {@link THREE.RGBAFormat}, data needs four values for one texel; Red, Green, Blue and Alpha (typically the opacity).
+	 * @remarks For the packed {@link type | types}, {@link THREE.UnsignedShort4444Type} and {@link THREE.UnsignedShort5551Type}
+	 * all color components of one texel can be addressed as bitfields within an integer element of a {@link Uint16Array}.
+	 * @remarks In order to use the {@link type | types} {@link THREE.FloatType} and {@link THREE.HalfFloatType},
+	 * the WebGL implementation must support the respective extensions _OES_texture_float_ and _OES_texture_half_float_
+	 * @remarks In order to use {@link THREE.LinearFilter} for component-wise, bilinear interpolation of the texels based on these types,
+	 * the WebGL extensions _OES_texture_float_linear_ or _OES_texture_half_float_linear_ must also be present.
+	 * @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);
+
+	/**
+	 * 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 DataArrayTexture.addLayerUpdate}.
+	 */
+	clearLayoutUpdates(): void;
+}