@types/three

Version 0.170.0
Published 27 days ago
1.32 MB
6 dependencies
MIT license

Install

npm i @types/three

yarn add @types/three

pnpm add @types/three

Overview

TypeScript definitions for three

Index

Variables

variable ACESFilmicToneMapping

const ACESFilmicToneMapping: number;

variable AddEquation

const AddEquation: number;

variable AdditiveAnimationBlendMode

const AdditiveAnimationBlendMode: number;

variable AdditiveBlending

const AdditiveBlending: number;

variable AddOperation

const AddOperation: number;

variable AgXToneMapping

const AgXToneMapping: number;

variable AlphaFormat

const AlphaFormat: number;

AlphaFormat discards the red, green and blue components and reads just the alpha component.

variable AlwaysCompare

const AlwaysCompare: number;

variable AlwaysDepth

const AlwaysDepth: number;

variable AlwaysStencilFunc

const AlwaysStencilFunc: number;

variable AnimationUtils

const AnimationUtils: {
    convertArray: typeof convertArray;
    isTypedArray: typeof isTypedArray;
    getKeyframeOrder: typeof getKeyframeOrder;
    sortedArray: typeof sortedArray;
    flattenJSON: typeof flattenJSON;
    subclip: typeof subclip;
    makeClipAdditive: typeof makeClipAdditive;
};

variable AttachedBindMode

const AttachedBindMode: string;

variable BackSide

const BackSide: number;

variable BasicDepthPacking

const BasicDepthPacking: number;

variable BasicShadowMap

const BasicShadowMap: number;

variable ByteType

const ByteType: number;

variable Cache

const Cache: {
    enabled: boolean;
    files: any;
    add(key: string, file: any): void;
    get(key: string): any;
    remove(key: string): void;
    clear(): void;
};

variable CineonToneMapping

const CineonToneMapping: number;

variable ClampToEdgeWrapping

const ClampToEdgeWrapping: number;

With ClampToEdgeWrapping the last pixel of the texture stretches to the edge of the mesh.
Remarks
This is the _default_ value and behaver for Wrapping Mapping.

variable ColorManagement

const ColorManagement: ColorManagement;

variable ConstantAlphaFactor

const ConstantAlphaFactor: number;

variable ConstantColorFactor

const ConstantColorFactor: number;

variable CubeReflectionMapping

const CubeReflectionMapping: number;

Remarks
This is the _default_ value and behaver for Cube Texture Mapping.

variable CubeRefractionMapping

const CubeRefractionMapping: number;

variable CubeUVReflectionMapping

const CubeUVReflectionMapping: number;

variable CullFaceBack

const CullFaceBack: number;

variable CullFaceFront

const CullFaceFront: number;

variable CullFaceFrontBack

const CullFaceFrontBack: number;

variable CullFaceNone

const CullFaceNone: number;

variable CustomBlending

const CustomBlending: number;

variable CustomToneMapping

const CustomToneMapping: number;

variable DataUtils

const DataUtils: {
    toHalfFloat: typeof toHalfFloat;
    fromHalfFloat: typeof fromHalfFloat;
};

variable DecrementStencilOp

const DecrementStencilOp: number;

variable DecrementWrapStencilOp

const DecrementWrapStencilOp: number;

variable DefaultLoadingManager

const DefaultLoadingManager: LoadingManager;

variable DepthFormat

const DepthFormat: number;

DepthFormat reads each element as a single depth value, converts it to floating point, and clamps to the range [0,1].
Remarks
This is the default for THREE.DepthTexture.

variable DepthStencilFormat

const DepthStencilFormat: number;

DepthStencilFormat reads each element is a pair of depth and stencil values. The depth component of the pair is interpreted as in DepthFormat. The stencil component is interpreted based on the depth + stencil internal format.

variable DetachedBindMode

const DetachedBindMode: string;

variable DoubleSide

const DoubleSide: number;

variable DstAlphaFactor

const DstAlphaFactor: number;

variable DstColorFactor

const DstColorFactor: number;

variable DynamicCopyUsage

const DynamicCopyUsage: number;

variable DynamicDrawUsage

