Classes
class	SkinRender
class	Camera
class	SignColorFunctor
class	GreyScaleColorFunctor
class	GradientColorFunctor
class	CrossSections
class	MeshDrawArray
class	MeshDrawDisplayLists
class	FramebufferObject
class	Frustum
class	Material
class	OnScreenDisplay
class	Picking
class	Renderbuffer
class	TrackBall
Typedefs
typedef boost::shared_ptr < Renderbuffer >	renderbuffer_pointer
Functions
template<typename versatile_mesh >
void	DrawVersatilePenaltyForces (versatile_mesh &mesh)
template<typename versatile_mesh >
void	DrawVersatileInternalForces (versatile_mesh &mesh)
template<typename versatile_mesh >
void	DrawVersatileExternalForces (versatile_mesh &mesh)
bool	is_float_texture_supported ()
template<typename types >
void	MultCameraMatrix (Camera< types > const &camera)
template<typename types >
void	LoadCameraMatrix (Camera< types > const &camera)
void	gl_check_errors (const char *location=0, std::ostream &ostr=std::cerr)
template<typename T1 , typename T2 , typename T3 , typename T4 >
void	ColorPicker (T1 const red, T2 const green, T3 const blue, T4 const alpha, unsigned int face=GL_FRONT_AND_BACK)
template<typename T1 , typename T2 , typename T3 >
void	ColorPicker (T1 const red, T2 const green, T3 const blue)
template<typename aabb_type >
void	DrawAABB (aabb_type const &aabb, bool wireframe=false)
template<typename vector3_type >
void	DrawArc (vector3_type const &x0, vector3_type const &x1, typename vector3_type::value_type const &theta)
template<typename bone_type >
void	DrawBone (bone_type const &bone)
template<typename bone_type >
void	DrawFancyBone (bone_type const &bone)
template<typename bone_type >
void	DrawStickBone (bone_type const &bone, float red=0.7, float green=0.7, float blue=0.7)
template<typename bone_type , typename capsule_type >
void	DrawFatBone (bone_type const &bone, capsule_type capsule, float red=0.7, float green=0.7, float blue=0.7, float thickness=0.2)
template<typename bone_type , typename transform_container >
void	DrawBonePath (bone_type const &bone, transform_container const &poses, double const radius=0.02)
template<typename capsule_type >
void	DrawCapsule (capsule_type const &capsule, bool wireframe=false)
template<typename chain_type >
void	DrawChain (chain_type const &chain)
template<typename cylinder_type >
void	DrawCylinder (cylinder_type const &cylinder, bool wireframe=false)
template<typename ellipsoid_type >
void	DrawEllipsoid (ellipsoid_type const &ellipsoid, bool wireframe=false)
template<typename T >
void	DrawFrame (math::Vector3< T > const &p, math::Quaternion< T > const &Q)
template<typename V >
void	DrawFrame (math::CoordSys< V > const &C)
template<typename grid_type >
void	DrawGrid (grid_type const &grid)
template<typename grid_type >
void	DrawGridAABB (grid_type const &grid)
template<typename grid_type >
void	DrawGridPlanes (grid_type const &grid, unsigned int const &k)
template<typename hybrid_type >
void	DrawHybrid (hybrid_type const &hybrid, bool wireframe=false)
template<typename image_type >
void	DrawImage (image_type const &image)
template<typename bone_type >
void	DrawJointLimits (bone_type const &bone)
template<typename face_type >
void	DrawMeshFace (face_type const &face, bool wireframe=false, bool use_colors=true, bool use_normals=true, bool use_texcoords=true)
template<typename mesh_type >
void	DrawMesh (mesh_type const &mesh, unsigned int mode=GL_POLYGON, bool use_colors=true, bool use_normals=true, bool use_texcoords=true)
template<typename mesh_type >
void	DrawSkinMesh (mesh_type const &mesh, unsigned int mode=GL_POLYGON)
template<typename obb_type >
void	DrawOBB (obb_type const &obb, bool wireframe=false)
template<typename plane_type >
void	DrawPlane (plane_type const &plane, bool wireframe=false)
template<typename plane_box_type >
void	DrawPlaneBox (plane_box_type const &box, bool wireframe=true)
template<typename vector3_type >
void	DrawPoint (vector3_type const &p, double const radius=0.1)
template<typename prism_type >
void	DrawPrism (prism_type const &prism, unsigned int mode)
template<typename sphere_type >
void	DrawSphere (sphere_type const &sphere, bool wireframe=false)
template<typename vector3_type >
void	DrawString (std::string const &str, vector3_type const &T, float width=0.0f)
template<typename t4mesh >
void	DrawT4Mesh (t4mesh const &mesh, double scale=0.95, bool wireframe=false)
template<typename point_container , typename t4mesh >
void	DrawPointsT4Mesh (point_container const &points, t4mesh const &mesh, double const &scale=0.95, bool wireframe=false)
template<typename t4mesh_type , typename plane_type >
void	DrawT4MeshCutThrough (t4mesh_type const &mesh, plane_type const &plane, double scale=1.0, bool wireframe=false)
template<typename point_container , typename t4mesh_type , typename plane_type >
void	DrawPointsT4MeshCutThrough (point_container const &points, t4mesh_type const &mesh, plane_type const &plane, double scale=1.0, bool wireframe=false)
template<typename tetrahedron_type >
void	DrawTetrahedron (tetrahedron_type const &tetrahedron, bool wireframe=false)
template<typename texture_type >
void	DrawTexture2D (texture_type const &texture)
template<typename torus_type >
void	DrawTorus (torus_type const &torus, bool wireframe=false)
template<typename triangle_type >
void	DrawTriangle (triangle_type const &triangle, bool wireframe=false)
template<typename vector3_type >
void	DrawVector (vector3_type const &p, vector3_type const &v, double scale=1.0, bool draw_pos=true)
template<typename vector3_type >
void	DrawVector (vector3_type const &v)
bool	is_framebuffer_object_supported ()
template<typename real_type , typename vector3_type >
vector3_type	xform (real_type *M, vector3_type const &v)
template<typename real_type >
void	mul (real_type const A, real_type const B, real_type *C)
template<typename real_type >
void	transpose (real_type const M, real_type T)
template<typename real_type >
void	transpose (real_type *M)
template<typename real_type >
real_type	invert (real_type const M, real_type I)
template<typename real_type >
void	orthonormalize (real_type const M, real_type O)
renderbuffer_pointer	create_depth_buffer (unsigned int width, unsigned int height)
renderbuffer_pointer	create_stencil_buffer (unsigned int width, unsigned int height)
renderbuffer_pointer	create_packed_depth_and_stencil_buffer (unsigned int width, unsigned int height)
void	Screen2Object (int sx, int sy, double &ox, double &oy, double &oz)
template<typename types >
void	MultTrackballMatrix (TrackBall< types > const &trackball)
template<typename types >
void	LoadTrackballMatrix (TrackBall< types > const &trackball)
template<typename value_type >
void	Transform (math::Vector3< value_type > const &r)
template<typename value_type >
void	Transform (math::Quaternion< value_type > const &Q)
template<typename vector3_type , typename quaternion_type >
void	Transform (vector3_type const &r, quaternion_type const &Q)
template<typename V >
void	Transform (math::CoordSys< V > const &C)

