THREE

Always pass.

Will always return true.

This light globally illuminates all objects in the scene equally. It cannot be used to cast shadows as it does not have a direction.

Companion object for AmbientLight with factory method

Array of cameras used for multi-viewport rendering.

An 3D arrow object for visualizing directions.

Companion object for ArrowHelper class

Create a non-positional audio object. This uses the Web Audio API and can play audio clips that are either loaded via the AudioLoader or created dynamically.

Create a frequency analyser for audio sources. This uses the Web Audio API's AnalyserNode to provide frequency and time domain data for visualization.

Audio buffer interface for loaded audio data.

The AudioListener represents a virtual listener of the audio sources in a scene. It is similar to a camera in the visual scene - it has a position and orientation in 3D space, and defines from where the audio is heard.

Class for loading an audio file.

An axis object to visualize the 3 axes in a simple way. The X axis is red. The Y axis is green. The Z axis is blue.

Companion object for AxesHelper class

Gives unfiltered shadow maps - fastest, but lowest quality.

Bloom pass that adds a bloom/glow effect to bright areas

BokehPass applies a depth of field effect using a bokeh shader

Parameters for BokehPass configuration

A bone which is part of a Skeleton. The skeleton in turn is used by the SkinnedMesh.

Example:

val root  = new Bone()
val child = new Bone()

root.add(child)
child.position.y = 5

Companion object for Bone with factory method.

Represents an axis-aligned bounding box (AABB) in 2D space.

Represents an axis-aligned bounding box (AABB) in 3D space.

A helper object to visualize an instance of [[Box3]].

Companion object for Box3Helper class

Class for generating rectangular cuboid geometries.