const DynamicDrawUsage: number;

variable DynamicReadUsage

const DynamicReadUsage: number;

variable EqualCompare

const EqualCompare: number;

variable EqualDepth

const EqualDepth: number;

variable EqualStencilFunc

const EqualStencilFunc: number;

variable EquirectangularReflectionMapping

const EquirectangularReflectionMapping: number;

variable EquirectangularRefractionMapping

const EquirectangularRefractionMapping: number;

variable FloatType

const FloatType: number;

variable FrontSide

const FrontSide: number;

variable GLSL1

const GLSL1: string;

variable GLSL3

const GLSL3: string;

variable GreaterCompare

const GreaterCompare: number;

variable GreaterDepth

const GreaterDepth: number;

variable GreaterEqualCompare

const GreaterEqualCompare: number;

variable GreaterEqualDepth

const GreaterEqualDepth: number;

variable GreaterEqualStencilFunc

const GreaterEqualStencilFunc: number;

variable GreaterStencilFunc

const GreaterStencilFunc: number;

variable HalfFloatType

const HalfFloatType: number;

variable IncrementStencilOp

const IncrementStencilOp: number;

variable IncrementWrapStencilOp

const IncrementWrapStencilOp: number;

variable InterpolateDiscrete

const InterpolateDiscrete: number;

variable InterpolateLinear

const InterpolateLinear: number;

variable InterpolateSmooth

const InterpolateSmooth: number;

variable IntType

const IntType: number;

variable InvertStencilOp

const InvertStencilOp: number;

variable KeepStencilOp

const KeepStencilOp: number;

variable LessCompare

const LessCompare: number;

variable LessDepth

const LessDepth: number;

variable LessEqualCompare

const LessEqualCompare: number;

variable LessEqualDepth

const LessEqualDepth: number;

variable LessEqualStencilFunc

const LessEqualStencilFunc: number;

variable LessStencilFunc

const LessStencilFunc: number;

variable LinearFilter

const LinearFilter: number;

LinearFilter returns the weighted average of the four texture elements that are closest to the specified texture coordinates, and can include items wrapped or repeated from other parts of a texture, depending on the values of wrapS and wrapT, and on the exact mapping.

variable LinearMipmapLinearFilter

const LinearMipmapLinearFilter: number;

LinearMipmapLinearFilter is the default and chooses the two mipmaps that most closely match the size of the pixel being textured and uses the LinearFilter criterion to produce a texture value from each mipmap. The final texture value is a weighted average of those two values.

variable LinearMipMapLinearFilter

const LinearMipMapLinearFilter: number;

LinearMipMapLinearFilter is the default and chooses the two mipmaps that most closely match the size of the pixel being textured and uses the LinearFilter criterion to produce a texture value from each mipmap. The final texture value is a weighted average of those two values.

variable LinearMipmapNearestFilter

const LinearMipmapNearestFilter: number;

LinearMipmapNearestFilter chooses the mipmap that most closely matches the size of the pixel being textured and uses the LinearFilter criterion (a weighted average of the four texels that are closest to the center of the pixel) to produce a texture value.

variable LinearMipMapNearestFilter

const LinearMipMapNearestFilter: number;

LinearMipMapNearestFilter chooses the mipmap that most closely matches the size of the pixel being textured and uses the LinearFilter criterion (a weighted average of the four texels that are closest to the center of the pixel) to produce a texture value.

variable LinearSRGBColorSpace

const LinearSRGBColorSpace: string;

variable LinearToneMapping

const LinearToneMapping: number;

variable LinearTransfer

const LinearTransfer: string;

variable LoopOnce

const LoopOnce: number;

variable LoopPingPong

const LoopPingPong: number;

variable LoopRepeat

const LoopRepeat: number;

variable LuminanceAlphaFormat

const LuminanceAlphaFormat: number;

LuminanceAlphaFormat reads each element as a luminance/alpha double. The same process occurs as for the LuminanceFormat, except that the alpha channel may have values other than 1.0.

variable LuminanceFormat

const LuminanceFormat: number;

