Class BufferGeometry<Attributes>

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.

To read and edit data in BufferGeometry attributes, see THREE.BufferAttribute | BufferAttribute documentation.

const geometry = new THREE.BufferGeometry();

// create a simple square shape. We duplicate the top left and bottom right
// vertices because each vertex needs to appear once per triangle.
const vertices = new Float32Array( [
-1.0, -1.0, 1.0, // v0
1.0, -1.0, 1.0, // v1
1.0, 1.0, 1.0, // v2

1.0, 1.0, 1.0, // v3
-1.0, 1.0, 1.0, // v4
-1.0, -1.0, 1.0 // v5
] );

// itemSize = 3 because there are 3 values (components) per vertex
geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
const material = new THREE.MeshBasicMaterial( { color: 0xff0000 } );
const mesh = new THREE.Mesh( geometry, material );
const geometry = new THREE.BufferGeometry();

const vertices = new Float32Array( [
-1.0, -1.0, 1.0, // v0
1.0, -1.0, 1.0, // v1
1.0, 1.0, 1.0, // v2
-1.0, 1.0, 1.0, // v3
] );
geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );

const indices = [
0, 1, 2,
2, 3, 0,
];

geometry.setIndex( indices );
geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );

const material = new THREE.MeshBasicMaterial( { color: 0xff0000 } );
const mesh = new THREE.Mesh( geometry, material );

Type Parameters

Hierarchy (view full)

Constructors

Properties

id: number

Unique number for this THREE.BufferGeometry | BufferGeometry instance.

Expects a Integer

uuid: string

UUID of this object instance.

This gets automatically assigned and shouldn't be edited.

name: string

Optional name for this THREE.BufferGeometry | BufferGeometry instance.

''

type: string

A Read-only string to check if this object type.

Sub-classes will update this value.

BufferGeometry

index: null | BufferAttribute

Allows for vertices to be re-used across multiple triangles; this is called using "indexed triangles".
Each triangle is associated with the indices of three vertices. This attribute therefore stores the index of each vertex for each triangular face.
If this attribute is not set, the THREE.WebGLRenderer | renderer assumes that each three contiguous positions represent a single triangle.

null

attributes: Attributes

This hashmap has as id the name of the attribute to be set and as value the THREE.BufferAttribute | buffer to set it to. Rather than accessing this property directly,
use .setAttribute and .getAttribute to access attributes of this geometry.

{}

morphAttributes: {
    [name: string]: (BufferAttribute | InterleavedBufferAttribute)[];
}

Hashmap of THREE.BufferAttribute | BufferAttributes holding details of the geometry's morph targets.

Once the geometry has been rendered, the morph attribute data cannot be changed.
You will have to call .dispose(), and create a new instance of THREE.BufferGeometry | BufferGeometry.

{}

morphTargetsRelative: boolean

Used to control the morph target behavior; when set to true, the morph target data is treated as relative offsets, rather than as absolute positions/normals.

false

groups: GeometryGroup[]

Split the geometry into groups, each of which will be rendered in a separate WebGL draw call. This allows an array of materials to be used with the geometry.

Every vertex and index must belong to exactly one group — groups must not share vertices or indices, and must not leave vertices or indices unused.

[]

boundingBox: null | Box3

Bounding box for the THREE.BufferGeometry | BufferGeometry, which can be calculated with .computeBoundingBox().

Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are null.

null

boundingSphere: null | Sphere

Bounding sphere for the THREE.BufferGeometry | BufferGeometry, which can be calculated with .computeBoundingSphere().

bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are null.

null

drawRange: {
    start: number;
    count: number;
}

Determines the part of the geometry to render. This should not be set directly, instead use .setDrawRange(...).

For non-indexed THREE.BufferGeometry | BufferGeometry, count is the number of vertices to render.

{ start: 0, count: Infinity }

userData: Record<string, any>

An object that can be used to store custom data about the BufferGeometry. It should not hold references to functions as these will not be cloned.

{}

isBufferGeometry: true

Read-only flag to check if a given object is of type BufferGeometry.

This is a constant value

true

