Class ConvexPolyhedron

A set of polygons describing a convex shape.

The shape MUST be convex for the code to work properly. No polygons may be coplanar (contained in the same 3D plane), instead these should be merged into one polygon.

Todo

Move the clipping functions to ContactGenerator?

Todo

Automatically merge coplanar polygons in constructor.

Example

const convexShape = new CANNON.ConvexPolyhedron({ vertices, faces })
    const convexBody = new CANNON.Body({ mass: 1, shape: convexShape })
    world.addBody(convexBody)

Hierarchy (view full)

Shape
- ConvexPolyhedron
  - Cylinder

Constructors

constructor

new ConvexPolyhedron(props?): ConvexPolyhedron
Parameters
- Optional props: {
      axes?: Vec3[];
      boundingSphereRadius?: number;
      faces?: number[][];
      normals?: Vec3[];
      vertices?: Vec3[];
  }
  - Optional axes?: Vec3[]
    axes
  - Optional boundingSphereRadius?: number
    boundingSphereRadius
  - Optional faces?: number[][]
    Array of integer arrays, describing which vertices that is included in each face.
  - Optional normals?: Vec3[]
    normals
  - Optional vertices?: Vec3[]
    An array of Vec3's
Returns ConvexPolyhedron
Overrides Shape.constructor

Properties

body

body: Body

The body to which the shape is added to.

boundingSphereRadius

boundingSphereRadius: number

The local bounding sphere radius of this shape.

collisionFilterGroup

collisionFilterGroup: number

Default

collisionFilterMask

collisionFilterMask: number

Default

-1

collisionResponse

collisionResponse: boolean

Whether to produce contact forces when in contact with other bodies. Note that contacts will be generated, but they will be disabled.

Default

true

faceNormals

faceNormals: Vec3[]

faceNormals

faces

faces: number[][]

Array of integer arrays, indicating which vertices each face consists of

id

id: number

Identifier of the Shape.

material

material: Material

Optional material of the shape that regulates contact properties.

type

type: 0 | ShapeType

The type of this shape. Must be set to an int > 0 by subclasses.

uniqueAxes

uniqueAxes: Vec3[]

If given, these locally defined, normalized axes are the only ones being checked when doing separating axis check.

uniqueEdges

uniqueEdges: Vec3[]

uniqueEdges

vertices

vertices: Vec3[]

vertices

worldFaceNormals

worldFaceNormals: Vec3[]

worldFaceNormals

worldFaceNormalsNeedsUpdate

worldFaceNormalsNeedsUpdate: boolean

worldFaceNormalsNeedsUpdate

worldVertices

worldVertices: Vec3[]

worldVertices

worldVerticesNeedsUpdate

worldVerticesNeedsUpdate: boolean

worldVerticesNeedsUpdate

`Static` idCounter

idCounter: number

`Static` types

types: {
    BOX: 4;
    COMPOUND: 8;
    CONVEXPOLYHEDRON: 16;
    CYLINDER: 128;
    HEIGHTFIELD: 32;
    PARTICLE: 64;
    PLANE: 2;
    SPHERE: 1;
    TRIMESH: 256;
}

All the Shape types.

Type declaration

Readonly BOX: 4
BOX
Readonly COMPOUND: 8
COMPOUND
Readonly CONVEXPOLYHEDRON: 16
CONVEXPOLYHEDRON
Readonly CYLINDER: 128
CYLINDER
Readonly HEIGHTFIELD: 32
HEIGHTFIELD
Readonly PARTICLE: 64
PARTICLE
Readonly PLANE: 2
PLANE
Readonly SPHERE: 1
SPHERE
Readonly TRIMESH: 256
TRIMESH

Methods

calculateLocalInertia

calculateLocalInertia(mass, target): void
calculateLocalInertia
Parameters
- mass: number
- target: Vec3
Returns void
Overrides Shape.calculateLocalInertia

calculateWorldAABB