LuminanceFormat reads each element as a single luminance component. This is then converted to a floating point, clamped to the range [0,1], and then assembled into an RGBA element by placing the luminance value in the red, green and blue channels, and attaching 1.0 to the alpha channel.

variable MathUtils

const MathUtils: {
    DEG2RAD: typeof DEG2RAD;
    RAD2DEG: typeof RAD2DEG;
    generateUUID: typeof generateUUID;
    clamp: typeof clamp;
    euclideanModulo: typeof euclideanModulo;
    mapLinear: typeof mapLinear;
    inverseLerp: typeof inverseLerp;
    lerp: typeof lerp;
    damp: typeof damp;
    pingpong: typeof pingpong;
    smoothstep: typeof smoothstep;
    smootherstep: typeof smootherstep;
    randInt: typeof randInt;
    randFloat: typeof randFloat;
    randFloatSpread: typeof randFloatSpread;
    seededRandom: typeof seededRandom;
    degToRad: typeof degToRad;
    radToDeg: typeof radToDeg;
    isPowerOfTwo: typeof isPowerOfTwo;
    ceilPowerOfTwo: typeof ceilPowerOfTwo;
    floorPowerOfTwo: typeof floorPowerOfTwo;
    setQuaternionFromProperEuler: typeof setQuaternionFromProperEuler;
    normalize: typeof normalize;
    denormalize: typeof denormalize;
};

variable MaxEquation

const MaxEquation: number;

variable MinEquation

const MinEquation: number;

variable MirroredRepeatWrapping

const MirroredRepeatWrapping: number;

With MirroredRepeatWrapping the texture will repeats to infinity, mirroring on each repeat.

variable MixOperation

const MixOperation: number;

variable MultiplyBlending

const MultiplyBlending: number;

variable MultiplyOperation

const MultiplyOperation: number;

variable NearestFilter

const NearestFilter: number;

NearestFilter returns the value of the texture element that is nearest (in Manhattan distance) to the specified texture coordinates.

variable NearestMipmapLinearFilter

const NearestMipmapLinearFilter: number;

NearestMipmapLinearFilter chooses the two mipmaps that most closely match the size of the pixel being textured and uses the NearestFilter criterion to produce a texture value from each mipmap. The final texture value is a weighted average of those two values.

variable NearestMipMapLinearFilter

const NearestMipMapLinearFilter: number;

NearestMipMapLinearFilter chooses the two mipmaps that most closely match the size of the pixel being textured and uses the NearestFilter criterion to produce a texture value from each mipmap. The final texture value is a weighted average of those two values.

variable NearestMipmapNearestFilter

const NearestMipmapNearestFilter: number;

NearestMipmapNearestFilter chooses the mipmap that most closely matches the size of the pixel being textured and uses the NearestFilter criterion (the texel nearest to the center of the pixel) to produce a texture value.

variable NearestMipMapNearestFilter

const NearestMipMapNearestFilter: number;

NearestMipmapNearestFilter chooses the mipmap that most closely matches the size of the pixel being textured and uses the NearestFilter criterion (the texel nearest to the center of the pixel) to produce a texture value.

variable NeutralToneMapping

const NeutralToneMapping: number;

variable NeverCompare

const NeverCompare: number;

variable NeverDepth

const NeverDepth: number;

variable NeverStencilFunc

const NeverStencilFunc: number;

variable NoBlending

const NoBlending: number;

variable NoColorSpace

const NoColorSpace: string;

variable NormalAnimationBlendMode

const NormalAnimationBlendMode: number;

variable NormalBlending

const NormalBlending: number;

variable NotEqualCompare

const NotEqualCompare: number;

variable NotEqualDepth

const NotEqualDepth: number;

variable NotEqualStencilFunc

const NotEqualStencilFunc: number;

variable NoToneMapping

const NoToneMapping: number;

variable ObjectSpaceNormalMap

const ObjectSpaceNormalMap: number;

variable OneFactor

const OneFactor: number;

variable OneMinusConstantAlphaFactor

const OneMinusConstantAlphaFactor: number;

variable OneMinusConstantColorFactor

const OneMinusConstantColorFactor: number;

variable OneMinusDstAlphaFactor

