G3D::Capsule Class Reference

#include <Capsule.h>

Public Member Functions
	Capsule ()
	Capsule (class BinaryInput &b)
	Capsule (const Vector3 &_p1, const Vector3 &_p2, float _r)
void	serialize (class BinaryOutput &b) const
void	deserialize (class BinaryInput &b)
Line	axis () const
float	radius () const
Vector3	point (int i) const
float	height () const
Vector3	center () const
void	getReferenceFrame (class CoordinateFrame &cframe) const
bool	contains (const Vector3 &p) const
float	volume () const
float	area () const
void	getBounds (AABox &out) const
void	getRandomSurfacePoint (Vector3 &P, Vector3 &N) const
Vector3	randomInteriorPoint () const

Private Attributes
Vector3	p1
Vector3	p2
float	_radius

Detailed Description

A shape formed by extruding a sphere along a line segment.

Constructor & Destructor Documentation

G3D::Capsule::Capsule

(

)

Uninitialized

 {
}

G3D::Capsule::Capsule

(

class BinaryInput &

b

)

 {
 deserialize(b);
}

Here is the call graph for this function:

G3D::Capsule::Capsule	(	const Vector3 &	_p1,
		const Vector3 &	_p2,
		float	_r
	)

 : p1(_p1), p2(_p2), _radius(_r) {
}

Member Function Documentation

float G3D::Capsule::area

(

)

const

 {

 return
 // Sphere area
 pow(_radius, 2) * 4 * (float)pi() +

 // Cylinder area
 (float)twoPi() * _radius * (p1 - p2).magnitude();
}

Here is the call graph for this function:

Line G3D::Capsule::axis

(

)

const

The line down the center of the capsule

 {
 return Line::fromTwoPoints(p1, p2);
}

Here is the call graph for this function:

Vector3 G3D::Capsule::center ( ) const

inline

 {
 return (p1 + p2) / 2.0;
 }

Here is the caller graph for this function:

bool G3D::Capsule::contains

(

const Vector3 &

p

)

const

Returns true if the point is inside the capsule or on its surface.

 { 
 return LineSegment::fromTwoPoints(p1, p2).distanceSquared(p) <= square(radius());
}

Here is the call graph for this function:

void G3D::Capsule::deserialize

(

class BinaryInput &

b

)

 {
 p1.deserialize(b);
 p2.deserialize(b);
 _radius = (float)b.readFloat64();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Capsule::getBounds

(

AABox &

out

)

const

Get axis aligned bounding box

 {
 Vector3 min = p1.min(p2) - (Vector3(1, 1, 1) * _radius);
 Vector3 max = p1.max(p2) + (Vector3(1, 1, 1) * _radius);

 out = AABox(min, max);
}

Here is the call graph for this function:

void G3D::Capsule::getRandomSurfacePoint	(	Vector3 &	P,
		Vector3 &	N
	)		const

Random world space point with outward facing normal.

 {
 float h = height();
 float r = radius();

 // Create a random point on a standard capsule and then rotate to the global frame.

 // Relative areas
 float capRelArea = sqrt(r) / 2.0f;
 float sideRelArea = r * h;

 float r1 = uniformRandom(0, capRelArea * 2 + sideRelArea);

 if (r1 < capRelArea * 2) {

 // Select a point uniformly at random on a sphere
 N = Sphere(Vector3::zero(), 1).randomSurfacePoint();
 p = N * r;
 p.y += sign(p.y) * h / 2.0f;
 } else {
 // Side
 float a = uniformRandom(0, (float)twoPi());
 N.x = cos(a);
 N.y = 0;
 N.z = sin(a);
 p.x = N.x * r;
 p.z = N.y * r;
 p.y = uniformRandom(-h / 2.0f, h / 2.0f);
 }

 // Transform to world space
 CoordinateFrame cframe;
 getReferenceFrame(cframe);
 
 p = cframe.pointToWorldSpace(p);
 N = cframe.normalToWorldSpace(N);
}

Here is the call graph for this function:

void G3D::Capsule::getReferenceFrame

(

class CoordinateFrame &

cframe

)

const

Get a reference frame in which the center of mass is the origin and Y is the axis of the capsule.

 {
 cframe.translation = center();

 Vector3 Y = (p1 - p2).direction();
 Vector3 X = (abs(Y.dot(Vector3::unitX())) > 0.9) ? Vector3::unitY() : Vector3::unitX();
 Vector3 Z = X.cross(Y).direction();
 X = Y.cross(Z); 
 cframe.rotation.setColumn(0, X);
 cframe.rotation.setColumn(1, Y);
 cframe.rotation.setColumn(2, Z);
}

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::Capsule::height ( ) const

inline

Distance between the sphere centers. The total extent of the cylinder is 2r + h.

 {
 return (p1 - p2).magnitude();
 }

Here is the caller graph for this function:

Vector3 G3D::Capsule::point ( int  i ) const

inline

Argument may be 0 or 1

 {
 debugAssert(i == 0 || i == 1);
 return (i == 0) ? p1 : p2;
 }

Here is the caller graph for this function:

float G3D::Capsule::radius ( ) const

inline

 {
 return _radius;
 }

Here is the caller graph for this function:

Vector3 G3D::Capsule::randomInteriorPoint

(

)

const

Point selected uniformly at random over the volume.

 {
 float h = height();
 float r = radius();

 // Create a random point in a standard capsule and then rotate to the global frame.

 Vector3 p;

 float hemiVolume = (float)pi() * (r*r*r) * 4 / 6.0f;
 float cylVolume = (float)pi() * square(r) * h;
 
 float r1 = uniformRandom(0, 2.0f * hemiVolume + cylVolume);

 if (r1 < 2.0 * hemiVolume) {

 p = Sphere(Vector3::zero(), r).randomInteriorPoint();

 p.y += sign(p.y) * h / 2.0f;

 } else {

 // Select a point uniformly at random on a disk
 float a = uniformRandom(0, (float)twoPi());
 float r2 = sqrt(uniformRandom(0, 1)) * r;

 p = Vector3(cos(a) * r2,
 uniformRandom(-h / 2.0f, h / 2.0f),
 sin(a) * r2);
 }

 // Transform to world space
 CoordinateFrame cframe;
 getReferenceFrame(cframe);
 
 return cframe.pointToWorldSpace(p);
}

Here is the call graph for this function:

void G3D::Capsule::serialize

(

class BinaryOutput &

b

)

const

 {
 p1.serialize(b);
 p2.serialize(b);
 b.writeFloat64(_radius);
}

Here is the call graph for this function:

float G3D::Capsule::volume

(

)

const

 {
 return 
 // Sphere volume
 pow(_radius, 3) * (float)pi() * 4 / 3 +

 // Cylinder volume
 pow(_radius, 2) * (p1 - p2).magnitude();
}

Here is the call graph for this function:

Member Data Documentation

float G3D::Capsule::_radius

private

Vector3 G3D::Capsule::p1

private

Vector3 G3D::Capsule::p2

private

---

The documentation for this class was generated from the following files:

• dep/g3dlite/include/G3D/Capsule.h
• dep/g3dlite/source/Capsule.cpp