• Version 0.132.2
  • Published
  • 618 kB
  • No dependencies
  • MIT license


npm i @types/three
yarn add @types/three
pnpm add @types/three


TypeScript definitions for three







Type Aliases



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 AlphaFormat

            const AlphaFormat: number;

              variable AlwaysDepth

              const AlwaysDepth: number;

                variable AlwaysStencilFunc

                const AlwaysStencilFunc: number;

                  variable BackSide

                  const BackSide: number;

                    variable BasicDepthPacking

                    const BasicDepthPacking: number;

                      variable BasicShadowMap

                      const BasicShadowMap: number;

                        variable ByteType

                        const ByteType: number;

                          variable CineonToneMapping

                          const CineonToneMapping: number;

                            variable ClampToEdgeWrapping

                            const ClampToEdgeWrapping: number;

                              variable CubeReflectionMapping

                              const CubeReflectionMapping: number;

                                variable CubeRefractionMapping

                                const CubeRefractionMapping: number;

                                  variable CubeUVReflectionMapping

                                  const CubeUVReflectionMapping: number;

                                    variable CubeUVRefractionMapping

                                    const CubeUVRefractionMapping: 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 DecrementStencilOp

                                                const DecrementStencilOp: number;

                                                  variable DecrementWrapStencilOp

                                                  const DecrementWrapStencilOp: number;

                                                    variable DefaultLoadingManager

                                                    const DefaultLoadingManager: LoadingManager;

                                                      variable DepthFormat

                                                      const DepthFormat: number;

                                                        variable DepthStencilFormat

                                                        const DepthStencilFormat: number;

                                                          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 EqualDepth

                                                                      const EqualDepth: number;

                                                                        variable EqualStencilFunc

                                                                        const EqualStencilFunc: number;

                                                                          variable EquirectangularReflectionMapping

                                                                          const EquirectangularReflectionMapping: number;

                                                                            variable EquirectangularRefractionMapping

                                                                            const EquirectangularRefractionMapping: number;

                                                                              variable FlatShading

                                                                              const FlatShading: number;

                                                                                variable FloatType

                                                                                const FloatType: number;

                                                                                  variable FrontSide

                                                                                  const FrontSide: number;

                                                                                    variable GammaEncoding

                                                                                    const GammaEncoding: number;

                                                                                      variable GLSL1

                                                                                      const GLSL1: number;

                                                                                        variable GLSL3

                                                                                        const GLSL3: number;

                                                                                          variable GreaterDepth

                                                                                          const GreaterDepth: 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 LessDepth

                                                                                                                    const LessDepth: number;

                                                                                                                      variable LessEqualDepth

                                                                                                                      const LessEqualDepth: number;

                                                                                                                        variable LessEqualStencilFunc

                                                                                                                        const LessEqualStencilFunc: number;

                                                                                                                          variable LessStencilFunc

                                                                                                                          const LessStencilFunc: number;

                                                                                                                            variable LinearEncoding

                                                                                                                            const LinearEncoding: number;

                                                                                                                              variable LinearFilter

                                                                                                                              const LinearFilter: number;

                                                                                                                                variable LinearMipmapLinearFilter

                                                                                                                                const LinearMipmapLinearFilter: number;

                                                                                                                                  variable LinearMipMapLinearFilter

                                                                                                                                  const LinearMipMapLinearFilter: number;

                                                                                                                                    variable LinearMipmapNearestFilter

                                                                                                                                    const LinearMipmapNearestFilter: number;

                                                                                                                                      variable LinearMipMapNearestFilter

                                                                                                                                      const LinearMipMapNearestFilter: number;

                                                                                                                                        variable LinearToneMapping

                                                                                                                                        const LinearToneMapping: number;

                                                                                                                                          variable LinePieces

                                                                                                                                          const LinePieces: number;
                                                                                                                                          • Deprecated

                                                                                                                                          variable LineStrip

                                                                                                                                          const LineStrip: number;
                                                                                                                                          • Deprecated

                                                                                                                                          variable LoaderUtils

                                                                                                                                          const LoaderUtils: LoaderUtils;

                                                                                                                                            variable LogLuvEncoding

                                                                                                                                            const LogLuvEncoding: number;

                                                                                                                                              variable LoopOnce

                                                                                                                                              const LoopOnce: number;

                                                                                                                                                variable LoopPingPong

                                                                                                                                                const LoopPingPong: number;

                                                                                                                                                  variable LoopRepeat

                                                                                                                                                  const LoopRepeat: number;

                                                                                                                                                    variable LuminanceAlphaFormat

                                                                                                                                                    const LuminanceAlphaFormat: number;

                                                                                                                                                      variable LuminanceFormat

                                                                                                                                                      const LuminanceFormat: number;

                                                                                                                                                        variable MaxEquation

                                                                                                                                                        const MaxEquation: number;

                                                                                                                                                          variable MinEquation

                                                                                                                                                          const MinEquation: number;

                                                                                                                                                            variable MirroredRepeatWrapping

                                                                                                                                                            const MirroredRepeatWrapping: number;

                                                                                                                                                              variable MixOperation

                                                                                                                                                              const MixOperation: number;

                                                                                                                                                                variable MultiplyBlending

                                                                                                                                                                const MultiplyBlending: number;

                                                                                                                                                                  variable MultiplyOperation

                                                                                                                                                                  const MultiplyOperation: number;

                                                                                                                                                                    variable NearestFilter

                                                                                                                                                                    const NearestFilter: number;

                                                                                                                                                                      variable NearestMipmapLinearFilter

                                                                                                                                                                      const NearestMipmapLinearFilter: number;

                                                                                                                                                                        variable NearestMipMapLinearFilter

                                                                                                                                                                        const NearestMipMapLinearFilter: number;

                                                                                                                                                                          variable NearestMipmapNearestFilter

                                                                                                                                                                          const NearestMipmapNearestFilter: number;

                                                                                                                                                                            variable NearestMipMapNearestFilter

                                                                                                                                                                            const NearestMipMapNearestFilter: number;

                                                                                                                                                                              variable NeverDepth

                                                                                                                                                                              const NeverDepth: number;

                                                                                                                                                                                variable NeverStencilFunc

                                                                                                                                                                                const NeverStencilFunc: number;

                                                                                                                                                                                  variable NoBlending

                                                                                                                                                                                  const NoBlending: number;

                                                                                                                                                                                    variable NormalAnimationBlendMode

                                                                                                                                                                                    const NormalAnimationBlendMode: number;

                                                                                                                                                                                      variable NormalBlending

                                                                                                                                                                                      const NormalBlending: 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 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 RedFormat

                                                                                                                                                                                                              const RedFormat: number;

                                                                                                                                                                                                                variable RedIntegerFormat

                                                                                                                                                                                                                const RedIntegerFormat: number;

                                                                                                                                                                                                                  variable ReinhardToneMapping

                                                                                                                                                                                                                  const ReinhardToneMapping: number;

                                                                                                                                                                                                                    variable RepeatWrapping

                                                                                                                                                                                                                    const RepeatWrapping: number;

                                                                                                                                                                                                                      variable ReplaceStencilOp

                                                                                                                                                                                                                      const ReplaceStencilOp: number;

                                                                                                                                                                                                                        variable ReverseSubtractEquation

                                                                                                                                                                                                                        const ReverseSubtractEquation: number;

                                                                                                                                                                                                                          variable REVISION

                                                                                                                                                                                                                          const REVISION: string;

                                                                                                                                                                                                                            variable RGB_ETC1_Format

                                                                                                                                                                                                                            const RGB_ETC1_Format: number;

                                                                                                                                                                                                                              variable RGB_ETC2_Format

                                                                                                                                                                                                                              const RGB_ETC2_Format: number;

                                                                                                                                                                                                                                variable RGB_PVRTC_2BPPV1_Format

                                                                                                                                                                                                                                const RGB_PVRTC_2BPPV1_Format: number;

                                                                                                                                                                                                                                  variable RGB_PVRTC_4BPPV1_Format

                                                                                                                                                                                                                                  const RGB_PVRTC_4BPPV1_Format: number;

                                                                                                                                                                                                                                    variable RGB_S3TC_DXT1_Format

                                                                                                                                                                                                                                    const RGB_S3TC_DXT1_Format: number;

                                                                                                                                                                                                                                      variable RGBA_ASTC_10x10_Format

                                                                                                                                                                                                                                      const RGBA_ASTC_10x10_Format: number;

                                                                                                                                                                                                                                        variable RGBA_ASTC_10x5_Format

                                                                                                                                                                                                                                        const RGBA_ASTC_10x5_Format: number;

                                                                                                                                                                                                                                          variable RGBA_ASTC_10x6_Format

                                                                                                                                                                                                                                          const RGBA_ASTC_10x6_Format: number;

                                                                                                                                                                                                                                            variable RGBA_ASTC_10x8_Format

                                                                                                                                                                                                                                            const RGBA_ASTC_10x8_Format: number;

                                                                                                                                                                                                                                              variable RGBA_ASTC_12x10_Format

                                                                                                                                                                                                                                              const RGBA_ASTC_12x10_Format: number;

                                                                                                                                                                                                                                                variable RGBA_ASTC_12x12_Format

                                                                                                                                                                                                                                                const RGBA_ASTC_12x12_Format: number;

                                                                                                                                                                                                                                                  variable RGBA_ASTC_4x4_Format

                                                                                                                                                                                                                                                  const RGBA_ASTC_4x4_Format: number;

                                                                                                                                                                                                                                                    variable RGBA_ASTC_5x4_Format

                                                                                                                                                                                                                                                    const RGBA_ASTC_5x4_Format: number;

                                                                                                                                                                                                                                                      variable RGBA_ASTC_5x5_Format

                                                                                                                                                                                                                                                      const RGBA_ASTC_5x5_Format: number;

                                                                                                                                                                                                                                                        variable RGBA_ASTC_6x5_Format

                                                                                                                                                                                                                                                        const RGBA_ASTC_6x5_Format: number;

                                                                                                                                                                                                                                                          variable RGBA_ASTC_6x6_Format

                                                                                                                                                                                                                                                          const RGBA_ASTC_6x6_Format: number;

                                                                                                                                                                                                                                                            variable RGBA_ASTC_8x5_Format

                                                                                                                                                                                                                                                            const RGBA_ASTC_8x5_Format: number;

                                                                                                                                                                                                                                                              variable RGBA_ASTC_8x6_Format

                                                                                                                                                                                                                                                              const RGBA_ASTC_8x6_Format: number;

                                                                                                                                                                                                                                                                variable RGBA_ASTC_8x8_Format

                                                                                                                                                                                                                                                                const RGBA_ASTC_8x8_Format: number;

                                                                                                                                                                                                                                                                  variable RGBA_BPTC_Format

                                                                                                                                                                                                                                                                  const RGBA_BPTC_Format: number;

                                                                                                                                                                                                                                                                    variable RGBA_ETC2_EAC_Format

                                                                                                                                                                                                                                                                    const RGBA_ETC2_EAC_Format: number;

                                                                                                                                                                                                                                                                      variable RGBA_PVRTC_2BPPV1_Format

                                                                                                                                                                                                                                                                      const RGBA_PVRTC_2BPPV1_Format: number;

                                                                                                                                                                                                                                                                        variable RGBA_PVRTC_4BPPV1_Format

                                                                                                                                                                                                                                                                        const RGBA_PVRTC_4BPPV1_Format: number;

                                                                                                                                                                                                                                                                          variable RGBA_S3TC_DXT1_Format

                                                                                                                                                                                                                                                                          const RGBA_S3TC_DXT1_Format: number;

                                                                                                                                                                                                                                                                            variable RGBA_S3TC_DXT3_Format

                                                                                                                                                                                                                                                                            const RGBA_S3TC_DXT3_Format: number;

                                                                                                                                                                                                                                                                              variable RGBA_S3TC_DXT5_Format

                                                                                                                                                                                                                                                                              const RGBA_S3TC_DXT5_Format: number;

                                                                                                                                                                                                                                                                                variable RGBADepthPacking

                                                                                                                                                                                                                                                                                const RGBADepthPacking: number;

                                                                                                                                                                                                                                                                                  variable RGBAFormat

                                                                                                                                                                                                                                                                                  const RGBAFormat: number;

                                                                                                                                                                                                                                                                                    variable RGBAIntegerFormat

                                                                                                                                                                                                                                                                                    const RGBAIntegerFormat: number;

                                                                                                                                                                                                                                                                                      variable RGBDEncoding

                                                                                                                                                                                                                                                                                      const RGBDEncoding: number;

                                                                                                                                                                                                                                                                                        variable RGBEEncoding

                                                                                                                                                                                                                                                                                        const RGBEEncoding: number;

                                                                                                                                                                                                                                                                                          variable RGBEFormat

                                                                                                                                                                                                                                                                                          const RGBEFormat: number;

                                                                                                                                                                                                                                                                                            variable RGBFormat

                                                                                                                                                                                                                                                                                            const RGBFormat: number;

                                                                                                                                                                                                                                                                                              variable RGBIntegerFormat

                                                                                                                                                                                                                                                                                              const RGBIntegerFormat: number;

                                                                                                                                                                                                                                                                                                variable RGBM16Encoding

                                                                                                                                                                                                                                                                                                const RGBM16Encoding: number;

                                                                                                                                                                                                                                                                                                  variable RGBM7Encoding

                                                                                                                                                                                                                                                                                                  const RGBM7Encoding: number;

                                                                                                                                                                                                                                                                                                    variable RGFormat

                                                                                                                                                                                                                                                                                                    const RGFormat: number;

                                                                                                                                                                                                                                                                                                      variable RGIntegerFormat

                                                                                                                                                                                                                                                                                                      const RGIntegerFormat: number;

                                                                                                                                                                                                                                                                                                        variable ShaderChunk

                                                                                                                                                                                                                                                                                                        let ShaderChunk: {
                                                                                                                                                                                                                                                                                                        [name: string]: string;
                                                                                                                                                                                                                                                                                                        alphamap_fragment: string;
                                                                                                                                                                                                                                                                                                        alphamap_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        alphatest_fragment: string;
                                                                                                                                                                                                                                                                                                        aomap_fragment: string;
                                                                                                                                                                                                                                                                                                        aomap_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        begin_vertex: string;
                                                                                                                                                                                                                                                                                                        beginnormal_vertex: string;
                                                                                                                                                                                                                                                                                                        bsdfs: 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_frag: string;
                                                                                                                                                                                                                                                                                                        cube_vert: string;
                                                                                                                                                                                                                                                                                                        cube_uv_reflection_fragment: string;
                                                                                                                                                                                                                                                                                                        defaultnormal_vertex: string;
                                                                                                                                                                                                                                                                                                        depth_frag: string;
                                                                                                                                                                                                                                                                                                        depth_vert: string;
                                                                                                                                                                                                                                                                                                        distanceRGBA_frag: string;
                                                                                                                                                                                                                                                                                                        distanceRGBA_vert: string;
                                                                                                                                                                                                                                                                                                        displacementmap_vertex: string;
                                                                                                                                                                                                                                                                                                        displacementmap_pars_vertex: string;
                                                                                                                                                                                                                                                                                                        emissivemap_fragment: string;
                                                                                                                                                                                                                                                                                                        emissivemap_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        encodings_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        encodings_fragment: string;
                                                                                                                                                                                                                                                                                                        envmap_fragment: string;
                                                                                                                                                                                                                                                                                                        envmap_common_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        envmap_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        envmap_pars_vertex: string;
                                                                                                                                                                                                                                                                                                        envmap_vertex: string;
                                                                                                                                                                                                                                                                                                        equirect_frag: string;
                                                                                                                                                                                                                                                                                                        equirect_vert: string;
                                                                                                                                                                                                                                                                                                        fog_fragment: string;
                                                                                                                                                                                                                                                                                                        fog_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        linedashed_frag: string;
                                                                                                                                                                                                                                                                                                        linedashed_vert: string;
                                                                                                                                                                                                                                                                                                        lightmap_fragment: string;
                                                                                                                                                                                                                                                                                                        lightmap_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        lights_lambert_vertex: string;
                                                                                                                                                                                                                                                                                                        lights_pars_begin: string;
                                                                                                                                                                                                                                                                                                        envmap_physical_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        lights_pars_map: 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;
                                                                                                                                                                                                                                                                                                        meshbasic_frag: string;
                                                                                                                                                                                                                                                                                                        meshbasic_vert: string;
                                                                                                                                                                                                                                                                                                        meshlambert_frag: string;
                                                                                                                                                                                                                                                                                                        meshlambert_vert: string;
                                                                                                                                                                                                                                                                                                        meshphong_frag: string;
                                                                                                                                                                                                                                                                                                        meshphong_vert: string;
                                                                                                                                                                                                                                                                                                        meshphysical_frag: string;
                                                                                                                                                                                                                                                                                                        meshphysical_vert: string;
                                                                                                                                                                                                                                                                                                        metalnessmap_fragment: string;
                                                                                                                                                                                                                                                                                                        metalnessmap_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        morphnormal_vertex: string;
                                                                                                                                                                                                                                                                                                        morphtarget_pars_vertex: string;
                                                                                                                                                                                                                                                                                                        morphtarget_vertex: string;
                                                                                                                                                                                                                                                                                                        normal_flip: string;
                                                                                                                                                                                                                                                                                                        normal_frag: string;
                                                                                                                                                                                                                                                                                                        normal_fragment_begin: string;
                                                                                                                                                                                                                                                                                                        normal_fragment_maps: string;
                                                                                                                                                                                                                                                                                                        normal_vert: string;
                                                                                                                                                                                                                                                                                                        normalmap_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        clearcoat_normal_fragment_begin: string;
                                                                                                                                                                                                                                                                                                        clearcoat_normal_fragment_maps: string;
                                                                                                                                                                                                                                                                                                        clearcoat_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        packing: string;
                                                                                                                                                                                                                                                                                                        points_frag: string;
                                                                                                                                                                                                                                                                                                        points_vert: string;
                                                                                                                                                                                                                                                                                                        shadow_frag: string;
                                                                                                                                                                                                                                                                                                        shadow_vert: string;
                                                                                                                                                                                                                                                                                                        premultiplied_alpha_fragment: string;
                                                                                                                                                                                                                                                                                                        project_vertex: 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;
                                                                                                                                                                                                                                                                                                        uv2_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        uv2_pars_vertex: string;
                                                                                                                                                                                                                                                                                                        uv2_vertex: string;
                                                                                                                                                                                                                                                                                                        uv_pars_fragment: string;
                                                                                                                                                                                                                                                                                                        uv_pars_vertex: string;
                                                                                                                                                                                                                                                                                                        uv_vertex: string;
                                                                                                                                                                                                                                                                                                        worldpos_vertex: string;

                                                                                                                                                                                                                                                                                                          variable ShaderLib

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

                                                                                                                                                                                                                                                                                                            variable ShortType

                                                                                                                                                                                                                                                                                                            const ShortType: number;

                                                                                                                                                                                                                                                                                                              variable SmoothShading

                                                                                                                                                                                                                                                                                                              const SmoothShading: number;

                                                                                                                                                                                                                                                                                                                variable SrcAlphaFactor

                                                                                                                                                                                                                                                                                                                const SrcAlphaFactor: number;

                                                                                                                                                                                                                                                                                                                  variable SrcAlphaSaturateFactor

                                                                                                                                                                                                                                                                                                                  const SrcAlphaSaturateFactor: number;

                                                                                                                                                                                                                                                                                                                    variable SrcColorFactor

                                                                                                                                                                                                                                                                                                                    const SrcColorFactor: number;

                                                                                                                                                                                                                                                                                                                      variable SRGB8_ALPHA8_ASTC_10x10_Format

                                                                                                                                                                                                                                                                                                                      const SRGB8_ALPHA8_ASTC_10x10_Format: number;

                                                                                                                                                                                                                                                                                                                        variable SRGB8_ALPHA8_ASTC_10x5_Format

                                                                                                                                                                                                                                                                                                                        const SRGB8_ALPHA8_ASTC_10x5_Format: number;

                                                                                                                                                                                                                                                                                                                          variable SRGB8_ALPHA8_ASTC_10x6_Format

                                                                                                                                                                                                                                                                                                                          const SRGB8_ALPHA8_ASTC_10x6_Format: number;

                                                                                                                                                                                                                                                                                                                            variable SRGB8_ALPHA8_ASTC_10x8_Format

                                                                                                                                                                                                                                                                                                                            const SRGB8_ALPHA8_ASTC_10x8_Format: number;

                                                                                                                                                                                                                                                                                                                              variable SRGB8_ALPHA8_ASTC_12x10_Format

                                                                                                                                                                                                                                                                                                                              const SRGB8_ALPHA8_ASTC_12x10_Format: number;

                                                                                                                                                                                                                                                                                                                                variable SRGB8_ALPHA8_ASTC_12x12_Format

                                                                                                                                                                                                                                                                                                                                const SRGB8_ALPHA8_ASTC_12x12_Format: number;

                                                                                                                                                                                                                                                                                                                                  variable SRGB8_ALPHA8_ASTC_4x4_Format

                                                                                                                                                                                                                                                                                                                                  const SRGB8_ALPHA8_ASTC_4x4_Format: number;

                                                                                                                                                                                                                                                                                                                                    variable SRGB8_ALPHA8_ASTC_5x4_Format

                                                                                                                                                                                                                                                                                                                                    const SRGB8_ALPHA8_ASTC_5x4_Format: number;

                                                                                                                                                                                                                                                                                                                                      variable SRGB8_ALPHA8_ASTC_5x5_Format

                                                                                                                                                                                                                                                                                                                                      const SRGB8_ALPHA8_ASTC_5x5_Format: number;

                                                                                                                                                                                                                                                                                                                                        variable SRGB8_ALPHA8_ASTC_6x5_Format

                                                                                                                                                                                                                                                                                                                                        const SRGB8_ALPHA8_ASTC_6x5_Format: number;

                                                                                                                                                                                                                                                                                                                                          variable SRGB8_ALPHA8_ASTC_6x6_Format

                                                                                                                                                                                                                                                                                                                                          const SRGB8_ALPHA8_ASTC_6x6_Format: number;

                                                                                                                                                                                                                                                                                                                                            variable SRGB8_ALPHA8_ASTC_8x5_Format

                                                                                                                                                                                                                                                                                                                                            const SRGB8_ALPHA8_ASTC_8x5_Format: number;

                                                                                                                                                                                                                                                                                                                                              variable SRGB8_ALPHA8_ASTC_8x6_Format

                                                                                                                                                                                                                                                                                                                                              const SRGB8_ALPHA8_ASTC_8x6_Format: number;

                                                                                                                                                                                                                                                                                                                                                variable SRGB8_ALPHA8_ASTC_8x8_Format

                                                                                                                                                                                                                                                                                                                                                const SRGB8_ALPHA8_ASTC_8x8_Format: number;

                                                                                                                                                                                                                                                                                                                                                  variable sRGBEncoding

                                                                                                                                                                                                                                                                                                                                                  const sRGBEncoding: number;

                                                                                                                                                                                                                                                                                                                                                    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 TriangleFanDrawMode

                                                                                                                                                                                                                                                                                                                                                                      const TriangleFanDrawMode: number;

                                                                                                                                                                                                                                                                                                                                                                        variable TrianglesDrawMode

                                                                                                                                                                                                                                                                                                                                                                        const TrianglesDrawMode: number;

                                                                                                                                                                                                                                                                                                                                                                          variable TriangleStripDrawMode

                                                                                                                                                                                                                                                                                                                                                                          const TriangleStripDrawMode: number;

                                                                                                                                                                                                                                                                                                                                                                            variable UniformsLib

                                                                                                                                                                                                                                                                                                                                                                            let UniformsLib: {
                                                                                                                                                                                                                                                                                                                                                                            common: {
                                                                                                                                                                                                                                                                                                                                                                            diffuse: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            opacity: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            map: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            uvTransform: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            uv2Transform: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            alphaMap: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            specularmap: { specularMap: IUniform };
                                                                                                                                                                                                                                                                                                                                                                            envmap: {
                                                                                                                                                                                                                                                                                                                                                                            envMap: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            flipEnvMap: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            reflectivity: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            refractionRatio: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            maxMipLevel: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            aomap: { aoMap: IUniform; aoMapIntensity: IUniform };
                                                                                                                                                                                                                                                                                                                                                                            lightmap: { lightMap: IUniform; lightMapIntensity: IUniform };
                                                                                                                                                                                                                                                                                                                                                                            emissivemap: { emissiveMap: IUniform };
                                                                                                                                                                                                                                                                                                                                                                            bumpmap: { bumpMap: IUniform; bumpScale: IUniform };
                                                                                                                                                                                                                                                                                                                                                                            normalmap: { normalMap: IUniform; normalScale: IUniform };
                                                                                                                                                                                                                                                                                                                                                                            displacementmap: {
                                                                                                                                                                                                                                                                                                                                                                            displacementMap: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            displacementScale: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            displacementBias: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            roughnessmap: { roughnessMap: IUniform };
                                                                                                                                                                                                                                                                                                                                                                            metalnessmap: { metalnessMap: IUniform };
                                                                                                                                                                                                                                                                                                                                                                            gradientmap: { gradientMap: IUniform };
                                                                                                                                                                                                                                                                                                                                                                            fog: {
                                                                                                                                                                                                                                                                                                                                                                            fogDensity: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            fogNear: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            fogFar: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            fogColor: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            lights: {
                                                                                                                                                                                                                                                                                                                                                                            ambientLightColor: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            directionalLights: {
                                                                                                                                                                                                                                                                                                                                                                            value: any[];
                                                                                                                                                                                                                                                                                                                                                                            properties: { direction: {}; color: {} };
                                                                                                                                                                                                                                                                                                                                                                            directionalLightShadows: {
                                                                                                                                                                                                                                                                                                                                                                            value: any[];
                                                                                                                                                                                                                                                                                                                                                                            properties: {
                                                                                                                                                                                                                                                                                                                                                                            shadowBias: {};
                                                                                                                                                                                                                                                                                                                                                                            shadowNormalBias: {};
                                                                                                                                                                                                                                                                                                                                                                            shadowRadius: {};
                                                                                                                                                                                                                                                                                                                                                                            shadowMapSize: {};
                                                                                                                                                                                                                                                                                                                                                                            directionalShadowMap: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            directionalShadowMatrix: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            spotLights: {
                                                                                                                                                                                                                                                                                                                                                                            value: any[];
                                                                                                                                                                                                                                                                                                                                                                            properties: {
                                                                                                                                                                                                                                                                                                                                                                            color: {};
                                                                                                                                                                                                                                                                                                                                                                            position: {};
                                                                                                                                                                                                                                                                                                                                                                            direction: {};
                                                                                                                                                                                                                                                                                                                                                                            distance: {};
                                                                                                                                                                                                                                                                                                                                                                            coneCos: {};
                                                                                                                                                                                                                                                                                                                                                                            penumbraCos: {};
                                                                                                                                                                                                                                                                                                                                                                            decay: {};
                                                                                                                                                                                                                                                                                                                                                                            spotLightShadows: {
                                                                                                                                                                                                                                                                                                                                                                            value: any[];
                                                                                                                                                                                                                                                                                                                                                                            properties: {
                                                                                                                                                                                                                                                                                                                                                                            shadowBias: {};
                                                                                                                                                                                                                                                                                                                                                                            shadowNormalBias: {};
                                                                                                                                                                                                                                                                                                                                                                            shadowRadius: {};
                                                                                                                                                                                                                                                                                                                                                                            shadowMapSize: {};
                                                                                                                                                                                                                                                                                                                                                                            spotShadowMap: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            spotShadowMatrix: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            pointLights: {
                                                                                                                                                                                                                                                                                                                                                                            value: any[];
                                                                                                                                                                                                                                                                                                                                                                            properties: { color: {}; position: {}; decay: {}; distance: {} };
                                                                                                                                                                                                                                                                                                                                                                            pointLightShadows: {
                                                                                                                                                                                                                                                                                                                                                                            value: any[];
                                                                                                                                                                                                                                                                                                                                                                            properties: {
                                                                                                                                                                                                                                                                                                                                                                            shadowBias: {};
                                                                                                                                                                                                                                                                                                                                                                            shadowNormalBias: {};
                                                                                                                                                                                                                                                                                                                                                                            shadowRadius: {};
                                                                                                                                                                                                                                                                                                                                                                            shadowMapSize: {};
                                                                                                                                                                                                                                                                                                                                                                            pointShadowMap: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            pointShadowMatrix: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            hemisphereLights: {
                                                                                                                                                                                                                                                                                                                                                                            value: any[];
                                                                                                                                                                                                                                                                                                                                                                            properties: { direction: {}; skycolor: {}; groundColor: {} };
                                                                                                                                                                                                                                                                                                                                                                            rectAreaLights: {
                                                                                                                                                                                                                                                                                                                                                                            value: any[];
                                                                                                                                                                                                                                                                                                                                                                            properties: { color: {}; position: {}; width: {}; height: {} };
                                                                                                                                                                                                                                                                                                                                                                            points: {
                                                                                                                                                                                                                                                                                                                                                                            diffuse: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            opacity: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            size: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            scale: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            map: IUniform;
                                                                                                                                                                                                                                                                                                                                                                            uvTransform: IUniform;

                                                                                                                                                                                                                                                                                                                                                                              variable UnsignedByteType

                                                                                                                                                                                                                                                                                                                                                                              const UnsignedByteType: number;

                                                                                                                                                                                                                                                                                                                                                                                variable UnsignedInt248Type

                                                                                                                                                                                                                                                                                                                                                                                const UnsignedInt248Type: number;

                                                                                                                                                                                                                                                                                                                                                                                  variable UnsignedIntType

                                                                                                                                                                                                                                                                                                                                                                                  const UnsignedIntType: number;

                                                                                                                                                                                                                                                                                                                                                                                    variable UnsignedShort4444Type

                                                                                                                                                                                                                                                                                                                                                                                    const UnsignedShort4444Type: number;

                                                                                                                                                                                                                                                                                                                                                                                      variable UnsignedShort5551Type

                                                                                                                                                                                                                                                                                                                                                                                      const UnsignedShort5551Type: number;

                                                                                                                                                                                                                                                                                                                                                                                        variable UnsignedShort565Type

                                                                                                                                                                                                                                                                                                                                                                                        const UnsignedShort565Type: number;

                                                                                                                                                                                                                                                                                                                                                                                          variable UnsignedShortType

                                                                                                                                                                                                                                                                                                                                                                                          const UnsignedShortType: number;

                                                                                                                                                                                                                                                                                                                                                                                            variable UVMapping

                                                                                                                                                                                                                                                                                                                                                                                            const UVMapping: number;

                                                                                                                                                                                                                                                                                                                                                                                              variable VSMShadowMap

                                                                                                                                                                                                                                                                                                                                                                                              const VSMShadowMap: number;

                                                                                                                                                                                                                                                                                                                                                                                                variable WrapAroundEnding

                                                                                                                                                                                                                                                                                                                                                                                                const WrapAroundEnding: number;

                                                                                                                                                                                                                                                                                                                                                                                                  variable ZeroCurvatureEnding

                                                                                                                                                                                                                                                                                                                                                                                                  const ZeroCurvatureEnding: number;

                                                                                                                                                                                                                                                                                                                                                                                                    variable ZeroFactor

                                                                                                                                                                                                                                                                                                                                                                                                    const ZeroFactor: number;

                                                                                                                                                                                                                                                                                                                                                                                                      variable ZeroSlopeEnding

                                                                                                                                                                                                                                                                                                                                                                                                      const ZeroSlopeEnding: number;

                                                                                                                                                                                                                                                                                                                                                                                                        variable ZeroStencilOp

                                                                                                                                                                                                                                                                                                                                                                                                        const ZeroStencilOp: number;


                                                                                                                                                                                                                                                                                                                                                                                                          function cloneUniforms

                                                                                                                                                                                                                                                                                                                                                                                                          cloneUniforms: (uniforms_src: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                            function mergeUniforms

                                                                                                                                                                                                                                                                                                                                                                                                            mergeUniforms: (uniforms: any[]) => any;

                                                                                                                                                                                                                                                                                                                                                                                                              function WebGLShader

                                                                                                                                                                                                                                                                                                                                                                                                              WebGLShader: (
                                                                                                                                                                                                                                                                                                                                                                                                              gl: WebGLRenderingContext,
                                                                                                                                                                                                                                                                                                                                                                                                              type: string,
                                                                                                                                                                                                                                                                                                                                                                                                              string: string
                                                                                                                                                                                                                                                                                                                                                                                                              ) => WebGLShader;


                                                                                                                                                                                                                                                                                                                                                                                                                class AmbientLight

                                                                                                                                                                                                                                                                                                                                                                                                                class AmbientLight extends Light {}
                                                                                                                                                                                                                                                                                                                                                                                                                • This light's color gets applied to all the objects in the scene globally.



                                                                                                                                                                                                                                                                                                                                                                                                                constructor(color?: ColorRepresentation, intensity?: number);
                                                                                                                                                                                                                                                                                                                                                                                                                • This creates a Ambientlight with a color.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter color

                                                                                                                                                                                                                                                                                                                                                                                                                  Numeric value of the RGB component of the color or a Color instance.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter intensity

                                                                                                                                                                                                                                                                                                                                                                                                                property isAmbientLight

                                                                                                                                                                                                                                                                                                                                                                                                                readonly isAmbientLight: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                  type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                  • 'AmbientLight'

                                                                                                                                                                                                                                                                                                                                                                                                                  class AmbientLightProbe

                                                                                                                                                                                                                                                                                                                                                                                                                  class AmbientLightProbe extends LightProbe {}


                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(color?: ColorRepresentation, intensity?: number);

                                                                                                                                                                                                                                                                                                                                                                                                                      property isAmbientLightProbe

                                                                                                                                                                                                                                                                                                                                                                                                                      readonly isAmbientLightProbe: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                        class AnimationAction

                                                                                                                                                                                                                                                                                                                                                                                                                        class AnimationAction {}


                                                                                                                                                                                                                                                                                                                                                                                                                          mixer: AnimationMixer,
                                                                                                                                                                                                                                                                                                                                                                                                                          clip: AnimationClip,
                                                                                                                                                                                                                                                                                                                                                                                                                          localRoot?: Object3D<Event>,
                                                                                                                                                                                                                                                                                                                                                                                                                          blendMode?: number

                                                                                                                                                                                                                                                                                                                                                                                                                            property blendMode

                                                                                                                                                                                                                                                                                                                                                                                                                            blendMode: number;

                                                                                                                                                                                                                                                                                                                                                                                                                              property clampWhenFinished

                                                                                                                                                                                                                                                                                                                                                                                                                              clampWhenFinished: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                              • false

                                                                                                                                                                                                                                                                                                                                                                                                                              property enabled

                                                                                                                                                                                                                                                                                                                                                                                                                              enabled: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                              • true

                                                                                                                                                                                                                                                                                                                                                                                                                              property loop

                                                                                                                                                                                                                                                                                                                                                                                                                              loop: number;
                                                                                                                                                                                                                                                                                                                                                                                                                              • THREE.LoopRepeat

                                                                                                                                                                                                                                                                                                                                                                                                                              property paused

                                                                                                                                                                                                                                                                                                                                                                                                                              paused: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                              • false

                                                                                                                                                                                                                                                                                                                                                                                                                              property repetitions

                                                                                                                                                                                                                                                                                                                                                                                                                              repetitions: number;
                                                                                                                                                                                                                                                                                                                                                                                                                              • Infinity

                                                                                                                                                                                                                                                                                                                                                                                                                              property time

                                                                                                                                                                                                                                                                                                                                                                                                                              time: number;
                                                                                                                                                                                                                                                                                                                                                                                                                              • 0

                                                                                                                                                                                                                                                                                                                                                                                                                              property timeScale

                                                                                                                                                                                                                                                                                                                                                                                                                              timeScale: number;
                                                                                                                                                                                                                                                                                                                                                                                                                              • 1

                                                                                                                                                                                                                                                                                                                                                                                                                              property weight

                                                                                                                                                                                                                                                                                                                                                                                                                              weight: number;
                                                                                                                                                                                                                                                                                                                                                                                                                              • 1

                                                                                                                                                                                                                                                                                                                                                                                                                              property zeroSlopeAtEnd

                                                                                                                                                                                                                                                                                                                                                                                                                              zeroSlopeAtEnd: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                              • true

                                                                                                                                                                                                                                                                                                                                                                                                                              property zeroSlopeAtStart

                                                                                                                                                                                                                                                                                                                                                                                                                              zeroSlopeAtStart: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                              • true

                                                                                                                                                                                                                                                                                                                                                                                                                              method crossFadeFrom

                                                                                                                                                                                                                                                                                                                                                                                                                              crossFadeFrom: (
                                                                                                                                                                                                                                                                                                                                                                                                                              fadeOutAction: AnimationAction,
                                                                                                                                                                                                                                                                                                                                                                                                                              duration: number,
                                                                                                                                                                                                                                                                                                                                                                                                                              warp: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                method crossFadeTo

                                                                                                                                                                                                                                                                                                                                                                                                                                crossFadeTo: (
                                                                                                                                                                                                                                                                                                                                                                                                                                fadeInAction: AnimationAction,
                                                                                                                                                                                                                                                                                                                                                                                                                                duration: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                warp: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                ) => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method fadeIn

                                                                                                                                                                                                                                                                                                                                                                                                                                  fadeIn: (duration: number) => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method fadeOut

                                                                                                                                                                                                                                                                                                                                                                                                                                    fadeOut: (duration: number) => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method getClip

                                                                                                                                                                                                                                                                                                                                                                                                                                      getClip: () => AnimationClip;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method getEffectiveTimeScale

                                                                                                                                                                                                                                                                                                                                                                                                                                        getEffectiveTimeScale: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method getEffectiveWeight

                                                                                                                                                                                                                                                                                                                                                                                                                                          getEffectiveWeight: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method getMixer

                                                                                                                                                                                                                                                                                                                                                                                                                                            getMixer: () => AnimationMixer;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method getRoot

                                                                                                                                                                                                                                                                                                                                                                                                                                              getRoot: () => Object3D;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method halt

                                                                                                                                                                                                                                                                                                                                                                                                                                                halt: (duration: number) => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isRunning

                                                                                                                                                                                                                                                                                                                                                                                                                                                  isRunning: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isScheduled

                                                                                                                                                                                                                                                                                                                                                                                                                                                    isScheduled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method play

                                                                                                                                                                                                                                                                                                                                                                                                                                                      play: () => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                        reset: () => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setDuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                          setDuration: (duration: number) => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setEffectiveTimeScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                            setEffectiveTimeScale: (timeScale: number) => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setEffectiveWeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                              setEffectiveWeight: (weight: number) => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setLoop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                setLoop: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                mode: AnimationActionLoopStyles,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                repetitions: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method startAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  startAt: (time: number) => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stop: () => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method stopFading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stopFading: () => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method stopWarping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        stopWarping: () => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method syncWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          syncWith: (action: AnimationAction) => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method warp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            warp: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            statTimeScale: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            endTimeScale: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            duration: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => AnimationAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class AnimationClip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class AnimationClip {}


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                duration?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tracks?: KeyframeTrack[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                blendMode?: number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property blendMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  blendMode: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • THREE.NormalAnimationBlendMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  duration: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • -1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property results

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    results: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tracks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tracks: KeyframeTrack[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property uuid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        uuid: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method clone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          clone: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method CreateClipsFromMorphTargetSequences

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static CreateClipsFromMorphTargetSequences: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            morphTargets: MorphTarget[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fps: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            noLoop: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => AnimationClip[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method CreateFromMorphTargetSequence

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static CreateFromMorphTargetSequence: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              morphTargetSequence: MorphTarget[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fps: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              noLoop: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => AnimationClip;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method findByName