const OneMinusDstAlphaFactor: number;

variable OneMinusDstColorFactor

const OneMinusDstColorFactor: number;

variable OneMinusSrcAlphaFactor

const OneMinusSrcAlphaFactor: number;

variable OneMinusSrcColorFactor

const OneMinusSrcColorFactor: number;

variable PCFShadowMap

const PCFShadowMap: number;

variable PCFSoftShadowMap

const PCFSoftShadowMap: number;

variable RED_GREEN_RGTC2_Format

const RED_GREEN_RGTC2_Format: number;

variable RED_RGTC1_Format

const RED_RGTC1_Format: number;

variable RedFormat

const RedFormat: number;

RedFormat discards the green and blue components and reads just the red component.

variable RedIntegerFormat

const RedIntegerFormat: number;

RedIntegerFormat discards the green and blue components and reads just the red component. The texels are read as integers instead of floating point.

variable ReinhardToneMapping

const ReinhardToneMapping: number;

variable RepeatWrapping

const RepeatWrapping: number;

With RepeatWrapping the texture will simply repeat to infinity.

variable ReplaceStencilOp

const ReplaceStencilOp: number;

variable ReverseSubtractEquation

const ReverseSubtractEquation: number;

variable REVISION

const REVISION: string;

variable RGB_BPTC_SIGNED_Format

const RGB_BPTC_SIGNED_Format: number;

variable RGB_BPTC_UNSIGNED_Format

const RGB_BPTC_UNSIGNED_Format: number;

variable RGB_ETC1_Format

const RGB_ETC1_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_etc1_ (ETC1) or _WEBGL_compressed_texture_etc_ (ETC2) WebGL extension.

variable RGB_ETC2_Format

const RGB_ETC2_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_etc1_ (ETC1) or _WEBGL_compressed_texture_etc_ (ETC2) WebGL extension.

variable RGB_PVRTC_2BPPV1_Format

const RGB_PVRTC_2BPPV1_Format: number;

RGB compression in 2-bit mode. One block for each 8×4 pixels.
Remarks
Require support for the _WEBGL_compressed_texture_pvrtc_ WebGL extension.

variable RGB_PVRTC_4BPPV1_Format

const RGB_PVRTC_4BPPV1_Format: number;

RGB compression in 4-bit mode. One block for each 4×4 pixels.
Remarks
Require support for the _WEBGL_compressed_texture_pvrtc_ WebGL extension.

variable RGB_S3TC_DXT1_Format

const RGB_S3TC_DXT1_Format: number;

A DXT1-compressed image in an RGB image format.
Remarks
Require support for the _WEBGL_compressed_texture_s3tc_ WebGL extension.

variable RGBA_ASTC_10x10_Format

const RGBA_ASTC_10x10_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_ASTC_10x5_Format

const RGBA_ASTC_10x5_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_ASTC_10x6_Format

const RGBA_ASTC_10x6_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_ASTC_10x8_Format

const RGBA_ASTC_10x8_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_ASTC_12x10_Format

const RGBA_ASTC_12x10_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_ASTC_12x12_Format

const RGBA_ASTC_12x12_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_ASTC_4x4_Format

const RGBA_ASTC_4x4_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_ASTC_5x4_Format

const RGBA_ASTC_5x4_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_ASTC_5x5_Format

const RGBA_ASTC_5x5_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_ASTC_6x5_Format

const RGBA_ASTC_6x5_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_ASTC_6x6_Format

const RGBA_ASTC_6x6_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_ASTC_8x5_Format

const RGBA_ASTC_8x5_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_ASTC_8x6_Format

const RGBA_ASTC_8x6_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_ASTC_8x8_Format

const RGBA_ASTC_8x8_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_astc_ WebGL extension.

variable RGBA_BPTC_Format

const RGBA_BPTC_Format: number;

Remarks
Require support for the _EXT_texture_compression_bptc_ WebGL extension.

variable RGBA_ETC2_EAC_Format

const RGBA_ETC2_EAC_Format: number;

Remarks
Require support for the _WEBGL_compressed_texture_etc1_ (ETC1) or _WEBGL_compressed_texture_etc_ (ETC2) WebGL extension.