Typedef Documentation

typedef boost::shared_ptr<Renderbuffer> OpenTissue::gl::renderbuffer_pointer

Function Documentation

template<typename T1 , typename T2 , typename T3 , typename T4 >

void OpenTissue::gl::ColorPicker	(	T1 const	red,
		T2 const	green,
		T3 const	blue,
		T4 const	alpha,
		unsigned int	face = `GL_FRONT_AND_BACK`
	)			`[inline]`

OpenGL Color Picker.

template<typename T1 , typename T2 , typename T3 >

void OpenTissue::gl::ColorPicker	(	T1 const	red,
		T2 const	green,
		T3 const	blue
	)			`[inline]`

renderbuffer_pointer OpenTissue::gl::create_depth_buffer	(	unsigned int	width,
		unsigned int	height
	)			`[inline]`

Create Depth Buffer. This method is a convenience tool, it makes it easier to create a render buffer representing a depth buffer.

Parameters:

	width	The number of pixels in a row of the depth buffer.
	height	The number of rows in the depth buffer.

renderbuffer_pointer OpenTissue::gl::create_packed_depth_and_stencil_buffer	(	unsigned int	width,
		unsigned int	height
	)			`[inline]`

Create Stencil Buffer. This method is a convenience tool, it makes it easier to create a render buffer representing a packed depth and stencil buffer.