Helper object to graphically show the world-axis-aligned bounding box around an object. The actual bounding box is handled with [[Box3]], this is just a visual helper for debugging. It can be automatically resized with [[BoxHelper#update]] when the object it's created from is transformed. Note that the object must have a geometry for this to work, so it won't work with sprites.

Companion object for BoxHelper class

Base class for all geometries.

Class for loading a buffer geometry from JSON format.

Utility functions for working with BufferGeometry objects. Provides advanced vertex manipulation and geometry processing capabilities.

Abstract base class for cameras.

This helps with visualizing what a camera contains in its frustum. It visualizes the frustum of a camera using line segments.

Based on frustum visualization in lightgl.js shadowmap example.

CameraHelper must be a child of the scene.

Companion object for CameraHelper class

Creates a texture from a canvas element.

Class for generating circle geometries.

A class representing an RGB color.

A Color instance is represented by RGB components in the linear working color space, which defaults to LinearSRGBColorSpace. Inputs conventionally using SRGBColorSpace (such as hexadecimals and CSS strings) are converted to the working color space automatically.

A class that manages conversions between color spaces.

Creates a texture based on data in compressed form.

These textures are usually loaded with CompressedTextureLoader.

Class for generating cone geometries.

Creates 6 cameras that render to a WebGLCubeRenderTarget.

Represents a texture comprising six images - one for each side of a cube.

Class for loading a CubeTexture.

Cubic interpolant.

The cubic interpolant uses a cubic Hermite spline for interpolation. This provides a smooth interpolation between adjacent values.

Culls back faces.

Culls front faces.

Culls both front and back faces.

Disables face culling.

Class for generating cylinder geometries.

A class representing cylindrical coordinates.

Cylindrical coordinates represent a position in 3D space using a distance from the origin (radius), an angle from the X axis on the XZ plane (theta), and a height above the XZ plane (y).

A loader for the S3TC texture compression format (DDS files).

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

Default loading manager used by loaders if one isn't specified.

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. This light will behave as though it is infinitely far away and the rays produced from it are all parallel. The common use case for this is to simulate daylight; the sun is far enough away that its position can be considered to be infinite.

Companion object for DirectionalLight with factory method

Helper object to assist with visualizing a [[DirectionalLight]]'s effect on the scene. This consists of plane and a line representing the light's position and direction.

Companion object for DirectionalLightHelper class

Represents the shadow configuration of directional lights.

Companion object for DirectionalLightShadow with factory method

Discrete interpolant.

The discrete interpolant returns the sample at the position closest to the parameter.

A class for generating a dodecahedron geometry. A dodecahedron is a polyhedron with twelve pentagonal faces.

Companion object for DodecahedronGeometry with factory method.

Dot screen pass that creates halftone/dot pattern effects

This class can be used to provide a drag'n'drop interaction.

The contents are intended to be respecified repeatedly by reading data from the 3D API, and used many times as the source for WebGL drawing and image specification commands.

The contents are intended to be respecified repeatedly by the application, and used many times as the source for drawing and image specification commands.

The contents are intended to be respecified repeatedly by reading data from the 3D API, and queried many times by the application.

The EffectComposer is a post-processing pipeline that allows you to apply multiple post-processing effects to a scene.

Base class for all post-processing passes

Pass if the incoming value equals the depth buffer value.

Will return true if the stencil reference value is equal to the current stencil value.

A class representing Euler Angles.

Creates extruded geometry from a path shape.

Class for loading a file as a string or ArrayBuffer.

Film pass that adds film grain and scanlines effects

This class is an alternative implementation of [[FlyControls]].

This class enables a navigation similar to fly modes in DCC tools like Blender. You can arbitrarily transform the camera in 3D space without any limitations (e.g. focus on a specific target).

This class can be used to define a linear fog that grows linearly denser with the distance.

val scene = new Scene()
scene.fog = Fog(0xcccccc, 10, 15)

Companion object for creating Fog instances

This class can be used to define an exponential squared fog, which gives a clear view near the camera and a faster than exponentially densening fog farther from the camera.

val scene = new Scene()
scene.fog = FogExp2(0xcccccc, 0.002)

Companion object for creating FogExp2 instances

Class for loading a font in JSON format.

This class can only be used in combination with copyFramebufferToTexture() methods of renderers. It extracts the contents of the current bound framebuffer and provides it as a texture for further usage.

A class representing a frustum - the volume visible to a camera.

A frustum is created by the intersection of six planes. The planes correspond to the faces of a parallelepiped (a box).

A loader for loading GLTF resources. The .gltf and .glb file extensions are supported.

The result of loading a GLTF asset.

Glitch pass that creates digital glitch effects

Parameters for GlitchPass configuration

Pass if the incoming value is greater than the depth buffer value.

Pass if the incoming value is greater than or equal to the depth buffer value.

Will return true if the stencil reference value is greater than or equal to the current stencil value.

Will return true if the stencil reference value is greater than the current stencil value.

The GridHelper is an object to define grids. Grids are two-dimensional arrays of lines.

Companion object for GridHelper class

This is almost identical to an Object3D. Its purpose is to make working with groups of objects syntactically clearer.

A group is useful for collecting objects to manipulate them as a whole, such as rotating, scaling, or setting their visibility.

Companion object for Group with factory method.

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

A class for generating an icosahedron geometry. An icosahedron is a regular polyhedron with 20 equilateral triangular faces, 30 edges and 12 vertices.

Class for loading an ImageBitmap.

A special version of Mesh with instanced rendering support. Use this if you have to render a large number of objects with the same geometry and material.

Abstract base class of interpolants over parametric samples.

The parameter domain is one dimensional, typically the time or a path along a curve defined by the data.

The sample values can have any dimensionality and derived classes may apply special interpretations to the data.

This class provides the interval seek in a Template Method, deferring the actual interpolation to derived classes.

Discrete interpolation mode.

Linear interpolation mode.

Smooth interpolation mode.

Represents the different interpolation sampling modes.

Represents mouse buttons and interaction types in context of controls.

A component for providing a basic Level of Detail (LOD) mechanism.

Every LOD level is associated with an object, and rendering can be switched between them at the distances specified. Typically you would create, say, three meshes, one for far away (low detail), one for mid range (medium detail) and one for close up (high detail).

Example:

val lod      = new LOD()
val material = MeshBasicMaterial(color = 0xffff00)

// Create spheres with 3 levels of detail and create new LOD levels for them
for (i <- 0 until 3) {
 val geometry = IcosahedronGeometry(10, 3 - i)
 val mesh     = Mesh(geometry, material)
 lod.addLevel(mesh, i * 75)
}

scene.add(lod)

Companion object for LOD with factory method.

Represents a single LOD level with its object, distance, and hysteresis settings.

Creates meshes with axial symmetry like vases. The lathe rotates around the Y axis.

LensFlare creates realistic lens flare effects that simulate the scattering of light through a camera lens. It consists of multiple LensFlareElement objects positioned at different distances from the light source.

LensFlareElement represents a single element in a lens flare effect. Each element can have its own texture, size, distance from the light source, and color.

Pass if the incoming value is less than the depth buffer value.

Pass if the incoming value is less than or equal to the depth buffer value.

Will return true if the stencil reference value is less than or equal to the current stencil value.

Will return true if the stencil reference value is less than the current stencil value.

Abstract base class for lights.

Light probes are used for image-based lighting (IBL) in Three.js. They capture the lighting information from the environment and can be used to illuminate objects with realistic lighting based on their surroundings.

Abstract base class for light shadow classes. These classes represent the shadow configuration for different light types.

Companion object for LightShadow with factory method

A continuous line.

This is nearly the same as LineSegments; the only difference is that it is rendered using gl.LINE_STRIP instead of gl.LINES.

Companion object for Line class

A class representing a line in 3D space, defined by a start point and an end point.

A material for drawing wireframe-style geometries with solid lines.

Parameters for LineBasicMaterial.

A material for drawing wireframe-style geometries with dashed lines. Note: You must call Line.computeLineDistances() when using LineDashedMaterial.

Companion object for LineDashedMaterial with factory methods.

A continuous line that connects back to the start.

This is nearly the same as Line; the only difference is that it is rendered using gl.LINE_LOOP instead of gl.LINE_STRIP, which draws a straight line to the next vertex, and connects the last vertex back to the first.

Companion object for LineLoop class

A material for drawing line segments with custom width.

A series of lines drawn between pairs of vertices.

This is nearly the same as Line; the only difference is that it is rendered using gl.LINES instead of gl.LINE_STRIP.

Companion object for LineSegments class

A series of lines drawn between pairs of vertices.

This adds functionality beyond LineSegments, like arbitrary line width and changing width to be in world units. Line2 extends this object, forming a polyline instead of individual segments.

A specialized geometry for drawing line segments.

Linear interpolant.

The linear interpolant performs a simple linear interpolation between two adjacent values.

Converts color component from linear to sRGB space

Class for managing and tracking loaded and pending data.

Represents mouse buttons and interaction types in context of controls.