variable RGBA_PVRTC_2BPPV1_Format

const RGBA_PVRTC_2BPPV1_Format: number;

RGBA compression in 2-bit mode. One block for each 8×4 pixels.
Remarks
Require support for the _WEBGL_compressed_texture_pvrtc_ WebGL extension.

variable RGBA_PVRTC_4BPPV1_Format

const RGBA_PVRTC_4BPPV1_Format: number;

RGBA compression in 4-bit mode. One block for each 4×4 pixels.
Remarks
Require support for the _WEBGL_compressed_texture_pvrtc_ WebGL extension.

variable RGBA_S3TC_DXT1_Format

const RGBA_S3TC_DXT1_Format: number;

A DXT1-compressed image in an RGB image format with a simple on/off alpha value.
Remarks
Require support for the _WEBGL_compressed_texture_s3tc_ WebGL extension.

variable RGBA_S3TC_DXT3_Format

const RGBA_S3TC_DXT3_Format: number;

A DXT3-compressed image in an RGBA image format. Compared to a 32-bit RGBA texture, it offers 4:1 compression.
Remarks
Require support for the _WEBGL_compressed_texture_s3tc_ WebGL extension.

variable RGBA_S3TC_DXT5_Format

const RGBA_S3TC_DXT5_Format: number;

A DXT5-compressed image in an RGBA image format. It also provides a 4:1 compression, but differs to the DXT3 compression in how the alpha compression is done.
Remarks
Require support for the _WEBGL_compressed_texture_s3tc_ WebGL extension.

variable RGBADepthPacking

const RGBADepthPacking: number;

variable RGBAFormat

const RGBAFormat: number;

RGBAFormat is the default and reads the red, green, blue and alpha components.

variable RGBAIntegerFormat

const RGBAIntegerFormat: number;

RGBAIntegerFormat reads the red, green, blue and alpha component
Remarks
This is the default for THREE.Texture.

variable RGBDepthPacking

const RGBDepthPacking: number;

variable RGBFormat

const RGBFormat: number;

variable RGBIntegerFormat

const RGBIntegerFormat: number;

RGBIntegerFormat discrads the alpha components and reads the red, green, and blue components.

variable RGDepthPacking

const RGDepthPacking: number;

variable RGFormat

const RGFormat: number;

RGFormat discards the alpha, and blue components and reads the red, and green components.

variable RGIntegerFormat

const RGIntegerFormat: number;

RGIntegerFormat discards the alpha, and blue components and reads the red, and green components. The texels are read as integers instead of floating point.

variable ShaderChunk