Parameters:

	width	The number of pixels in a row of the buffer.
	height	The number of rows in the buffer.

renderbuffer_pointer OpenTissue::gl::create_stencil_buffer	(	unsigned int	width,
		unsigned int	height
	)			`[inline]`

Create Stencil Buffer. This method is a convenience tool, it makes it easier to create a render buffer representing a stencil buffer.

Parameters:

	width	The number of pixels in a row of the stencil buffer.
	height	The number of rows in the stencil buffer.

template<typename aabb_type >

void OpenTissue::gl::DrawAABB	(	aabb_type const &	aabb,
		bool	wireframe = `false`
	)			`[inline]`

Draw AABB This method draws the AABB in the world coordinate system.

Parameters:

	aabb	A reference to the AABB that should be drawn.
	wireframe	Draw in wireframe or normal.

template<typename vector3_type >

void OpenTissue::gl::DrawArc	(	vector3_type const &	x0,
		vector3_type const &	x1,
		typename vector3_type::value_type const &	theta
	)			`[inline]`

Draw Arc (always bool wireframe = true)

Parameters:

	sphere	A reference to the sphere that should be drawn.
	wireframe	Draw in wireframe or normal.

template<typename bone_type >

void OpenTissue::gl::DrawBone ( bone_type const & bone ) [inline]

Draw Bone. Orientations and translations are simply drawn as arrows and coordinate frames.

Parameters:

bone

A reference to the bone that should be drawn.

template<typename bone_type , typename transform_container >

void OpenTissue::gl::DrawBonePath	(	bone_type const &	bone,
		transform_container const &	poses,
		double const	radius = `0.02`
	)			`[inline]`

Draw Bone Path. Draw bone path as a sequence of points. This is a good tool for visualization motion samples.

Parameters:

	bone	A reference to the bone that should be drawn.
	poses	A transform container, containing sampled poses of the bone motion.
	radius	The radius size of the path being drawn. Default value is 0.02.

template<typename capsule_type >

void OpenTissue::gl::DrawCapsule	(	capsule_type const &	capsule,
		bool	wireframe = `false`
	)			`[inline]`

Draw Capsule

Parameters:

	capsule	A reference to the capsule that should be drawn
	wireframe	Draw in wireframe or normal.

template<typename chain_type >

void OpenTissue::gl::DrawChain ( chain_type const & chain ) [inline]

Draw Chain.

Parameters:

chain

A reference to the chain that should be drawn.

template<typename cylinder_type >

void OpenTissue::gl::DrawCylinder	(	cylinder_type const &	cylinder,
		bool	wireframe = `false`
	)			`[inline]`

Drawing Routine

Parameters:

	cylinder	A reference to the cylinder that should be drawn.
	wireframe	Draw in wireframe or normal.

template<typename ellipsoid_type >

void OpenTissue::gl::DrawEllipsoid	(	ellipsoid_type const &	ellipsoid,
		bool	wireframe = `false`
	)			`[inline]`

Draw Ellipsoid.

Parameters:

	ellipsoid	A refernece to the ellipsoid that should be drawn
	wireframe	Draw in wireframe or normal.

