Geometry

Geometry is a user-friendly alternative to BufferGeometry. Geometries store attributes (vertex positions, faces, colors, etc.) using objects like Vector3 or Color that are easier to read and edit, but less efficient than typed arrays.

Prefer BufferGeometry for large or serious projects.

Example

WebGL / geometry / minecraft
WebGL / geometry / minecraft / ao
WebGL / geometry / nurbs
WebGL / geometry / spline / editor
WebGL / interactive / cubes / gpu
WebGL / interactive / lines
WebGL / interactive / raycasting / points
WebGL / interactive / voxelpainter
WebGL / morphNormals
var geometry = new v3d.Geometry(); geometry.vertices.push( new v3d.Vector3(-10, 10, 0), new v3d.Vector3(-10, -10, 0), new v3d.Vector3( 10, -10, 0) ); geometry.faces.push(new v3d.Face3(0, 1, 2)); geometry.computeBoundingSphere();

Constructor

Geometry()

The constructor takes no arguments.

Properties

.boundingBox : Box3

Bounding box for the Geometry, which can be calculated with .computeBoundingBox(). Default is null.

.boundingSphere : Sphere

Bounding sphere for the Geometry, which can be calculated with .computeBoundingSphere(). Default is null.

.colors : Array

Array of vertex colors, matching number and order of vertices.

This is used by Points and Line and any classes derived from those such as LineSegments and various helpers. Meshes use Face3.vertexColors instead of this.

To signal an update in this array, Geometry.colorsNeedUpdate needs to be set to true.

.faces : Array

Array of faces.
The array of faces describe how each vertex in the model is connected to form faces. Additionally it holds information about face and vertex normals and colors.

To signal an update in this array, Geometry.elementsNeedUpdate needs to be set to true.

.faceVertexUvs : Array

Array of face UV layers, used for mapping textures onto the geometry.
Each UV layer is an array of UVs matching the order and number of vertices in faces.

To signal an update in this array, Geometry.uvsNeedUpdate needs to be set to true.

.id : Integer

Unique number for this geometry instance.

.isGeometry : Boolean

Used to check whether this or derived classes are Geometries. Default is true.

You should not change this, as it used internally for optimisation.

.lineDistances : array

An array containing distances between vertices for Line geometries. This is required for LineDashedMaterial to render correctly.

.morphTargets : Array

Array of morph targets. Each morph target is a Javascript object: { name: "targetName", vertices: [new v3d.Vector3(), ...] } Morph vertices match number and order of primary vertices.

.morphNormals : Array

Array of morph normals. Morph normals have similar structure as morph targets, each normal set is a Javascript object: morphNormal = { name: "NormalName", normals: [new v3d.Vector3(), ...] } See the WebGL / morphNormals example.

.name : String

Optional name for this geometry. Default is an empty string.

.skinWeights : Array

When working with a SkinnedMesh, each vertex can have up to 4 bones affecting it. The skinWeights property is an array of weight values that correspond to the order of the vertices in the geometry. So for instance, the first skinWeight would correspond to the first vertex in the geometry. Since each vertex can be modified by 4 bones, a Vector4 is used to represent the skin weights for that vertex.

The values of the vector should typically be between 0 and 1. For instance when set to 0 the bone transformation will have no affect. When set to 0.5 it will have 50% affect. When set to 100%, it will have 100% affect. If there is only 1 bone associated with the vertex then you only need to worry about the first component of the vector, the rest can be ignored and set to 0.

.skinIndices : Array

Just like the skinWeights property, the skinIndices' values correspond to the geometry's vertices. Each vertex can have up to 4 bones associated with it. So if you look at the first vertex, and the first skinIndex, this will tell you the bones associated with that vertex. For example the first vertex could have a value of (10.05, 30.10, 12.12). Then the first skin index could have the value of (10, 2, 0, 0). The first skin weight could have the value of (0.8, 0.2, 0, 0). In affect this would take the first vertex, and then the bone mesh.bones[10] and apply it 80% of the way. Then it would take the bone skeleton.bones[2] and apply it 20% of the way. The next two values have a weight of 0, so they would have no affect.

In code another example could look like this: // e.g. geometry.skinIndices[15] = new v3d.Vector4( 0, 5, 9, 10); geometry.skinWeights[15] = new v3d.Vector4(0.2, 0.5, 0.3, 0); // corresponds with the following vertex geometry.vertices[15]; // these bones will be used like so: skeleton.bones[0]; // weight of 0.2 skeleton.bones[5]; // weight of 0.5 skeleton.bones[9]; // weight of 0.3 skeleton.bones[10]; // weight of 0