const ShaderChunk: {
    alphahash_fragment: string;
    alphahash_pars_fragment: string;
    alphamap_fragment: string;
    alphamap_pars_fragment: string;
    alphatest_fragment: string;
    alphatest_pars_fragment: string;
    aomap_fragment: string;
    aomap_pars_fragment: string;
    batching_pars_vertex: string;
    begin_vertex: string;
    beginnormal_vertex: string;
    bsdfs: string;
    iridescence_fragment: string;
    bumpmap_pars_fragment: string;
    clipping_planes_fragment: string;
    clipping_planes_pars_fragment: string;
    clipping_planes_pars_vertex: string;
    clipping_planes_vertex: string;
    color_fragment: string;
    color_pars_fragment: string;
    color_pars_vertex: string;
    color_vertex: string;
    common: string;
    cube_uv_reflection_fragment: string;
    defaultnormal_vertex: string;
    displacementmap_pars_vertex: string;
    displacementmap_vertex: string;
    emissivemap_fragment: string;
    emissivemap_pars_fragment: string;
    colorspace_fragment: string;
    colorspace_pars_fragment: string;
    envmap_fragment: string;
    envmap_common_pars_fragment: string;
    envmap_pars_fragment: string;
    envmap_pars_vertex: string;
    envmap_physical_pars_fragment: string;
    envmap_vertex: string;
    fog_vertex: string;
    fog_pars_vertex: string;
    fog_fragment: string;
    fog_pars_fragment: string;
    gradientmap_pars_fragment: string;
    lightmap_pars_fragment: string;
    lights_lambert_fragment: string;
    lights_lambert_pars_fragment: string;
    lights_pars_begin: string;
    lights_toon_fragment: string;
    lights_toon_pars_fragment: string;
    lights_phong_fragment: string;
    lights_phong_pars_fragment: string;
    lights_physical_fragment: string;
    lights_physical_pars_fragment: string;
    lights_fragment_begin: string;
    lights_fragment_maps: string;
    lights_fragment_end: string;
    logdepthbuf_fragment: string;
    logdepthbuf_pars_fragment: string;
    logdepthbuf_pars_vertex: string;
    logdepthbuf_vertex: string;
    map_fragment: string;
    map_pars_fragment: string;
    map_particle_fragment: string;
    map_particle_pars_fragment: string;
    metalnessmap_fragment: string;
    metalnessmap_pars_fragment: string;
    morphcolor_vertex: string;
    morphnormal_vertex: string;
    morphtarget_pars_vertex: string;
    morphtarget_vertex: string;
    normal_fragment_begin: string;
    normal_fragment_maps: string;
    normal_pars_fragment: string;
    normal_pars_vertex: string;
    normal_vertex: string;
    normalmap_pars_fragment: string;
    clearcoat_normal_fragment_begin: string;
    clearcoat_normal_fragment_maps: string;
    clearcoat_pars_fragment: string;
    iridescence_pars_fragment: string;
    opaque_fragment: string;
    packing: string;
    premultiplied_alpha_fragment: string;
    project_vertex: string;
    dithering_fragment: string;
    dithering_pars_fragment: string;
    roughnessmap_fragment: string;
    roughnessmap_pars_fragment: string;
    shadowmap_pars_fragment: string;
    shadowmap_pars_vertex: string;
    shadowmap_vertex: string;
    shadowmask_pars_fragment: string;
    skinbase_vertex: string;
    skinning_pars_vertex: string;
    skinning_vertex: string;
    skinnormal_vertex: string;
    specularmap_fragment: string;
    specularmap_pars_fragment: string;
    tonemapping_fragment: string;
    tonemapping_pars_fragment: string;
    transmission_fragment: string;
    transmission_pars_fragment: string;
    uv_pars_fragment: string;
    uv_pars_vertex: string;
    uv_vertex: string;
    worldpos_vertex: string;
    background_vert: string;
    background_frag: string;
    backgroundCube_vert: string;
    backgroundCube_frag: string;
    cube_vert: string;
    cube_frag: string;
    depth_vert: string;
    depth_frag: string;
    distanceRGBA_vert: string;
    distanceRGBA_frag: string;
    equirect_vert: string;
    equirect_frag: string;
    linedashed_vert: string;
    linedashed_frag: string;
    meshbasic_vert: string;
    meshbasic_frag: string;
    meshlambert_vert: string;
    meshlambert_frag: string;
    meshmatcap_vert: string;
    meshmatcap_frag: string;
    meshnormal_vert: string;
    meshnormal_frag: string;
    meshphong_vert: string;
    meshphong_frag: string;
    meshphysical_vert: string;
    meshphysical_frag: string;
    meshtoon_vert: string;
    meshtoon_frag: string;
    points_vert: string;
    points_frag: string;
    shadow_vert: string;
    shadow_frag: string;
    sprite_vert: string;
    sprite_frag: string;
};

variable ShaderLib

const ShaderLib: {
    [name: string]: ShaderLibShader;
    basic: ShaderLibShader;
    lambert: ShaderLibShader;
    phong: ShaderLibShader;
    standard: ShaderLibShader;
    matcap: ShaderLibShader;
    points: ShaderLibShader;
    dashed: ShaderLibShader;
    depth: ShaderLibShader;
    normal: ShaderLibShader;
    sprite: ShaderLibShader;
    background: ShaderLibShader;
    cube: ShaderLibShader;
    equirect: ShaderLibShader;
    distanceRGBA: ShaderLibShader;
    shadow: ShaderLibShader;
    physical: ShaderLibShader;
};

variable ShortType

const ShortType: number;