template<typename bone_type >

void OpenTissue::gl::DrawFancyBone ( bone_type const & bone ) [inline]

Draw Bone. Mimics Maya's bone visualization. Translations are drawn as pyramids and orientaions as circular arcs on a sphere.

Observe that the pyramid for the root bone is not drawn. This may cause one to think that a bone consist of a ``sphere-pyramid'' pairing. This is however misleadning the true pairing that match the underlying bone transform is ``pyramid-sphere''.

Parameters:

bone

A reference to the bone that should be drawn.

template<typename bone_type , typename capsule_type >

void OpenTissue::gl::DrawFatBone	(	bone_type const &	bone,
		capsule_type	capsule,
		float	red = `0.7`,
		float	green = `0.7`,
		float	blue = `0.7`,
		float	thickness = `0.2`
	)			`[inline]`

Draw Fat Bone. the bone is drawn as a capsule the color can be chosen or left at the default light grey.

Parameters:

bone

A reference to the bone that should be drawn.

template<typename T >

void OpenTissue::gl::DrawFrame	(	math::Vector3< T > const &	p,
		math::Quaternion< T > const &	Q
	)			`[inline]`

Draw Frame.

Parameters:

	p	The point where to place origo of the frame
	Q	The orientation of the frame as a quaterion.

template<typename V >

void OpenTissue::gl::DrawFrame ( math::CoordSys< V > const & C ) [inline]

template<typename grid_type >

void OpenTissue::gl::DrawGrid ( grid_type const & grid ) [inline]

template<typename grid_type >

void OpenTissue::gl::DrawGridAABB ( grid_type const & grid ) [inline]

Draw AABB box around the Grid.

Parameters:

grid

The grid to draw.

template<typename grid_type >

void OpenTissue::gl::DrawGridPlanes	(	grid_type const &	grid,
		unsigned int const &	k
	)			`[inline]`

template<typename hybrid_type >

void OpenTissue::gl::DrawHybrid	(	hybrid_type const &	hybrid,
		bool	wireframe = `false`
	)			`[inline]`

Draw Hybrid This method draws the hybrid volume in the world coordinate system.

Parameters:

	hybdrid	A reference to the Hybrid that should be drawn.
	wireframe	Draw in wireframe or normal.

template<typename image_type >

void OpenTissue::gl::DrawImage ( image_type const & image ) [inline]

template<typename bone_type >

void OpenTissue::gl::DrawJointLimits ( bone_type const & bone ) [inline]

Draw Inverse Kinematics Joint Limits

Parameters:

bone

A skeleton bone holding information about the joint limits that should be visualized.

template<typename mesh_type >

void OpenTissue::gl::DrawMesh	(	mesh_type const &	mesh,
		unsigned int	mode = `GL_POLYGON`,
		bool	use_colors = `true`,
		bool	use_normals = `true`,
		bool	use_texcoords = `true`
	)			`[inline]`

Simple brute force openGL drawing. This is usefull for debugging, since it is extremely robust. However, it is also extremely slow.

Parameters:

	mesh	The mesh that should be drawn.
	mode	The mode that the polygon mesh should be drawn in (GL_POLYGON or GL_LINE_LOOP are accepted).

template<typename face_type >

void OpenTissue::gl::DrawMeshFace	(	face_type const &	face,
		bool	wireframe = `false`,
		bool	use_colors = `true`,
		bool	use_normals = `true`,
		bool	use_texcoords = `true`
	)			`[inline]`

Simple brute force openGL drawing. This is usefull for debugging, since it is extremely robust. However, it is also extremely slow.

Parameters:

	face	The mesh face that should be drawn.
	wireframe	whether the face should be drawn in wireframe or normal (solid).

template<typename obb_type >

void OpenTissue::gl::DrawOBB	(	obb_type const &	obb,
		bool	wireframe = `false`
	)			`[inline]`