calculateWorldAABB(pos, quat, min, max): void
calculateWorldAABB
Parameters
- pos: Vec3
- quat: Quaternion
- min: Vec3
- max: Vec3
Returns void
Overrides Shape.calculateWorldAABB

clipAgainstHull

clipAgainstHull(posA, quatA, hullB, posB, quatB, separatingNormal, minDist, maxDist, result): void
Parameters
- posA: Vec3
- quatA: Quaternion
- hullB: ConvexPolyhedron
- posB: Vec3
- quatB: Quaternion
- separatingNormal: Vec3
- minDist: number
  Clamp distance
- maxDist: number
- result: ConvexPolyhedronContactPoint[]
  The an array of contact point objects, see clipFaceAgainstHull
Returns void

clipFaceAgainstHull

clipFaceAgainstHull(separatingNormal, posA, quatA, worldVertsB1, minDist, maxDist, result): void
Clip a face against a hull.
Parameters
- separatingNormal: Vec3
- posA: Vec3
- quatA: Quaternion
- worldVertsB1: Vec3[]
  An array of Vec3 with vertices in the world frame.
- minDist: number
  Distance clamping
- maxDist: number
- result: ConvexPolyhedronContactPoint[]
Returns void

clipFaceAgainstPlane

clipFaceAgainstPlane(inVertices, outVertices, planeNormal, planeConstant): Vec3[]
Clip a face in a hull against the back of a plane.
Parameters
- inVertices: Vec3[]
- outVertices: Vec3[]
- planeNormal: Vec3
- planeConstant: number
  The constant in the mathematical plane equation
Returns Vec3[]

computeEdges

computeEdges(): void
Computes uniqueEdges

Returns void

computeLocalAABB

computeLocalAABB(aabbmin, aabbmax): void
Parameters
- aabbmin: Vec3
- aabbmax: Vec3
Returns void

computeNormals

computeNormals(): void
Compute the normals of the faces. Will reuse existing Vec3 objects in the faceNormals array if they exist.

Returns void

computeWorldFaceNormals

computeWorldFaceNormals(quat): void
Updates worldVertices and sets worldVerticesNeedsUpdate to false.
Parameters
- quat: Quaternion
Returns void

computeWorldVertices

computeWorldVertices(position, quat): void
Updates .worldVertices and sets .worldVerticesNeedsUpdate to false.
Parameters
- position: Vec3
- quat: Quaternion
Returns void

findSeparatingAxis

findSeparatingAxis(hullB, posA, quatA, posB, quatB, target, faceListA?, faceListB?): boolean
Find the separating axis between this hull and another
Parameters
- hullB: ConvexPolyhedron
- posA: Vec3
- quatA: Quaternion
- posB: Vec3
- quatB: Quaternion
- target: Vec3
  The target vector to save the axis in
- Optional faceListA: number[]
- Optional faceListB: number[]
Returns boolean
Returns false if a separation is found, else true

getAveragePointLocal

getAveragePointLocal(target?): Vec3
Get an average of all the vertices positions
Parameters
- Optional target: Vec3
Returns Vec3

getFaceNormal

getFaceNormal(i, target): void
Compute the normal of a face from its vertices
Parameters
- i: number
- target: Vec3
Returns void

getPlaneConstantOfFace

getPlaneConstantOfFace(face_i): number
Parameters
- face_i: number
  Index of the face
Returns number

pointIsInside

pointIsInside(p): false | 1 | -1
Checks whether p is inside the polyhedra. Must be in local coords. The point lies outside of the convex hull of the other points if and only if the direction of all the vectors from it to those other points are on less than one half of a sphere around it.
Parameters
- p: Vec3
  A point given in local coordinates
Returns false | 1 | -1

testSepAxis