variable SIGNED_RED_GREEN_RGTC2_Format

const SIGNED_RED_GREEN_RGTC2_Format: number;

variable SIGNED_RED_RGTC1_Format

const SIGNED_RED_RGTC1_Format: number;

variable SrcAlphaFactor

const SrcAlphaFactor: number;

variable SrcAlphaSaturateFactor

const SrcAlphaSaturateFactor: number;

variable SrcColorFactor

const SrcColorFactor: number;

variable SRGBColorSpace

const SRGBColorSpace: string;

variable SRGBTransfer

const SRGBTransfer: string;

variable StaticCopyUsage

const StaticCopyUsage: number;

variable StaticDrawUsage

const StaticDrawUsage: number;

variable StaticReadUsage

const StaticReadUsage: number;

variable StreamCopyUsage

const StreamCopyUsage: number;

variable StreamDrawUsage

const StreamDrawUsage: number;

variable StreamReadUsage

const StreamReadUsage: number;

variable SubtractEquation

const SubtractEquation: number;

variable SubtractiveBlending

const SubtractiveBlending: number;

variable TangentSpaceNormalMap

const TangentSpaceNormalMap: number;

variable TextureUtils

const TextureUtils: {
    contain: typeof contain;
    cover: typeof cover;
    fill: typeof fill;
    getByteLength: typeof getByteLength;
};

A class containing utility functions for textures.

variable TriangleFanDrawMode

const TriangleFanDrawMode: number;

variable TrianglesDrawMode

const TrianglesDrawMode: number;

variable TriangleStripDrawMode

const TriangleStripDrawMode: number;

variable UniformsLib

