@types/three 0.149.0 → 0.150.1

three/src/textures/Texture.d.ts

@@ -1,5 +1,3 @@
-// https://threejs.org/docs/?q=texture#api/en/textures/Texture
-
 import { Vector2 } from './../math/Vector2';
 import { Matrix3 } from './../math/Matrix3';
 import { Source } from './Source';
@@ -7,213 +5,431 @@ import { EventDispatcher } from './../core/EventDispatcher';
 import {
     Mapping,
     Wrapping,
-    TextureFilter,
     PixelFormat,
     PixelFormatGPU,
     TextureDataType,
     TextureEncoding,
+    MagnificationTextureFilter,
+    MinificationTextureFilter,
+    AnyPixelFormat,
+    AnyMapping,
 } from '../constants';
 
 /** Shim for OffscreenCanvas. */
 // tslint:disable-next-line:no-empty-interface
 export interface OffscreenCanvas extends EventTarget {}
 
+/**
+ * Create a {@link Texture} to apply to a surface or as a reflection or refraction map.
+ * @remarks
+ * After the initial use of a texture, its **dimensions**, {@link format}, and {@link type} cannot be changed
+ * Instead, call {@link dispose | .dispose()} on the {@link Texture} and instantiate a new {@link Texture}.
+ * @example
+ * ```typescript
+ * // load a texture, set wrap mode to repeat
+ * const texture = new THREE.TextureLoader().load("textures/water.jpg");
+ * texture.wrapS = THREE.RepeatWrapping;
+ * texture.wrapT = THREE.RepeatWrapping;
+ * texture.repeat.set(4, 4);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_materials_texture_filters | webgl materials texture filters}
+ * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+ * @see {@link https://threejs.org/docs/index.html#api/en/textures/Texture | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/Textures/Texture.js | Source}
+ */
 export class Texture extends EventDispatcher {
     /**
-     * @param [image]
-     * @param [mapping=THREE.Texture.DEFAULT_MAPPING]
-     * @param [wrapS=THREE.ClampToEdgeWrapping]
-     * @param [wrapT=THREE.ClampToEdgeWrapping]
-     * @param [magFilter=THREE.LinearFilter]
-     * @param [minFilter=THREE.LinearMipmapLinearFilter]
-     * @param [format=THREE.RGBAFormat]
-     * @param [type=THREE.UnsignedByteType]
-     * @param [anisotropy=THREE.Texture.DEFAULT_ANISOTROPY]
-     * @param [encoding=THREE.LinearEncoding]
+     * This creates a new {@link THREE.Texture | Texture} object.
+     * @param image See {@link Texture.image | .image}. Default {@link THREE.Texture.DEFAULT_IMAGE}
+     * @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}
+     * @param encoding See {@link Texture.encoding | .encoding}. Default {@link THREE.LinearEncoding}
      */
     constructor(
         image?: TexImageSource | OffscreenCanvas,
         mapping?: Mapping,
         wrapS?: Wrapping,
         wrapT?: Wrapping,
-        magFilter?: TextureFilter,
-        minFilter?: TextureFilter,
+        magFilter?: MagnificationTextureFilter,
+        minFilter?: MinificationTextureFilter,
         format?: PixelFormat,
         type?: TextureDataType,
         anisotropy?: number,
         encoding?: TextureEncoding,
     );
 
-    id: number;
+    /**
+     * Read-only flag to check if a given object is of type {@link Texture}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isTexture: true;
+
+    /**
+     * Unique number for this {@link Texture} instance.
+     * @remarks Note that ids are assigned in chronological order: 1, 2, 3, ..., incrementing by one for each new object.
+     * @remarks Expects a `Integer`
+     */
+    readonly id: number;
+
+    /**
+     * {@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;
 
     /**
-     * @default ''
+     * Optional name of the object
+     * @remarks _(doesn't need to be unique)_.
+     * @defaultValue `""`
      */
     name: string;
-    sourceFile: string;
 
     /**
      * The data definition of a texture. A reference to the data source can be shared across textures.
-     * This is often useful in context of spritesheets where multiple textures render the same data but with different texture transformations.
+     * This is often useful in context of spritesheets where multiple textures render the same data
+     * but with different {@link Texture} transformations.
      */
     source: Source;
 
     /**
-     * An image object, typically created using the {@link TextureLoader.load} method.
-     * This can be any image (e.g., PNG, JPG, GIF, DDS) or video (e.g., MP4, OGG/OGV) type supported by three.js.
-     *
-     * To use video as a texture you need to have a playing HTML5
-     * video element as a source for your texture image and continuously update this texture
-     * as long as video is playing - the {@link VideoTexture} class handles this automatically.
+     * An image object, typically created using the {@link THREE.TextureLoader.load | TextureLoader.load()} method.
+     * @remarks This can be any image (e.g., PNG, JPG, GIF, DDS) or video (e.g., MP4, OGG/OGV) type supported by three.js.
+     * @remarks To use video as a {@link Texture} you need to have a playing HTML5 video element as a source
+     * for your {@link Texture} image and continuously update this {@link Texture}
+     * as long as video is playing - the {@link THREE.VideoTexture | VideoTexture} class handles this automatically.
      */
     get image(): any;
-
-    /**
-     * An image object, typically created using the {@link TextureLoader.load} method.
-     * This can be any image (e.g., PNG, JPG, GIF, DDS) or video (e.g., MP4, OGG/OGV) type supported by three.js.
-     *
-     * To use video as a texture you need to have a playing HTML5
-     * video element as a source for your texture image and continuously update this texture
-     * as long as video is playing - the {@link VideoTexture} class handles this automatically.
-     */
     set image(data: any);
 
     /**
-     * @default []
+     * Array of user-specified mipmaps
+     * @defaultValue `[]`
      */
     mipmaps: any[]; // ImageData[] for 2D textures and CubeTexture[] for cube textures;
 
     /**
-     * @default THREE.Texture.DEFAULT_MAPPING
+     * How the image is applied to the object.
+     * @remarks All {@link Texture} types except {@link THREE.CubeTexture} expect the _values_ be {@link THREE.Mapping}
+     * @remarks {@link CubeTexture} expect the _values_ be {@link THREE.CubeTextureMapping}
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+     * @defaultValue _value of_ {@link THREE.Texture.DEFAULT_MAPPING}
      */
-    mapping: Mapping;
+    mapping: AnyMapping;
 
     /**
-     * @default THREE.ClampToEdgeWrapping
+     * This defines how the {@link Texture} is wrapped *horizontally* and corresponds to **U** in UV mapping.
+     * @remarks for **WEBGL1** - tiling of images in textures only functions if image dimensions are powers of two
+     * (2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, ...) in terms of pixels.
+     * Individual dimensions need not be equal, but each must be a power of two. This is a limitation of WebGL1, not three.js.
+     * **WEBGL2** does not have this limitation.
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+     * @see {@link wrapT}
+     * @see {@link repeat}
+     * @defaultValue {@link THREE.ClampToEdgeWrapping}
      */
     wrapS: Wrapping;
 
     /**
-     * @default THREE.ClampToEdgeWrapping
+     * This defines how the {@link Texture} is wrapped *vertically* and corresponds to **V** in UV mapping.
+     * @remarks for **WEBGL1** - tiling of images in textures only functions if image dimensions are powers of two
+     * (2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, ...) in terms of pixels.
+     * Individual dimensions need not be equal, but each must be a power of two. This is a limitation of WebGL1, not three.js.
+     * **WEBGL2** does not have this limitation.
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+     * @see {@link wrapS}
+     * @see {@link repeat}
+     * @defaultValue {@link THREE.ClampToEdgeWrapping}
      */
     wrapT: Wrapping;
 
     /**
-     * @default THREE.LinearFilter
+     * How the {@link Texture} is sampled when a texel covers more than one pixel.
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+     * @see {@link minFilter}
+     * @see {@link THREE.MagnificationTextureFilter}
+     * @defaultValue {@link THREE.LinearFilter}
      */
-    magFilter: TextureFilter;
+    magFilter: MagnificationTextureFilter;
 
     /**
-     * @default THREE.LinearMipmapLinearFilter
+     * How the {@link Texture} is sampled when a texel covers less than one pixel.
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+     * @see {@link magFilter}
+     * @see {@link THREE.MinificationTextureFilter}
+     * @defaultValue {@link THREE.LinearMipmapLinearFilter}
      */
-    minFilter: TextureFilter;
+    minFilter: MinificationTextureFilter;
 
     /**
-     * @default 1
+     * The number of samples taken along the axis through the pixel that has the highest density of texels.
+     * @remarks A higher value gives a less blurry result than a basic mipmap, at the cost of more {@link Texture} samples being used.
+     * @remarks Use {@link THREE.WebGLCapabilities.getMaxAnisotropy() | renderer.capabilities.getMaxAnisotropy()} to find the maximum valid anisotropy value for the GPU;
+     * @remarks This value is usually a power of 2.
+     * @default _value of_ {@link THREE.Texture.DEFAULT_ANISOTROPY}. That is normally `1`.
      */
     anisotropy: number;
 
     /**
-     * @default THREE.RGBAFormat
+     * These define how elements of a 2D texture, or texels, are read by shaders.
+     * @remarks All {@link Texture} types except {@link THREE.DeepTexture} and {@link THREE.CompressedPixelFormat} expect the _values_ be {@link THREE.PixelFormat}
+     * @remarks {@link DeepTexture} expect the _values_ be {@link THREE.CubeTextureMapping}
+     * @remarks {@link CompressedPixelFormat} expect the _values_ be {@link THREE.CubeTextureMapping}
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+     * @see {@link THREE.PixelFormat}
+     * @defaultValue {@link THREE.RGBAFormat}.
      */
-    format: PixelFormat;
-
-    internalFormat: PixelFormatGPU | null;
+    format: AnyPixelFormat;
 
     /**
-     * @default THREE.UnsignedByteType
+     * This must correspond to the {@link Texture.format | .format}.
+     * @remarks {@link THREE.UnsignedByteType}, is the type most used by Texture formats.
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+     * @see {@link THREE.TextureDataType}
+     * @defaultValue {@link THREE.UnsignedByteType}
      */
     type: TextureDataType;
 
     /**
-     * @default new THREE.Matrix3()
+     * The GPU Pixel Format allows the developer to specify how the data is going to be stored on the GPU.
+     * @remarks Compatible only with {@link WebGL2RenderingContext | WebGL 2 Rendering Context}.
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+     * @defaultValue The default value is obtained using a combination of {@link Texture.format | .format} and {@link Texture.type | .type}.
+     */
+    internalFormat: PixelFormatGPU | null;
+
+    /**
+     * The uv-transform matrix for the texture.
+     * @remarks
+     * When {@link Texture.matrixAutoUpdate | .matrixAutoUpdate} property is `true`.
+     * Will be updated by the renderer from the properties:
+     *  - {@link Texture.offset | .offset}
+     *  - {@link Texture.repeat | .repeat}
+     *  - {@link Texture.rotation | .rotation}
+     *  - {@link Texture.center | .center}
+     * @remarks
+     * When {@link Texture.matrixAutoUpdate | .matrixAutoUpdate} property is `false`.
+     * This matrix may be set manually.
+     * @see {@link matrixAutoUpdate | .matrixAutoUpdate}
+     * @defaultValue `new THREE.Matrix3()`
      */
     matrix: Matrix3;
 
     /**
-     * @default true
+     * Whether is to update the texture's uv-transform {@link matrix | .matrix}.
+     * @remarks Set this to `false` if you are specifying the uv-transform {@link matrix} directly.
+     * @see {@link matrix | .matrix}
+     * @defaultValue `true`
      */
     matrixAutoUpdate: boolean;
 
     /**
-     * @default new THREE.Vector2( 0, 0 )
+     * How much a single repetition of the texture is offset from the beginning, in each direction **U** and **V**.
+     * @remarks Typical range is `0.0` to `1.0`.
+     * @remarks
+     * The below texture types share the `first` uv channel in the engine.
+     * The offset (and repeat) setting is evaluated according to the following priorities and then shared by those textures:
+     *  - color map
+     *  - specular map
+     *  - displacement map
+     *  - normal map
+     *  - bump map
+     *  - roughness map
+     *  - metalness map
+     *  - alpha map
+     *  - emissive map
+     *  - clearcoat map
+     *  - clearcoat normal map
+     *  - clearcoat roughnessMap map
+     * @remarks
+     * The below {@link Texture} types share the `second` uv channel in the engine.
+     * The offset (and repeat) setting is evaluated according to the following priorities and then shared by those textures:
+     *  - ao map
+     *  - light map
+     * @defaultValue `new THREE.Vector2(0, 0)`
      */
     offset: Vector2;
 
     /**
-     * @default new THREE.Vector2( 1, 1 )
+     * How many times the texture is repeated across the surface, in each direction **U** and **V**.
+     * @remarks
+     * If repeat is set greater than `1` in either direction, the corresponding *Wrap* parameter should
+     * also be set to {@link THREE.RepeatWrapping} or {@link THREE.MirroredRepeatWrapping} to achieve the desired tiling effect.
+     * @remarks
+     * Setting different repeat values for textures is restricted in the same way like {@link .offset | .offset}.
+     * @see {@link wrapS}
+     * @see {@link wrapT}
+     * @defaultValue `new THREE.Vector2( 1, 1 )`
      */
     repeat: Vector2;
 
     /**
-     * @default new THREE.Vector2( 0, 0 )
+     * The point around which rotation occurs.
+     * @remarks A value of `(0.5, 0.5)` corresponds to the center of the texture.
+     * @defaultValue `new THREE.Vector2( 0, 0 )`, _lower left._
      */
     center: Vector2;
 
     /**
-     * @default 0
+     * How much the texture is rotated around the center point, in radians.
+     * @remarks Positive values are counter-clockwise.
+     * @defaultValue `0`
      */
     rotation: number;
 
     /**
-     * @default true
+     * Whether to generate mipmaps, _(if possible)_ for a texture.
+     * @remarks Set this to false if you are creating mipmaps manually.
+     * @defaultValue true
      */
     generateMipmaps: boolean;
 
     /**
-     * @default false
+     * If set to `true`, the alpha channel, if present, is multiplied into the color channels when the texture is uploaded to the GPU.
+     * @remarks
+     * Note that this property has no effect for {@link https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap | ImageBitmap}.
+     * You need to configure on bitmap creation instead. See {@link THREE.ImageBitmapLoader | ImageBitmapLoader}.
+     * @see {@link THREE.ImageBitmapLoader | ImageBitmapLoader}.
+     * @defaultValue `false`
      */
     premultiplyAlpha: boolean;
 
     /**
-     * @default true
+     * If set to `true`, the texture is flipped along the vertical axis when uploaded to the GPU.
+     * @remarks
+     * Note that this property has no effect for {@link https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap | ImageBitmap}.
+     * You need to configure on bitmap creation instead. See {@link THREE.ImageBitmapLoader | ImageBitmapLoader}.
+     * @see {@link THREE.ImageBitmapLoader | ImageBitmapLoader}.
+     * @defaultValue `true`
      */
     flipY: boolean;
 
     /**
-     * @default 4
+     * Specifies the alignment requirements for the start of each pixel row in memory.
+     * @remarks
+     * The allowable values are:
+     *  - `1` (byte-alignment)
+     *  - `2` (rows aligned to even-numbered bytes)
+     *  - `4` (word-alignment)
+     *  - `8` (rows start on double-word boundaries).
+     * @see {@link http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml | glPixelStorei} for more information.
+     * @defaultValue `4`
      */
-    unpackAlignment: number;
+    unpackAlignment: number; // TODO Fix typing to only allow the expected values.
 
     /**
-     * @default THREE.LinearEncoding
+     * The {@link Textures | {@link Texture} constants} page for details of other formats.
+     * @remarks
+     * Values of {@link encoding} !== {@link THREE.LinearEncoding} are only supported on _map_, _envMap_ and _emissiveMap_.
+     * @remarks
+     * Note that if this value is changed on a texture after the material has been used, it is necessary to trigger a {@link THREE.Material.needsUpdate} for this value to be realized in the shader.
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+     * @see {@link THREE.TextureDataType}
+     * @defaultValue {@link THREE.LinearEncoding}
      */
     encoding: TextureEncoding;
 
     /**
-     * @default false
+     * Indicates whether a texture belongs to a render target or not
+     * @defaultValue `false`
      */
     isRenderTargetTexture: boolean;
 
     /**
-     * @default false
+     * Indicates whether this texture should be processed by {@link THREE.PMREMGenerator} or not.
+     * @remarks Only relevant for render target textures.
+     * @defaultValue `false`
      */
     needsPMREMUpdate: boolean;
 
     /**
-     * An object that can be used to store custom data about the Material. It should not hold references to functions as these will not be cloned.
-     * @default {}
+     * An object that can be used to store custom data about the texture.
+     * @remarks It should not hold references to functions as these will not be cloned.
+     * @defaultValue `{}`
      */
     userData: any;
 
     /**
-     * @default 0
+     * This starts at `0` and counts how many times {@link needsUpdate | .needsUpdate} is set to `true`.
+     * @remarks Expects a `Integer`
+     * @defaultValue `0`
      */
     version: number;
-    set needsUpdate(value: boolean);
-    readonly isTexture: true;
 
-    onUpdate: () => void;
+    /**
+     * Set this to `true` to trigger an update next time the texture is used. Particularly important for setting the wrap mode.
+     */
+    set needsUpdate(value: boolean);
 
+    /**
+     * The Global default value for {@link anisotropy | .anisotropy}.
+     * @defaultValue `1`.
+     */
     static DEFAULT_ANISOTROPY: number;
+
+    /**
+     * The Global default value for {@link Texture.image | .image}.
+     * @defaultValue `null`.
+     */
     static DEFAULT_IMAGE: any;
-    static DEFAULT_MAPPING: any;
 
+    /**
+     * The Global default value for {@link mapping | .mapping}.
+     * @defaultValue {@link THREE.UVMapping}
+     */
+    static DEFAULT_MAPPING: Mapping;
+
+    /**
+     * A callback function, called when the texture is updated _(e.g., when needsUpdate has been set to true and then the texture is used)_.
+     */
+    onUpdate: () => void;
+
+    /**
+     * Transform the **UV** based on the value of this texture's
+     * {@link offset | .offset},
+     * {@link repeat | .repeat},
+     * {@link wrapS | .wrapS},
+     * {@link wrapT | .wrapT} and
+     * {@link flipY | .flipY} properties.
+     * @param uv
+     */
+    transformUv(uv: Vector2): Vector2;
+
+    /**
+     * Update the texture's **UV-transform** {@link matrix | .matrix} from the texture properties
+     * {@link offset | .offset},
+     * {@link repeat | .repeat},
+     * {@link rotation | .rotation} and
+     * {@link center | .center}.
+     */
+    updateMatrix(): void;
+
+    /**
+     * Make copy of the texture
+     * @remarks Note this is not a **"deep copy"**, the image is shared
+     * @remarks
+     * Besides, cloning a texture does not automatically mark it for a texture upload
+     * You have to set {@link needsUpdate | .needsUpdate} to `true` as soon as it's image property (the data source) is fully loaded or ready.
+     */
     clone(): this;
+
     copy(source: Texture): this;
-    toJSON(meta: any): any;
+
+    /**
+     * Convert the texture to three.js {@link https://github.com/mrdoob/three.js/wiki/JSON-Object-Scene-format-4 | JSON Object/Scene format}.
+     * @param meta Optional object containing metadata.
+     */
+    toJSON(meta?: string | {}): {};
+
+    /**
+     * Frees the GPU-related resources allocated by this instance
+     * @remarks Call this method whenever this instance is no longer used in your app.
+     */
     dispose(): void;
-    transformUv(uv: Vector2): Vector2;
-    updateMatrix(): void;
 }