testSepAxis(axis, hullB, posA, quatA, posB, quatB): number | false
Test separating axis against two hulls. Both hulls are projected onto the axis and the overlap size is returned if there is one.
Parameters
- axis: Vec3
- hullB: ConvexPolyhedron
- posA: Vec3
- quatA: Quaternion
- posB: Vec3
- quatB: Quaternion
Returns number | false
The overlap depth, or FALSE if no penetration.

transformAllPoints

transformAllPoints(offset, quat): void
Transform all local points. Will change the .vertices
Parameters
- offset: Vec3
- quat: Quaternion
Returns void

updateBoundingSphereRadius

updateBoundingSphereRadius(): void
updateBoundingSphereRadius

Returns void
Overrides Shape.updateBoundingSphereRadius

volume

volume(): number
Get approximate convex volume

Returns number
Overrides Shape.volume

`Static` computeNormal

computeNormal(va, vb, vc, target): void
Get face normal given 3 vertices
Parameters
- va: Vec3
- vb: Vec3
- vc: Vec3
- target: Vec3
Returns void

`Static` project

project(shape, axis, pos, quat, result): void
Get max and min dot product of a convex hull at position (pos,quat) projected onto an axis. Results are saved in the array maxmin.
Parameters
- shape: ConvexPolyhedron
- axis: Vec3
- pos: Vec3
- quat: Quaternion
- result: number[]
  result[0] and result[1] will be set to maximum and minimum, respectively.
Returns void

Class ConvexPolyhedron

Author

Author

See

Todo

Todo

Example

Hierarchy (view full)

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Optional props: { axes?: Vec3[]; boundingSphereRadius?: number; faces?: number[][]; normals?: Vec3[]; vertices?: Vec3[]; }

Optional axes?: Vec3[]

Optional boundingSphereRadius?: number

Optional faces?: number[][]

Optional normals?: Vec3[]

Optional vertices?: Vec3[]

Returns ConvexPolyhedron

Properties

body

boundingSphereRadius

collisionFilterGroup

Default

collisionFilterMask

Default

collisionResponse

Default

faceNormals

faces

id

material

type

uniqueAxes

uniqueEdges

vertices

worldFaceNormals

worldFaceNormalsNeedsUpdate

worldVertices

worldVerticesNeedsUpdate

Static idCounter

Static types

Type declaration

Readonly BOX: 4

Readonly COMPOUND: 8

Readonly CONVEXPOLYHEDRON: 16

Readonly CYLINDER: 128

Readonly HEIGHTFIELD: 32

Readonly PARTICLE: 64

Readonly PLANE: 2

Readonly SPHERE: 1

Readonly TRIMESH: 256

Methods

calculateLocalInertia

Parameters

mass: number

target: Vec3

Returns void

calculateWorldAABB

Parameters

pos: Vec3

quat: Quaternion

min: Vec3

max: Vec3

Returns void

clipAgainstHull

Parameters

posA: Vec3

quatA: Quaternion

hullB: ConvexPolyhedron

posB: Vec3

quatB: Quaternion

separatingNormal: Vec3

minDist: number

maxDist: number

result: ConvexPolyhedronContactPoint[]

Returns void

`Optional` props: {
axes?: Vec3[];
boundingSphereRadius?: number;
faces?: number[][];
normals?: Vec3[];
vertices?: Vec3[];
}

`Optional` axes?: Vec3[]

`Optional` boundingSphereRadius?: number

`Optional` faces?: number[][]

`Optional` normals?: Vec3[]

`Optional` vertices?: Vec3[]

`Static` idCounter

`Static` types

`Readonly` BOX: 4

`Readonly` COMPOUND: 8

`Readonly` CONVEXPOLYHEDRON: 16

`Readonly` CYLINDER: 128

`Readonly` HEIGHTFIELD: 32

`Readonly` PARTICLE: 64

`Readonly` PLANE: 2

`Readonly` SPHERE: 1

`Readonly` TRIMESH: 256

`Optional` faceListA: number[]

`Optional` faceListB: number[]

`Optional` target: Vec3