Drawing Routine

Parameters:

	obb
	wireframe	Draw in wireframe or normal.

template<typename plane_type >

void OpenTissue::gl::DrawPlane	(	plane_type const &	plane,
		bool	wireframe = `false`
	)			`[inline]`

Draw Plane.

Parameters:

	plane	A reference to the plane that should be drawn.
	wireframe	Draw in wireframe or normal.

template<typename plane_box_type >

void OpenTissue::gl::DrawPlaneBox	(	plane_box_type const &	box,
		bool	wireframe = `true`
	)			`[inline]`

Draw Plane Box.

Parameters:

	box	A reference to a plane box object.
	wireframe	A boolean indicating whether the plane box should be visualized as wireframe or solid.

template<typename vector3_type >

void OpenTissue::gl::DrawPoint	(	vector3_type const &	p,
		double const	radius = `0.1`
	)			`[inline]`

Draw Point.

template<typename point_container , typename t4mesh >

void OpenTissue::gl::DrawPointsT4Mesh	(	point_container const &	points,
		t4mesh const &	mesh,
		double const &	scale = `0.95`,
		bool	wireframe = `false`
	)			`[inline]`

Parameters:

	points	A point container with coordinates of the nodes.
	mesh	The mesh that should be drawn.
	scale	A scale of each individual tetrahedron that is drawn.
	wireframe	Draw in wireframe or normal.

template<typename point_container , typename t4mesh_type , typename plane_type >

void OpenTissue::gl::DrawPointsT4MeshCutThrough	(	point_container const &	points,
		t4mesh_type const &	mesh,
		plane_type const &	plane,
		double	scale = `1.0`,
		bool	wireframe = `false`
	)			`[inline]`

Draw t4mesh cut through.

Assumes that nodes have default memeber m_coord

Parameters:

	points	A point container with coordinates of the nodes.
	mesh	The mesh that should be drawn.
	plane	The plane that defines the cut.
	scale	A scale of each individual tetrahedron that is drawn.
	wireframe	Draw in wireframe or normal.

template<typename prism_type >

void OpenTissue::gl::DrawPrism	(	prism_type const &	prism,
		unsigned int	mode
	)			`[inline]`

Prism Drawing Routine

prism

Parameters:

mode

GL_LINE_LOOP or GL_POLYGON mode

template<typename mesh_type >

void OpenTissue::gl::DrawSkinMesh	(	mesh_type const &	mesh,
		unsigned int	mode = `GL_POLYGON`
	)			`[inline]`

template<typename sphere_type >

void OpenTissue::gl::DrawSphere	(	sphere_type const &	sphere,
		bool	wireframe = `false`
	)			`[inline]`

Draw Sphere.

Parameters:

	sphere	A reference to the sphere that should be drawn.
	wireframe	Draw in wireframe or normal.

template<typename bone_type >

void OpenTissue::gl::DrawStickBone	(	bone_type const &	bone,
		float	red = `0.7`,
		float	green = `0.7`,
		float	blue = `0.7`
	)			`[inline]`

Draw Stick Bone. Orientations and translations are simply drawn as arrows and coordinate frames.

Parameters:

bone

A reference to the bone that should be drawn.

template<typename vector3_type >

void OpenTissue::gl::DrawString	(	std::string const &	str,
		vector3_type const &	T,
		float	width = `0.0f`
	)			`[inline]`

Draw String. Writes a string at the specified location.

Contributted by Adam Hasselblach and Sren Horn and tweaked by Kenny Erleben.

Parameters:

	str	The string to be drawn
	T	Location in world coordinates
	width	Wanted width of text in world space length. If zero no rescaling of text is done, this is default behavior.

template<typename t4mesh >

void OpenTissue::gl::DrawT4Mesh	(	t4mesh const &	mesh,
		double	scale = `0.95`,
		bool	wireframe = `false`
	)			`[inline]`

Draw t4mesh.

Assumes that nodes have default memeber m_coord

