This light globally illuminates all objects in the scene equally.

Alias for {@link THREE.EllipseCurve | EllipseCurve}.

ArrayCamera can be used in order to efficiently render a scene with a predefined set of cameras

An 3D arrow object for visualizing directions.

Create a non-positional ( global ) Audio object. This uses the [Web {@link Audio](https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API | ) API}.

Create a AudioAnalyser object, which uses an AnalyserNode to analyse audio data. This uses the Web Audio API.

The AudioListener represents a virtual listener of the all positional and non-positional audio effects in the scene. A three.js application usually creates a single instance of AudioListener * @remarks It is a mandatory construtor parameter for audios entities like {@link Audio | Audio} and {@link PositionalAudio | PositionalAudio}. In most cases, the listener object is a child of the camera So the 3D transformation of the camera represents the 3D transformation of the listener.

An axis object to visualize the 3 axes in a simple way.

A special version of Mesh with multi draw batch rendering support. Use BatchedMesh if you have to render a large number of objects with the same material but with different world transformations and geometry. The usage of BatchedMesh will help you to reduce the number of draw calls and thus improve the overall rendering performance in your application.

A Bone which is part of a {@link THREE.Skeleton | Skeleton}

Helper object to visualize a {@link THREE.Box3 | Box3}.

BoxGeometry is a geometry class for a rectangular cuboid with a given 'width', 'height', and 'depth'

Helper object to graphically show the world-axis-aligned bounding box around an object

This class stores data for an attribute (such as vertex positions, face indices, normals, colors, UVs, and any custom attributes ) associated with a {@link THREE.BufferGeometry | BufferGeometry}, which allows for more efficient passing of data to the GPU

A representation of mesh, line, or point geometry Includes vertex positions, face indices, normals, colors, UVs, and custom attributes within buffers, reducing the cost of passing all this data to the GPU.

Abstract base class for cameras

This helps with visualizing what a camera contains in its frustum

Creates a texture from a canvas element.

CapsuleGeometry is a geometry class for a capsule with given radii and height

Create a smooth 3D spline curve from a series of points using the Catmull-Rom algorithm.

CircleGeometry is a simple shape of Euclidean geometry

Object for keeping track of time

Represents a color. See also {@link ColorUtils}.

Creates an texture 2D array based on data in compressed form, for example from a DDS file.

Creates a texture based on data in compressed form, for example from a DDS file.

A class for generating cone geometries.

Creates 6 {@link THREE.PerspectiveCamera | cameras} that render to a {@link THREE.WebGLCubeRenderTarget | WebGLCubeRenderTarget}.

Creates a cube texture made up of six images.

Create a smooth 2D cubic bezier curve, defined by a start point, endpoint and two control points.

Create a smooth 3D cubic bezier curve, defined by a start point, endpoint and two control points.

An abstract base class for creating a Curve object that contains methods for interpolation

Curved Path - a curve path is simply a array of connected curves, but retains the api of a curve.

A class for generating cylinder geometries.

Creates a three-dimensional texture from raw data, with parameters to divide it into width, height, and depth

Creates an array of textures directly from raw data, width and height and depth

Creates a texture directly from raw data, width and height.

This class can be used to automatically save the depth information of a rendering into a texture

A light that gets emitted in a specific direction

Helper object to assist with visualizing a {@link THREE.DirectionalLight | DirectionalLight}'s effect on the scene

This is used internally by {@link DirectionalLight | DirectionalLights} for calculating shadows. Unlike the other shadow classes, this uses an {@link THREE.OrthographicCamera | OrthographicCamera} to calculate the shadows, rather than a {@link THREE.PerspectiveCamera | PerspectiveCamera}

A class for generating a dodecahedron geometries.

This can be used as a helper object to view the edges of a {@link THREE.BufferGeometry | geometry}.

Creates a 2d curve in the shape of an ellipse

JavaScript events for custom objects

Creates extruded geometry from a path shape.

A {@link THREE.BufferAttribute | BufferAttribute} for Uint16Array TypedArray