three/src/textures/VideoTexture.d.ts

@@ -1,34 +1,90 @@
 import { Texture } from './Texture';
-import { Mapping, Wrapping, TextureFilter, PixelFormat, TextureDataType } from '../constants';
+import {
+    Mapping,
+    Wrapping,
+    PixelFormat,
+    TextureDataType,
+    MagnificationTextureFilter,
+    MinificationTextureFilter,
+} from '../constants';
 
+/**
+ * Creates a texture for use with a video.
+ * @remarks
+ * Note: After the initial use of a texture, the video cannot be changed
+ * Instead, call {@link dispose | .dispose()} on the texture and instantiate a new one.
+ * @example
+ * ```typescript
+ * // assuming you have created a HTML video element with id="video"
+ * const video = document.getElementById('video');
+ * const texture = new THREE.VideoTexture(video);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_materials_video | materials / video}
+ * @see Example: {@link https://threejs.org/examples/#webgl_materials_video_webcam | materials / video / webcam}
+ * @see Example: {@link https://threejs.org/examples/#webgl_video_kinect | video / kinect}
+ * @see Example: {@link https://threejs.org/examples/#webgl_video_panorama_equirectangular | video / panorama / equirectangular}
+ * @see Example: {@link https://threejs.org/examples/#webxr_vr_video | vr / video}
+ * @see {@link https://threejs.org/docs/index.html#api/en/textures/VideoTexture | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/textures/VideoTexture.js | Source}
+ */
 export class VideoTexture extends Texture {
     /**
-     * @param video
-     * @param [mapping=THREE.Texture.DEFAULT_MAPPING]
-     * @param [wrapS=THREE.ClampToEdgeWrapping]
-     * @param [wrapT=THREE.ClampToEdgeWrapping]
-     * @param [magFilter=THREE.LinearFilter]
-     * @param [minFilter=THREE.LinearFilter]
-     * @param [format=THREE.RGBAFormat]
-     * @param [type=THREE.UnsignedByteType]
-     * @param [anisotropy=1]
+     * Create a new instance of {@link VideoTexture}
+     * @param video The video element to use as 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.LinearFilter}
+     * @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(
         video: HTMLVideoElement,
         mapping?: Mapping,
         wrapS?: Wrapping,
         wrapT?: Wrapping,
-        magFilter?: TextureFilter,
-        minFilter?: TextureFilter,
+        magFilter?: MagnificationTextureFilter,
+        minFilter?: MinificationTextureFilter,
         format?: PixelFormat,
         type?: TextureDataType,
         anisotropy?: number,
     );
 
+    /**
+     * Read-only flag to check if a given object is of type {@link VideoTexture}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
     readonly isVideoTexture: true;
 
     /**
-     * @default false
+     * @override
+     * @defaultValue {@link THREE.LinearFilter}
+     */
+    magFilter: MagnificationTextureFilter;
+
+    /**
+     * @override
+     * @defaultValue {@link THREE.LinearFilter}
+     */
+    minFilter: MinificationTextureFilter;
+
+    /**
+     * @override
+     * @defaultValue `false`
      */
     generateMipmaps: boolean;
+
+    /**
+     * @override
+     * You will **not** need to set this manually here as it is handled by the {@link update | update()} method.
+     */
+    set needsUpdate(value: boolean);
+
+    /**
+     * This is called automatically and sets {@link needsUpdate | .needsUpdate } to `true` every time a new frame is available.
+     */
+    update(): void;
 }

three/src/textures/types.d.ts

@@ -0,0 +1,9 @@
+export interface TextureImageData {
+    readonly data: Uint8ClampedArray;
+    readonly height: number;
+    readonly width: number;
+}
+
+export interface Texture3DImageData extends TextureImageData {
+    readonly depth: number;
+}

three/src/utils.d.ts

@@ -1,3 +1,6 @@
-import { Color } from './math/Color';
+import { Color, ColorKeyword } from './math/Color';
 
-export type ColorRepresentation = Color | string | number;
+export type ColorModelString = `${'rgb' | 'hsl'}(${string})`;
+export type HexColorString = `#${string}`;
+
+export type ColorRepresentation = Color | ColorKeyword | ColorModelString | HexColorString | number;