Parameters:

	mesh	The mesh that should be drawn.
	scale	A scale of each individual tetrahedron that is drawn.
	wireframe	Draw in wireframe or normal.

template<typename t4mesh_type , typename plane_type >

void OpenTissue::gl::DrawT4MeshCutThrough	(	t4mesh_type const &	mesh,
		plane_type const &	plane,
		double	scale = `1.0`,
		bool	wireframe = `false`
	)			`[inline]`

Draw t4mesh cut through.

Assumes that nodes have default memeber m_coord

Parameters:

	mesh	The mesh that should be drawn.
	plane	The plane that defines the cut.
	scale	A scale of each individual tetrahedron that is drawn.
	wireframe	Draw in wireframe or normal.

template<typename tetrahedron_type >

void OpenTissue::gl::DrawTetrahedron	(	tetrahedron_type const &	tetrahedron,
		bool	wireframe = `false`
	)			`[inline]`

Drawing Routine

Parameters:

	tetrahedron	A reference to the tetrahedron that should be drawn.
	wireframe	Draw in wireframe or normal.

template<typename texture_type >

void OpenTissue::gl::DrawTexture2D ( texture_type const & texture ) [inline]

Draw 2D Texture. This function is great for debugging 2D textures. It draws a quad with the texture mapped onto it, using simple brute openGL.

Parameters:

texture

The texture that should be drawn.

template<typename torus_type >

void OpenTissue::gl::DrawTorus	(	torus_type const &	torus,
		bool	wireframe = `false`
	)			`[inline]`

Draw Torus

Parameters:

	torus	A reference to the torus that should be drawn
	wireframe	Draw in wireframe or normal.

template<typename triangle_type >

void OpenTissue::gl::DrawTriangle	(	triangle_type const &	triangle,
		bool	wireframe = `false`
	)			`[inline]`

Drawing Routine

Parameters:

	triangle	A reference to the triangle that should be drawn.
	wireframe	Draw in wireframe or normal.

template<typename vector3_type >

void OpenTissue::gl::DrawVector ( vector3_type const & v ) [inline]

Draw Vector.

Parameters:

v

The vector to be drawn, tail will be placed at origin.

template<typename vector3_type >

void OpenTissue::gl::DrawVector	(	vector3_type const &	p,
		vector3_type const &	v,
		double	scale = `1.0`,
		bool	draw_pos = `true`
	)			`[inline]`

Draw Vector.

Parameters:

	p	The position at which the tail of the vector should be placed.
	v	The vector itself

template<typename versatile_mesh >

void OpenTissue::gl::DrawVersatileExternalForces ( versatile_mesh & mesh ) [inline]

template<typename versatile_mesh >

void OpenTissue::gl::DrawVersatileInternalForces ( versatile_mesh & mesh ) [inline]

template<typename versatile_mesh >

void OpenTissue::gl::DrawVersatilePenaltyForces ( versatile_mesh & mesh ) [inline]

void OpenTissue::gl::gl_check_errors	(	const char *	location = `0`,
		std::ostream &	ostr = `std::cerr`
	)			`[inline]`

A simple OpenGL error checking routine. This compiles away to a no-op method if the NDEBUG preprocessor symbol is defined during compilation.

Parameters:

	location	Optional. A string that can be used to indicate the location where the error check occurs.
	ostr	Optional. Determines the destination of the error message. Defaults to cerr, but could also be a file.

template<typename real_type >

real_type OpenTissue::gl::invert	(	real_type const *	M,
		real_type *	I
	)			`[inline]`

Invert a 4x4 matrix

Parameters:

	M	the matrix to be inverted
	iM	the inverted matrix

Returns:: the determinant of M. If zero, the matrix is invertible.

bool OpenTissue::gl::is_float_texture_supported ( ) [inline]

Test if floating point texture formats are supported. This is a convenience function that makes it easier for end users to determine whether floating point textures are supported by their opengl drivers.