.uuid : String

UUID of this object instance. This gets automatically assigned and shouldn't be edited.

.vertices : Array

Array of vertices.
The array of vertices holds the position of every vertex in the model.
To signal an update in this array, .verticesNeedUpdate needs to be set to true.

.verticesNeedUpdate : Boolean

Set to true if the vertices array has been updated.

.elementsNeedUpdate : Boolean

Set to true if the faces array has been updated.

.uvsNeedUpdate : Boolean

Set to true if the uvs array has been updated.

.normalsNeedUpdate : Boolean

Set to true if the normals array has been updated.

.colorsNeedUpdate : Boolean

Set to true if the colors array or a face3 color has been updated.

.groupsNeedUpdate : Boolean

Set to true if a face3 materialIndex has been updated.

.lineDistancesNeedUpdate : Boolean

Set to true if the linedistances array has been updated.

Methods

EventDispatcher methods are available on this class.

.applyMatrix (matrix : Matrix4) : null

Bakes matrix transform directly into vertex coordinates.

.center () : Geometry

Center the geometry based on the bounding box.

.clone () : Geometry

Creates a new clone of the Geometry.

This method copies only vertices, faces and uvs. It does not copy any other properties of the geometry.

.computeBoundingBox () : null

Computes bounding box of the geometry, updating Geometry.boundingBox attribute.

.computeBoundingSphere () : null

Computes bounding sphere of the geometry, updating Geometry.boundingSphere attribute.

Neither bounding boxes or bounding spheres are computed by default. They need to be explicitly computed, otherwise they are null.

.computeFaceNormals () : null

Computes face normals.

.computeFlatVertexNormals () : null

Computes flat vertex normals. Sets the vertex normal of each vertex of each face to be the same as the face's normal.

.computeMorphNormals () : null

Computes .morphNormals.

.computeVertexNormals (areaWeighted : Boolean) : null

areaWeighted - If true the contribution of each face normal to the vertex normal is weighted by the area of the face. Default is true.

Computes vertex normals by averaging face normals.

.copy (geometry : Geometry) : Geometry

Copies vertices, faces and uvs into this geometry. It does not copy any other properties of the geometry.

.dispose () : null

Removes The object from memory.
Don't forget to call this method when you remove a geometry because it can cause memory leaks.

.fromBufferGeometry (geometry : BufferGeometry) : Geometry

Convert a BufferGeometry to a Geometry.
The array used to store the vertices in the bufferGeometry is a non indexed array, so the resultant geometry may contain duplicated vertices. Use mergeVertices to remove them.

.lookAt (vector : Vector3) : Geometry

vector - A world vector to look at.

Rotates the geometry to face point in space. This is typically done as a one time operation but not during the render loop.
Use Object3D.lookAt for typical real-time mesh usage.

.merge (geometry : Geometry, matrix : Matrix4, materialIndexOffset : Integer) : null

Merge two geometries or geometry and geometry from object (using object's transform)

.mergeMesh (mesh : Mesh) : null

Merge the mesh's geometry with this, also applying the mesh's transform.

.mergeVertices () : null

Checks for duplicate vertices using hashmap.
Duplicated vertices are removed and faces' vertices are updated.

.normalize () : null

Normalize the geometry.
Make the geometry centered and have a bounding sphere of radius 1.0.

.rotateX (radians : Float) : Geometry

Rotate the geometry about the X axis. This is typically done as a one time operation but not during the render loop.
Use Object3D.rotation for typical real-time mesh rotation.

.rotateY (radians : Float) : Geometry

Rotate the geometry about the Y axis. This is typically done as a one time operation but not during the render loop.
Use Object3D.rotation for typical real-time mesh rotation.

.rotateZ (radians : Float) : Geometry

Rotate the geometry about the Z axis. This is typically done as a one time operation but not during the render loop.
Use Object3D.rotation for typical real-time mesh rotation.

.setFromPoints (points : Array) : Geometry

Sets the vertices for this Geometry from an array of points.

.sortFacesByMaterialIndex () : null

Sorts the faces array according to material index. For complex geometries with several materials, this can result in reduced draw calls and improved performance.

.scale (x : Float, y : Float, z : Float) : Geometry

Scale the geometry data. This is typically done as a one time operation but not during the render loop.
Use Object3D.scale for typical real-time mesh scaling.

.toJSON () : JSON

Convert the geometry to JSON format.

.translate (x : Float, y : Float, z : Float) : Geometry

Translate the geometry. This is typically done as a one time operation but not during the render loop.
Use Object3D.position for typical real-time mesh translation.

Source

For more info on how to obtain the source code of this module see this page.