A {@link THREE.BufferAttribute | BufferAttribute} for Float32Array TypedArray

A {@link THREE.BufferAttribute | BufferAttribute} for Float64Array TypedArray

This class contains the parameters that define linear fog, i.e., that grows linearly denser with the distance.

This class contains the parameters that define exponential squared fog, which gives a clear view near the camera and a faster than exponentially densening fog farther from the camera.

This class can only be used in combination with {@link THREE.WebGLRenderer.copyFramebufferToTexture | WebGLRenderer.copyFramebufferToTexture()}.

Frustums are used to determine what is inside the camera's field of view. They help speed up the rendering process.

This buffer attribute class does not construct a VBO. Instead, it uses whatever VBO is passed in constructor and can later be altered via the {@link buffer | .buffer} property.

The GridHelper is an object to define grids

Its purpose is to make working with groups of objects syntactically clearer.

A light source positioned directly above the scene, with color fading from the sky color to the ground color.

Creates a visual aid consisting of a spherical {@link THREE.Mesh | Mesh} for a {@link THREE.HemisphereLight | HemisphereLight}.

A class for generating an icosahedron geometry.

A loader for loading an image. Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object.

An instanced version of {@link THREE.BufferAttribute | BufferAttribute}.

An instanced version of {@link THREE.BufferGeometry | BufferGeometry}.

An instanced version of {@link THREE.InterleavedBuffer | InterleavedBuffer}.

A special version of {@link THREE.Mesh | Mesh} with instanced rendering support

A {@link THREE.BufferAttribute | BufferAttribute} for Int16Array TypedArray

A {@link THREE.BufferAttribute | BufferAttribute} for Int32Array TypedArray

A {@link THREE.BufferAttribute | BufferAttribute} for Int8Array TypedArray

"Interleaved" means that multiple attributes, possibly of different types, (e.g., position, normal, uv, color) are packed into a single array buffer. An introduction into interleaved arrays can be found here: Interleaved array basics

Creates meshes with axial symmetry like vases

A {@link THREE.Layers | Layers} object assigns an {@link THREE.Object3D | Object3D} to 1 or more of 32 layers numbered 0 to 31 - internally the layers are stored as a bit mask, and by default all Object3Ds are a member of layer 0.

Abstract base class for lights.

Light probes are an alternative way of adding light to a 3D scene.

Serves as a base class for the other shadow classes.

A continuous line.

A curve representing a 2D line segment.

A curve representing a 3D line segment.

A continuous line that connects back to the start.

A series of lines drawn between pairs of vertices.

Base class for implementing loaders.

Handles and keeps track of loaded and pending data.

Every level is associated with an object, and rendering can be switched between them at the distances specified

Materials describe the appearance of objects. They are defined in a (mostly) renderer-independent way, so you don't have to rewrite materials if you decide to use a different renderer.

( class Matrix3 implements Matrix )

A 4x4 Matrix.

Class representing triangular polygon mesh based objects.

This is the base class for most objects in three.js and provides a set of properties and methods for manipulating objects in 3D space.

A class for generating an octahedron geometry.

Camera that uses orthographic projection. In this projection mode, an object's size in the rendered image stays constant regardless of its distance from the camera. This can be useful for rendering 2D scenes and UI elements, amongst other things.

A 2D Path representation.

Camera that uses perspective projection. This projection mode is designed to mimic the way the human eye sees

A class for generating plane geometries.

Helper object to visualize a {@link THREE.Plane | Plane}.

This class generates a Prefiltered, Mipmapped Radiance Environment Map (PMREM) from a cubeMap environment texture.

A light that gets emitted from a single point in all directions

This displays a helper object consisting of a spherical {@link THREE.Mesh | Mesh} for visualizing a {@link THREE.PointLight | PointLight}.

Shadow for {@link THREE.PointLight | PointLight}

A class for displaying Points

The PolarGridHelper is an object to define polar grids

A polyhedron is a solid in three dimensions with flat faces