Returns:: If supported then thereturn value is true otherwise it is false.

bool OpenTissue::gl::is_framebuffer_object_supported ( ) [inline]

Test if Framebuffer object is supported. This is a convenience function that makes it easier for end users to determine whether the frame buffer object (and render buffers) are supported by their opengl drivers.

Returns:: If framebuffer object is supported then the return value is true otherwise it is false.

template<typename types >

void OpenTissue::gl::LoadCameraMatrix ( Camera< types > const & camera ) [inline]

Parameters:

camera

template<typename types >

void OpenTissue::gl::LoadTrackballMatrix ( TrackBall< types > const & trackball ) [inline]

Loads the Trackball transformation matrix onto the current opengl matrix stack.

template<typename real_type >

void OpenTissue::gl::mul	(	real_type const *	A,
		real_type const *	B,
		real_type *	C
	)			`[inline]`

Matrix-Matrix Multiplication. Auxiliary method used to multiply opengl matrices.

C = A*B

All matrices are represented in column major form.

Parameters:

	A
	B
	C

template<typename types >

void OpenTissue::gl::MultCameraMatrix ( Camera< types > const & camera ) [inline]

Parameters:

camera

template<typename types >

void OpenTissue::gl::MultTrackballMatrix ( TrackBall< types > const & trackball ) [inline]

Multiplies the top element of the current openGL stack with the trackball transformation matrix.

template<typename real_type >

void OpenTissue::gl::orthonormalize	(	real_type const *	M,
		real_type *	O
	)			`[inline]`

Orthonormalize OpenGL Matrix

Parameters:

	M	The input matrix in column major format.
	O	The input matrix in column major format.

void OpenTissue::gl::Screen2Object	(	int	sx,
		int	sy,
		double &	ox,
		double &	oy,
		double &	oz
	)			`[inline]`

Screen to Object conversion. Given a point on the screen, get the corresponding 3D point in the world

Parameters:

	sx	Screen x-coordinate.
	sy	Screen y-coordinate.
	ox	Object world x-coordinate.
	oy	Object world y-coordinate.
	oz	Object world z-coordinate.

template<typename value_type >

void OpenTissue::gl::Transform ( math::Vector3< value_type > const & r ) [inline]

template<typename value_type >

void OpenTissue::gl::Transform ( math::Quaternion< value_type > const & Q ) [inline]

Apply Rigid Body Transformation to current Matrix Track.

Parameters:

Q

Rotation.

template<typename vector3_type , typename quaternion_type >

void OpenTissue::gl::Transform	(	vector3_type const &	r,
		quaternion_type const &	Q
	)			`[inline]`

Apply Rigid Body Transformation to current Matrix Track.

That is rotate before translate!

Parameters:

	r	Translation.
	Q	Rotation.

template<typename V >

void OpenTissue::gl::Transform ( math::CoordSys< V > const & C ) [inline]

Apply Coordsys Transformation to current Matrix Track.

That is rotate before translate!

Parameters:

C

Coordinate System Transform.

template<typename real_type >

void OpenTissue::gl::transpose	(	real_type const *	M,
		real_type *	T
	)			`[inline]`

Transpose a 4x4 matrix

Parameters:

	M	the matrix to be transposed
	T	The resulting transposed matrix.

template<typename real_type >

void OpenTissue::gl::transpose ( real_type * M ) [inline]

Transpose a 4x4 matrix

Parameters:

M

The matrix to be transposed

template<typename real_type , typename vector3_type >

vector3_type OpenTissue::gl::xform	(	real_type *	M,
		vector3_type const &	v
	)			`[inline]`

OpenGL Matrix-Vector Transformation.

Parameters:

	M	OpenGL matrix type in column major format.
	v	A 3 dimensional vector type.

Returns:: The homegenoized result of M*[v^T,1]^T

OpenTissue::gl Namespace Reference

Classes

Typedefs

Functions

Typedef Documentation

Function Documentation