const UniformsLib: {
    common: {
        diffuse: IUniform<Color>;
        opacity: IUniform<number>;
        map: IUniform<unknown>;
        mapTransform: IUniform<Matrix3>;
        alphaMap: IUniform<unknown>;
        alphaMapTransform: IUniform<Matrix3>;
        alphaTest: IUniform<number>;
    };
    specularmap: {
        specularMap: IUniform<unknown>;
        specularMapTransform: IUniform<Matrix3>;
    };
    envmap: {
        envMap: IUniform<unknown>;
        envMapRotation: IUniform<Matrix3>;
        flipEnvMap: IUniform<number>;
        reflectivity: IUniform<number>;
        ior: IUniform<number>;
        refractRatio: IUniform<number>;
    };
    aomap: {
        aoMap: IUniform<unknown>;
        aoMapIntensity: IUniform<number>;
        aoMapTransform: IUniform<Matrix3>;
    };
    lightmap: {
        lightMap: IUniform<number>;
        lightMapIntensity: IUniform<number>;
        lightMapTransform: IUniform<Matrix3>;
    };
    bumpmap: {
        bumpMap: IUniform<unknown>;
        bumpMapTransform: IUniform<Matrix3>;
        bumpScale: IUniform<number>;
    };
    normalmap: {
        normalMap: IUniform<unknown>;
        normalMapTransform: IUniform<Matrix3>;
        normalScale: IUniform<Vector2>;
    };
    displacementmap: {
        displacementMap: IUniform<unknown>;
        displacementMapTransform: IUniform<Matrix3>;
        displacementScale: IUniform<number>;
        displacementBias: IUniform<number>;
    };
    emissivemap: {
        emissiveMap: IUniform<unknown>;
        emissiveMapTransform: IUniform<Matrix3>;
    };
    metalnessmap: {
        metalnessMap: IUniform<unknown>;
        metalnessMapTransform: IUniform<Matrix3>;
    };
    roughnessmap: {
        roughnessMap: IUniform<unknown>;
        roughnessMapTransform: IUniform<Matrix3>;
    };
    gradientmap: { gradientMap: IUniform<unknown> };
    fog: {
        fogDensity: IUniform<number>;
        fogNear: IUniform<number>;
        fogFar: IUniform<number>;
        fogColor: IUniform<Color>;
    };
    lights: {
        ambientLightColor: IUniform<unknown[]>;
        lightProbe: IUniform<unknown[]>;
        directionalLights: {
            value: unknown[];
            properties: { direction: {}; color: {} };
        };
        directionalLightShadows: {
            value: unknown[];
            properties: {
                shadowIntensity: number;
                shadowBias: {};
                shadowNormalBias: {};
                shadowRadius: {};
                shadowMapSize: {};
            };
        };
        directionalShadowMap: IUniform<unknown[]>;
        directionalShadowMatrix: IUniform<unknown[]>;
        spotLights: {
            value: unknown[];
            properties: {
                color: {};
                position: {};
                direction: {};
                distance: {};
                coneCos: {};
                penumbraCos: {};
                decay: {};
            };
        };
        spotLightShadows: {
            value: unknown[];
            properties: {
                shadowIntensity: number;
                shadowBias: {};
                shadowNormalBias: {};
                shadowRadius: {};
                shadowMapSize: {};
            };
        };
        spotLightMap: IUniform<unknown[]>;
        spotShadowMap: IUniform<unknown[]>;
        spotLightMatrix: IUniform<unknown[]>;
        pointLights: {
            value: unknown[];
            properties: { color: {}; position: {}; decay: {}; distance: {} };
        };
        pointLightShadows: {
            value: unknown[];
            properties: {
                shadowIntensity: number;
                shadowBias: {};
                shadowNormalBias: {};
                shadowRadius: {};
                shadowMapSize: {};
                shadowCameraNear: {};
                shadowCameraFar: {};
            };
        };
        pointShadowMap: IUniform<unknown[]>;
        pointShadowMatrix: IUniform<unknown[]>;
        hemisphereLights: {
            value: unknown[];
            properties: { direction: {}; skycolor: {}; groundColor: {} };
        };
        rectAreaLights: {
            value: unknown[];
            properties: { color: {}; position: {}; width: {}; height: {} };
        };
        ltc_1: IUniform<unknown>;
        ltc_2: IUniform<unknown>;
    };
    points: {
        diffuse: IUniform<Color>;
        opacity: IUniform<number>;
        size: IUniform<number>;
        scale: IUniform<number>;
        map: IUniform<unknown>;
        alphaMap: IUniform<unknown>;
        alphaTest: IUniform<number>;
        uvTransform: IUniform<Matrix3>;
    };
    sprite:

@types/three

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable ACESFilmicToneMapping

variable AddEquation

variable AdditiveAnimationBlendMode

variable AdditiveBlending

variable AddOperation

variable AgXToneMapping

variable AlphaFormat

variable AlwaysCompare

variable AlwaysDepth

variable AlwaysStencilFunc

variable AnimationUtils

variable AttachedBindMode

variable BackSide

variable BasicDepthPacking

variable BasicShadowMap

variable ByteType

variable Cache

variable CineonToneMapping

variable ClampToEdgeWrapping

Remarks

variable ColorManagement

variable ConstantAlphaFactor

variable ConstantColorFactor

variable CubeReflectionMapping

Remarks

variable CubeRefractionMapping

variable CubeUVReflectionMapping

variable CullFaceBack

variable CullFaceFront

variable CullFaceFrontBack

variable CullFaceNone

variable CustomBlending

variable CustomToneMapping

variable DataUtils

variable DecrementStencilOp

variable DecrementWrapStencilOp

variable DefaultLoadingManager

variable DepthFormat

Remarks

variable DepthStencilFormat

variable DetachedBindMode

variable DoubleSide

variable DstAlphaFactor

variable DstColorFactor

variable DynamicCopyUsage

variable DynamicDrawUsage

variable DynamicReadUsage

variable EqualCompare

variable EqualDepth

variable EqualStencilFunc

variable EquirectangularReflectionMapping

variable EquirectangularRefractionMapping

variable FloatType

variable FrontSide

variable GLSL1

variable GLSL3

variable GreaterCompare

variable GreaterDepth

variable GreaterEqualCompare

variable GreaterEqualDepth

variable GreaterEqualStencilFunc

variable GreaterStencilFunc

variable HalfFloatType

variable IncrementStencilOp

variable IncrementWrapStencilOp

variable InterpolateDiscrete

variable InterpolateLinear

variable InterpolateSmooth