Methods

  • Set the THREE.BufferGeometry.index | .index buffer.

    Parameters

    Returns this

  • Sets an attribute to this geometry with the specified name.

    Type Parameters

    • K extends string | number | symbol

    Parameters

    Returns this

    Use this rather than the attributes property, because an internal hashmap of .attributes is maintained to speed up iterating over attributes.

  • Returns the attribute with the specified name.

    Type Parameters

    • K extends string | number | symbol

    Parameters

    • name: K

    Returns Attributes[K]

  • Deletes the attribute with the specified name.

    Parameters

    Returns this

  • Returns true if the attribute with the specified name exists.

    Parameters

    Returns boolean

  • Adds a group to this geometry

    Parameters

    • start: number
    • count: number
    • OptionalmaterialIndex: number

    Returns void

    the groups property for details.

  • Clears all groups.

    Returns void

  • Set the .drawRange property

    Parameters

    • start: number
    • count: number

      is the number of vertices or indices to render. Expects a Integer

    Returns void

    For non-indexed BufferGeometry, count is the number of vertices to render

  • Applies the matrix transform to the geometry.

    Parameters

    Returns this

  • Applies the rotation represented by the quaternion to the geometry.

    Parameters

    Returns this

  • Rotate the geometry about the X axis. This is typically done as a one time operation, and not during a loop.

    Parameters

    • angle: number

      radians. Expects a Float

    Returns this

    Use THREE.Object3D.rotation | Object3D.rotation for typical real-time mesh rotation.

  • Rotate the geometry about the Y axis.

    Parameters

    • angle: number

      radians. Expects a Float

    Returns this

    This is typically done as a one time operation, and not during a loop.

  • Rotate the geometry about the Z axis.

    Parameters

    • angle: number

      radians. Expects a Float

    Returns this

    This is typically done as a one time operation, and not during a loop.

  • Translate the geometry.

    Parameters

    • x: number

      Expects a Float

    • y: number

      Expects a Float

    • z: number

      Expects a Float

    Returns this

    This is typically done as a one time operation, and not during a loop.

  • Scale the geometry data.

    Parameters

    • x: number

      Expects a Float

    • y: number

      Expects a Float

    • z: number

      Expects a Float

    Returns this

    This is typically done as a one time operation, and not during a loop.

  • Rotates the geometry to face a point in space.

    Parameters

    • vector: Vector3

      A world vector to look at.

    Returns this

    This is typically done as a one time operation, and not during a loop.

  • Center the geometry based on the bounding box.

    Returns this

  • Sets the attributes for this BufferGeometry from an array of points.

    Parameters

    Returns this

  • Computes the bounding box of the geometry, and updates the .boundingBox attribute. The bounding box is
    not computed by the engine; it must be computed by your app. You may need to recompute the bounding box if the
    geometry vertices are modified.

    Returns void

  • Computes the bounding sphere of the geometry, and updates the .boundingSphere attribute. The engine
    automatically computes the bounding sphere when it is needed, e.g., for ray casting or view frustum culling. You
    may need to recompute the bounding sphere if the geometry vertices are modified.

    Returns void

  • Calculates and adds a tangent attribute to this geometry.
    The computation is only supported for indexed geometries and if position, normal, and uv attributes are defined

    Returns void

    When using a tangent space normal map, prefer the MikkTSpace algorithm provided by
    BufferGeometryUtils.computeMikkTSpaceTangents instead.

  • Computes vertex normals for the given vertex data. For indexed geometries, the method sets each vertex normal to
    be the average of the face normals of the faces that share that vertex. For non-indexed geometries, vertices are
    not shared, and the method sets each vertex normal to be the same as the face normal.

    Returns void

  • Every normal vector in a geometry will have a magnitude of 1

    Returns void

    This will correct lighting on the geometry surfaces.

  • Convert the buffer geometry to three.js JSON Object/Scene format.

    Returns {}

    • Creates a clone of this BufferGeometry

      Returns this

    • Copies another BufferGeometry to this BufferGeometry.

      Returns this

    • Frees the GPU-related resources allocated by this instance.

      Returns void

      Call this method whenever this instance is no longer used in your app.

    • Checks if listener is added to an event type.

      Type Parameters

      • T extends "dispose"

      Parameters

      Returns boolean

    • Type Parameters

      • T extends string

      Parameters

      Returns boolean

    • Fire an event type.

      Type Parameters

      • T extends "dispose"

      Parameters

      • event: BaseEvent<T> & {
            dispose: {};
        }[T]

        The event that gets fired.

      Returns void