Create a positional audio object. This uses the Web Audio API.

Create a smooth 2D quadratic bezier curve, defined by a start point, end point and a single control point.

Create a smooth 3D quadratic bezier curve, defined by a start point, end point and a single control point.

Implementation of a quaternion. This is used for rotating things without incurring in the dreaded gimbal lock issue, amongst other advantages.

This class is designed to assist with raycasting

RectAreaLight emits light uniformly across the face a rectangular plane

A class for generating a two-dimensional ring geometry.

Scenes allow you to set up what and where is to be rendered by three.js

Defines an arbitrary 2d Shape plane using paths with optional holes

Creates an one-sided polygonal geometry from one or more path shapes.

This class is used to convert a series of shapes to an array of {@link THREE.Path | Path's}, for example an SVG shape to a path.

Use an array of {@link Bone | bones} to create a Skeleton that can be used by a {@link THREE.SkinnedMesh | SkinnedMesh}.

A helper object to assist with visualizing a {@link Skeleton | Skeleton}

A mesh that has a {@link THREE.Skeleton | Skeleton} with {@link Bone | bones} that can then be used to animate the vertices of the geometry.

Represents the data Source of a texture.

A class for generating sphere geometries.

Create a smooth 2D spline curve from a series of points.

This light gets emitted from a single point in one direction, along a cone that increases in size the further from the light it gets.

This displays a cone shaped helper object for a {@link THREE.SpotLight | SpotLight}.

This is used internally by {@link SpotLight | SpotLights} for calculating shadows.

A Sprite is a plane that always faces towards the camera, generally with a partially transparent texture applied.

Dual {@link PerspectiveCamera | PerspectiveCamera}s used for effects such as 3D Anaglyph or Parallax Barrier.

A class for generating a tetrahedron geometries.

Create a Texture to apply to a surface or as a reflection or refraction map.

Class for loading a texture. Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object.

A class for generating torus geometries.

Creates a torus knot, the particular shape of which is defined by a pair of coprime integers, p and q If p and q are not coprime, the result will be a torus link.

Creates a tube that extrudes along a 3d curve.

A {@link THREE.BufferAttribute | BufferAttribute} for Uint16Array TypedArray

A {@link THREE.BufferAttribute | BufferAttribute} for Uint32Array TypedArray

A {@link THREE.BufferAttribute | BufferAttribute} for Uint8Array TypedArray

A {@link THREE.BufferAttribute | BufferAttribute} for Uint8ClampedArray TypedArray

Uniforms are global GLSL variables. They are passed to shader programs.

2D vector.

3D vector. ( class Vector3 implements Vector )

4D vector.

Creates a texture for use with a video.

Represents a three-dimensional render target.

This type of render target represents an array of textures.

An object with a series of statistical information about the graphics board memory and the rendering process.

The WebGL renderer displays your beautifully crafted scenes using WebGL, if your device supports it. This renderer has way better performance than CanvasRenderer.

This can be used as a helper object to view a {@link BufferGeometry | geometry} as a wireframe.

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

With ClampToEdgeWrapping the last pixel of the texture stretches to the edge of the mesh.

DepthFormat reads each element as a single depth value, converts it to floating point, and clamps to the range [0,1].

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

With RepeatWrapping the texture will simply repeat to infinity.

RGB compression in 2-bit mode. One block for each 8×4 pixels.

RGB compression in 4-bit mode. One block for each 4×4 pixels.

A DXT1-compressed image in an RGB image format.

RGBA compression in 2-bit mode. One block for each 8×4 pixels.

RGBA compression in 4-bit mode. One block for each 4×4 pixels.

A DXT1-compressed image in an RGB image format with a simple on/off alpha value.

A DXT3-compressed image in an RGBA image format. Compared to a 32-bit RGBA texture, it offers 4:1 compression.

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

RGBAFormat discards the green and blue components and reads just the red component. (Can only be used with a WebGL 2 rendering context).

RGBAIntegerFormat reads the red, green, blue and alpha component

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

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

Maps the texture using the mesh's UV coordinates.

Used internally by {@link THREE.SplineCurve | SplineCurve}.

Used internally by {@link THREE.CubicBezierCurve3 | CubicBezierCurve3} and {@link THREE.CubicBezierCurve | CubicBezierCurve}.

Returns a single precision floating point value from the given half precision floating point value.

Returns a half precision floating point value from the given single precision floating point value.

Clamps the x to be between a and b.

Smoothly interpolate a number from x toward y in a spring-like manner using the dt to maintain frame rate independent movement.

Returns a value linearly interpolated from two known points based on the given interval - t = 0 will return x and t = 1 will return y.

Linear mapping of x from range [a1, a2] to range [b1, b2].

Returns a value that alternates between 0 and length.

Random float from low to high interval.

Random float from - range / 2 to range / 2 interval.

Random integer from low to high interval.

Deterministic pseudo-random float in the interval [ 0, 1 ].

Used internally by {@link THREE.QuadraticBezierCurve3 | QuadraticBezierCurve3} and {@link THREE.QuadraticBezierCurve | QuadraticBezierCurve}.

The minimal basic Event that can be dispatched by a {@link EventDispatcher<>}.

The minimal expected contract of a fired Event that was dispatched by a {@link EventDispatcher<>}.

( interface Matrix )

parameters is an object with one or more properties defining the material's appearance.

Shim for OffscreenCanvas.

( interface Vector )

Texture Mapping Modes for any type of Textures

All Possible Texture Pixel Formats Modes. For any Type or SubType of Textures.

For use with a {@link THREE.CompressedTexture}'s {@link THREE.CompressedTexture.format | .format} property.

Texture Mapping Modes for cube Textures

All Texture Pixel Formats Modes for {@link THREE.DepthTexture}.

Texture Magnification Filter Modes. For use with a texture's {@link THREE.Texture.magFilter | magFilter} property, these define the texture magnification function to be used when the pixel being textured maps to an area less than or equal to one texture element (texel).

Texture Mapping Modes for non-cube Textures

Texture Minification Filter Modes. For use with a texture's {@link THREE.Texture.minFilter | minFilter} property, these define the texture minifying function that is used whenever the pixel being textured maps to an area greater than one texture element (texel).

All Texture Pixel Formats Modes.

For use with a texture's {@link THREE.Texture.internalFormat} property, these define how elements of a {@link THREE.Texture}, or texels, are stored on the GPU.

• R8 stores the red component on 8 bits.
• R8_SNORM stores the red component on 8 bits. The component is stored as normalized.
• R8I stores the red component on 8 bits. The component is stored as an integer.
• R8UI stores the red component on 8 bits. The component is stored as an unsigned integer.
• R16I stores the red component on 16 bits. The component is stored as an integer.
• R16UI stores the red component on 16 bits. The component is stored as an unsigned integer.
• R16F stores the red component on 16 bits. The component is stored as floating point.
• R32I stores the red component on 32 bits. The component is stored as an integer.
• R32UI stores the red component on 32 bits. The component is stored as an unsigned integer.
• R32F stores the red component on 32 bits. The component is stored as floating point.
• RG8 stores the red and green components on 8 bits each.
• RG8_SNORM stores the red and green components on 8 bits each. Every component is stored as normalized.
• RG8I stores the red and green components on 8 bits each. Every component is stored as an integer.
• RG8UI stores the red and green components on 8 bits each. Every component is stored as an unsigned integer.
• RG16I stores the red and green components on 16 bits each. Every component is stored as an integer.
• RG16UI stores the red and green components on 16 bits each. Every component is stored as an unsigned integer.
• RG16F stores the red and green components on 16 bits each. Every component is stored as floating point.
• RG32I stores the red and green components on 32 bits each. Every component is stored as an integer.
• RG32UI stores the red and green components on 32 bits. Every component is stored as an unsigned integer.
• RG32F stores the red and green components on 32 bits. Every component is stored as floating point.
• RGB8 stores the red, green, and blue components on 8 bits each. RGB8_SNORM` stores the red, green, and blue components on 8 bits each. Every component is stored as normalized.
• RGB8I stores the red, green, and blue components on 8 bits each. Every component is stored as an integer.
• RGB8UI stores the red, green, and blue components on 8 bits each. Every component is stored as an unsigned integer.
• RGB16I stores the red, green, and blue components on 16 bits each. Every component is stored as an integer.
• RGB16UI stores the red, green, and blue components on 16 bits each. Every component is stored as an unsigned integer.
• RGB16F stores the red, green, and blue components on 16 bits each. Every component is stored as floating point
• RGB32I stores the red, green, and blue components on 32 bits each. Every component is stored as an integer.
• RGB32UI stores the red, green, and blue components on 32 bits each. Every component is stored as an unsigned integer.
• RGB32F stores the red, green, and blue components on 32 bits each. Every component is stored as floating point
• R11F_G11F_B10F stores the red, green, and blue components respectively on 11 bits, 11 bits, and 10bits. Every component is stored as floating point.
• RGB565 stores the red, green, and blue components respectively on 5 bits, 6 bits, and 5 bits.
• RGB9_E5 stores the red, green, and blue components on 9 bits each.
• RGBA8 stores the red, green, blue, and alpha components on 8 bits each.
• RGBA8_SNORM stores the red, green, blue, and alpha components on 8 bits. Every component is stored as normalized.
• RGBA8I stores the red, green, blue, and alpha components on 8 bits each. Every component is stored as an integer.
• RGBA8UI stores the red, green, blue, and alpha components on 8 bits. Every component is stored as an unsigned integer.
• RGBA16I stores the red, green, blue, and alpha components on 16 bits. Every component is stored as an integer.
• RGBA16UI stores the red, green, blue, and alpha components on 16 bits. Every component is stored as an unsigned integer.
• RGBA16F stores the red, green, blue, and alpha components on 16 bits. Every component is stored as floating point.
• RGBA32I stores the red, green, blue, and alpha components on 32 bits. Every component is stored as an integer.
• RGBA32UI stores the red, green, blue, and alpha components on 32 bits. Every component is stored as an unsigned integer.
• RGBA32F stores the red, green, blue, and alpha components on 32 bits. Every component is stored as floating point.
• RGB5_A1 stores the red, green, blue, and alpha components respectively on 5 bits, 5 bits, 5 bits, and 1 bit.
• RGB10_A2 stores the red, green, blue, and alpha components respectively on 10 bits, 10 bits, 10 bits and 2 bits.
• RGB10_A2UI stores the red, green, blue, and alpha components respectively on 10 bits, 10 bits, 10 bits and 2 bits. Every component is stored as an unsigned integer.
• SRGB8 stores the red, green, and blue components on 8 bits each.
• SRGB8_ALPHA8 stores the red, green, blue, and alpha components on 8 bits each.
• DEPTH_COMPONENT16 stores the depth component on 16bits.
• DEPTH_COMPONENT24 stores the depth component on 24bits.
• DEPTH_COMPONENT32F stores the depth component on 32bits. The component is stored as floating point.
• DEPTH24_STENCIL8 stores the depth, and stencil components respectively on 24 bits and 8 bits. The stencil component is stored as an unsigned integer.
• DEPTH32F_STENCIL8 stores the depth, and stencil components respectively on 32 bits and 8 bits. The depth component is stored as floating point, and the stencil component as an unsigned integer.

Defines which side of faces will be rendered - front, back or both. Default is FrontSide.

Texture Types.

Texture Encodings.

Texture all Magnification and Minification Filter Modes.

Texture Pixel Formats Modes. Compatible only with {@link WebGLRenderingContext | WebGL 1 Rendering Context}.

Texture Pixel Formats Modes. Compatible only with {@link WebGL2RenderingContext | WebGL 2 Rendering Context}.

Texture Wrapping Modes