jem::gl Namespace Reference

This namespace contains classes and functions for building OpenGL-based graphics applications. More...

Classes
class	ActionParams
class	Actions
class	Attributes
class	Box
class	Buttons
class	CallbackQueue
class	Camera
class	Camera2D
class	Camera3D
class	Click2Event
class	Color
class	ColoredMarker
class	ColorMap
class	ColorMapScope
class	CommandEvent
class	Commands
class	Compound
class	Controller
class	CustomPalette
class	Display
class	DisplayException
class	DummyAttribs
class	DummyNode
class	ErrorHandler
class	EventHandler
class	EventHandler2D
class	EventHandler3D
class	EventNode
class	EventQueue
class	Font
class	FontScope
class	FrameGrabber
class	GeomNode
class	GfxContext
class	GfxError
class	GfxEvent
class	GfxNode
class	GLActionParams
class	GLActions
class	GLException
class	GLSetup
class	GLSetup2D
class	GLSetup3D
class	GraphViewer
class	GroupNode
class	InitEvent
class	KeyEvent
class	KeyPress
class	Keys
class	LeafNode
class	Lights
class	LinearPalette
class	LineSet
class	MarkerSet
class	MarkerStyle
class	Menu
class	MenuNode
class	MessageBox
class	MotionEvent
class	MouseClick
class	MouseDrag
class	MouseEvent
class	MultiNode
class	NRActionParams
class	NRActions
class	NumberMarker
class	Orb
class	OrbMarker
class	OrthoCamera
class	OrthoCamera3D
class	OrthoTextScope
class	OSContext
class	Palette
class	PalettePainter
class	Pivotable
class	PNGGrabber
class	PointMarker
class	PointSampler
class	Popup
class	PPMGrabber
class	PrintErrHandler
class	PropertyNames
class	RainbowPalette
class	Rect
class	RedrawEvent
class	RedrawRoot
class	ResizeEvent
class	RubberBand
class	Size2
class	StdAttribs
class	StdCamera
class	StdEventHandler
class	StdGLSetup
class	SymbolMarker
class	Symbols
class	TeeMarker
class	TextBalloon
class	TextPainter
class	TextProjector
class	TextScope
class	TextureException
class	TextureManager
class	Transform
class	Transformable
class	Transformer
class	TriangleSet
class	Vertex
class	VertexSet
class	Viewer
class	Viewport
class	Window
class	WrapperNode
class	XYPlot

Typedefs
typedef Array< idx_t >	IdxVector
typedef Array< idx_t, 2 >	IdxMatrix
typedef Array< GLbyte >	GLbyteVector
typedef Array< GLbyte, 2 >	GLbyteMatrix
typedef Array< GLubyte >	GLubyteVector
typedef Array< GLubyte, 2 >	GLubyteMatrix
typedef Array< GLfloat >	GLfloatVector
typedef Array< GLfloat, 2 >	GLfloatMatrix
typedef Array< GLdouble >	GLdoubleVector
typedef Array< GLdouble, 2 >	GLdoubleMatrix
typedef AutoPointer< GfxEvent >	EventPtr
typedef AutoPointer< RedrawEvent >	RedrawEventPtr
typedef PropertyNames	PropNames
typedef Size2< GLsizei >	Size2i
typedef Size2< GLfloat >	Size2f
typedef Size2< GLdouble >	Size2d
typedef Tuple< GLint, 2 >	Vertex2i
typedef Tuple< GLfloat, 2 >	Vertex2f
typedef Tuple< GLdouble, 2 >	Vertex2d
typedef Tuple< GLint, 3 >	Vertex3i
typedef Tuple< GLfloat, 3 >	Vertex3f
typedef Tuple< GLdouble, 3 >	Vertex3d
typedef Tuple< GLint, 4 >	Vertex4i
typedef Tuple< GLfloat, 4 >	Vertex4f
typedef Tuple< GLdouble, 4 >	Vertex4d

Enumerations
enum	Alignment {   LEFT_ALIGNED = 0,   BOT_ALIGNED = LEFT_ALIGNED,   CENTERED = 1,   RIGHT_ALIGNED = 2,   TOP_ALIGNED = RIGHT_ALIGNED }
enum	FontSize {   SMALL_FONT,   MEDIUM_FONT,   LARGE_FONT }
enum	FontType {   MONOSPACE_FONT,   PROPORTIONAL_FONT,   SYMBOL_FONT }
enum	FontID {   MONOSPACE_SMALL_FONT,   MONOSPACE_MEDIUM_FONT,   MONOSPACE_LARGE_FONT,   PROPORTIONAL_SMALL_FONT,   PROPORTIONAL_MEDIUM_FONT,   PROPORTIONAL_LARGE_FONT,   SYMBOL_SMALL_FONT,   SYMBOL_MEDIUM_FONT,   SYMBOL_LARGE_FONT }

Functions
void	setCurrent (const Attributes &attribs)
void	setCurrent (const Attributes &attribs, int fields)
void	getCurrent (Attributes &attribs)
void	getCurrent (Attributes &attribs, int fields)
void	getAttribsOf (GfxNode *node, const Properties &attribs)
void	swap (Box &lhs, Box &rhs)
bool	isVisible (const Box &box, const Transform &proj)
double	distance (const Box &first, const Box &second)
bool	overlap (const Box &first, const Box &second)
GLbyte	toByte (float fval)
GLbyte	toByte (double dval)
GLubyte	toUbyte (float fval)
GLubyte	toUbyte (double dval)
float	toFloat (GLbyte bval)
float	toFloat (GLubyte bval)
double	toDouble (GLbyte bval)
double	toDouble (GLubyte bval)
void	convert (GLbyte &lhs, float rhs)
void	convert (GLbyte &lhs, double rhs)
void	convert (GLubyte &lhs, float rhs)
void	convert (GLubyte &lhs, double rhs)
void	convert (float &lhs, GLbyte rhs)
void	convert (float &lhs, GLubyte rhs)
void	convert (double &lhs, GLbyte rhs)
void	convert (double &lhs, GLubyte rhs)
void	read (io::TextInput &in, Color &c)
template<class Output >
void	print (Output &out, const Color &c)
bool	clamp (Color &c)
Color	clamped (const Color &c)
void	setCurrent (const Color &c)
void	getCurrent (Color &c)
bool	isOpaque (GLfloat alpha)
bool	isCompound (const Ref< GfxNode > &node)
Compound *	toCompound (const Ref< GfxNode > &node)
Compound &	toCompound (GfxNode &node)
void	addChild (GfxNode &parent, const Ref< GfxNode > &child)
void	eraseChild (GfxNode &parent, const Ref< GfxNode > &child)
bool	addToScene (const Ref< GfxNode > &scene, const Ref< GfxNode > &node)
void	eraseFromParent (const Ref< GfxNode > &node)
Ref< Controller >	newController2D (const Ref< Camera > &camera, const Ref< MultiNode > &world)
Ref< Controller >	newController3D (const Ref< Camera > &camera, const Ref< MultiNode > &world)
void	indexError (const String &where, const String &name, idx_t index, idx_t ubound=-1)
void	sizeError (const String &where, const String &name, idx_t size)
void	shapeError (const String &where, const String &name, const Tuple< idx_t, 2 > &sh)
void	zeroVectorError (const String &where, const String &name)
void	swap (Font &lhs, Font &rhs)
void	print (TextOutput &out, const Font &font)
bool	passAction (Ref< GfxNode > child, const String &action, const Properties &params)
bool	passGLAction (Ref< GfxNode > child, GfxContext &gtx, int action, const Properties &params)
void	configChild (Ref< GfxNode > child, const Properties &props)
Ref< MessageBox >	showMessage (Viewer &viewer, const Ref< GfxNode > &node, const String &text, Alignment hAlign=CENTERED, Alignment vAlign=CENTERED)
Ref< MessageBox >	showMessage (GfxContext &gtx, const Ref< GfxNode > &node, const String &text, Alignment hAlign=CENTERED, Alignment vAlign=CENTERED)
Ref< MessageBox >	showMessageUntil (GfxContext &gtx, const Ref< GfxNode > &node, const String &text, const Time &deadline, Alignment hAlign=CENTERED, Alignment vAlign=CENTERED)
void	explode (MultiNode &multi, double scale=0.1)
double	mapColorToValue (double &val, double prec, const Color &color, const Color &minColor, const Color &maxColor)
void	makeLinearColorMap (ColorMap &colorMap, idx_t colorCount, const Palette &palette)
void	swap (Rect &lhs, Rect &rhs)
void	print (TextOutput &out, const Rect &rect)
void	getViewport (Rect &vport)
Rect	getViewport ()
void	loadOrtho (const Rect &vport, GLdouble clip0, GLdouble clip1)
bool	isRedrawRoot (const Ref< GfxNode > &node)
GfxNode *	findRedrawRoot (const Ref< GfxNode > &node)
template<class T >
void	swap (Size2< T > &lhs, Size2< T > &rhs)
template<class T >
Size2< T >	makeSize (T width, T height)
template<class Output , class T >
void	print (Output &out, const Size2< T > &size)
Ref< TextBalloon >	showBalloon (GfxContext &gtx, const Ref< GfxNode > &node, const String &text)
Ref< TextBalloon >	showBalloon (GfxContext &gtx, const Ref< GfxNode > &node, const String &text, int xPos, int yPos)
void	swap (Transform &lhs, Transform &rhs)
void	print (TextOutput &out, const Transform &tr)
void	getCurrent (Transform &tr)
void	setCurrent (const Transform &tr)
void	multCurrent (const Transform &tr)
Vertex2d	matmul (const Transform &a, const Vertex2d &b)
Vertex3d	matmul (const Transform &a, const Vertex3d &b)
Vertex4d	matmul (const Transform &a, const Vertex4d &b)
Transform	matmul (const Transform &a, const Transform &b)
void	matmul (Vertex2d &r, const Transform &a, const Vertex2d &b)
void	matmul (Vertex3d &r, const Transform &a, const Vertex3d &b)
void	matmul (Vertex4d &r, const Transform &a, const Vertex4d &b)
void	matmul (Transform &r, const Transform &a, const Transform &b)
Vertex3d	project (const Transform &p, const Vertex3d &v)
bool	project (Vertex3d &d, const Transform &p, const Vertex3d &v)
bool	project (Vertex2d &d, const Transform &p, const Vertex3d &v)
Vertex3d	unproject (const Transform &p, const Vertex3d &d)
bool	unproject (Vertex3d &v, const Transform &p, const Vertex3d &d)
void	getProjection (Transform &p)
void	toWindow (Vertex3d &v, const Rect &vport)
void	fromWindow (Vertex2d &v, const Rect &vport)
void	fromWindow (Vertex3d &v, const Rect &vport)
Transform	inverse (const Transform &tr)
bool	invert (Transform &tr)
GLdouble	reldiff (const Transform &a, const Transform &b)
bool	isTransformable (const Ref< GfxNode > &node)
Transformable *	toTransformable (const Ref< GfxNode > &node)
Transformable &	toTransformable (GfxNode &node)
Transform	getTransformOf (const Ref< GfxNode > &node)
Transform	getProjectionOf (const Ref< GfxNode > &node)
bool	fromWindowToNode (Vertex3d &v, const GfxNode &node)
GLdouble	getAngle (const Vertex2d &e1, const Vertex2d &e2)
template<class T , int N>
T	normalize (Tuple< T, N > &vx)
template<class T >
T	getNormal (Tuple< T, 3 > &n, const Tuple< T, 3 > &a, const Tuple< T, 3 > &b)
template<class T >
T	normalize (Tuple< T, 2 > &vx)
template<class T >
T	normalize (Tuple< T, 3 > &vx)

Detailed Description

The namespace jem::gl contains classes and functions that provide support for building OpenGL-based graphics applications.

All classes and functions in this namespace can be found in the package jem.gl.

Typedef Documentation

typedef Array<idx_t> jem::gl::IdxVector

typedef Array<idx_t,2> jem::gl::IdxMatrix

typedef Array<GLbyte> jem::gl::GLbyteVector

typedef Array<GLbyte,2> jem::gl::GLbyteMatrix

typedef Array<GLubyte> jem::gl::GLubyteVector

typedef Array<GLubyte,2> jem::gl::GLubyteMatrix

typedef Array<GLfloat> jem::gl::GLfloatVector

typedef Array<GLfloat,2> jem::gl::GLfloatMatrix

typedef Array<GLdouble> jem::gl::GLdoubleVector

typedef Array<GLdouble,2> jem::gl::GLdoubleMatrix

typedef AutoPointer<GfxEvent> jem::gl::EventPtr

typedef AutoPointer<RedrawEvent> jem::gl::RedrawEventPtr

typedef PropertyNames jem::gl::PropNames

typedef Size2<GLsizei> jem::gl::Size2i

typedef Size2<GLfloat> jem::gl::Size2f

typedef Size2<GLdouble> jem::gl::Size2d

typedef Tuple<GLint,2> jem::gl::Vertex2i

typedef Tuple<GLfloat,2> jem::gl::Vertex2f

typedef Tuple<GLdouble,2> jem::gl::Vertex2d

typedef Tuple<GLint,3> jem::gl::Vertex3i

typedef Tuple<GLfloat,3> jem::gl::Vertex3f

typedef Tuple<GLdouble,3> jem::gl::Vertex3d

typedef Tuple<GLint,4> jem::gl::Vertex4i

typedef Tuple<GLfloat,4> jem::gl::Vertex4f

typedef Tuple<GLdouble,4> jem::gl::Vertex4d

Enumeration Type Documentation

enum jem::gl::Alignment

Enumerator
LEFT_ALIGNED
BOT_ALIGNED
CENTERED
RIGHT_ALIGNED
TOP_ALIGNED

enum jem::gl::FontSize

Enumerator
SMALL_FONT
MEDIUM_FONT
LARGE_FONT

enum jem::gl::FontType

Enumerator
MONOSPACE_FONT
PROPORTIONAL_FONT
SYMBOL_FONT

enum jem::gl::FontID

Enumerator
MONOSPACE_SMALL_FONT
MONOSPACE_MEDIUM_FONT
MONOSPACE_LARGE_FONT
PROPORTIONAL_SMALL_FONT
PROPORTIONAL_MEDIUM_FONT
PROPORTIONAL_LARGE_FONT
SYMBOL_SMALL_FONT
SYMBOL_MEDIUM_FONT
SYMBOL_LARGE_FONT

Function Documentation

void jem::gl::setCurrent

(

const Attributes &

attribs

)

void jem::gl::setCurrent	(	const Attributes &	attribs,
		int	fields
	)

void jem::gl::getCurrent

(

Attributes &

attribs

)

void jem::gl::getCurrent	(	Attributes &	attribs,
		int	fields
	)

void jem::gl::getAttribsOf	(	GfxNode *	node,
		const Properties &	attribs
	)

void jem::gl::swap	(	Box &	lhs,
		Box &	rhs
	)

bool jem::gl::isVisible	(	const Box &	box,
		const Transform &	proj
	)

double jem::gl::distance	(	const Box &	first,
		const Box &	second
	)

bool jem::gl::overlap	(	const Box &	first,
		const Box &	second
	)

GLbyte jem::gl::toByte

(

float

fval

)

GLbyte jem::gl::toByte

(

double

dval

)

GLubyte jem::gl::toUbyte

(

float

fval

)

GLubyte jem::gl::toUbyte

(

double

dval

)

float jem::gl::toFloat

(

GLbyte

bval

)

float jem::gl::toFloat

(

GLubyte

bval

)

double jem::gl::toDouble

(

GLbyte

bval

)

double jem::gl::toDouble

(

GLubyte

bval

)

void jem::gl::convert	(	GLbyte &	lhs,
		float	rhs
	)

void jem::gl::convert	(	GLbyte &	lhs,
		double	rhs
	)

void jem::gl::convert	(	GLubyte &	lhs,
		float	rhs
	)

void jem::gl::convert	(	GLubyte &	lhs,
		double	rhs
	)

void jem::gl::convert	(	float &	lhs,
		GLbyte	rhs
	)

void jem::gl::convert	(	float &	lhs,
		GLubyte	rhs
	)

void jem::gl::convert	(	double &	lhs,
		GLbyte	rhs
	)

void jem::gl::convert	(	double &	lhs,
		GLubyte	rhs
	)

void jem::gl::read	(	io::TextInput &	in,
		Color &	c
	)

template<class Output >

void jem::gl::print	(	Output &	out,
		const Color &	c
	)

bool jem::gl::clamp

(

Color &

c

)

Color jem::gl::clamped

(

const Color &

c

)

void jem::gl::setCurrent

(

const Color &

c

)

void jem::gl::getCurrent

(

Color &

c

)

bool jem::gl::isOpaque

(

GLfloat

alpha

)

bool jem::gl::isCompound

(

const Ref< GfxNode > &

node

)

Compound * jem::gl::toCompound

(

const Ref< GfxNode > &

node

)

Compound& jem::gl::toCompound

(

GfxNode &

node

)

void jem::gl::addChild	(	GfxNode &	parent,
		const Ref< GfxNode > &	child
	)

void jem::gl::eraseChild	(	GfxNode &	parent,
		const Ref< GfxNode > &	child
	)

bool jem::gl::addToScene	(	const Ref< GfxNode > &	scene,
		const Ref< GfxNode > &	node
	)

void jem::gl::eraseFromParent

(

const Ref< GfxNode > &

node

)

Ref<Controller> jem::gl::newController2D	(	const Ref< Camera > &	camera,
		const Ref< MultiNode > &	world
	)

Ref<Controller> jem::gl::newController3D	(	const Ref< Camera > &	camera,
		const Ref< MultiNode > &	world
	)

void jem::gl::indexError	(	const String &	where,
		const String &	name,
		idx_t	index,
		idx_t	ubound = -1
	)

void jem::gl::sizeError	(	const String &	where,
		const String &	name,
		idx_t	size
	)

void jem::gl::shapeError	(	const String &	where,
		const String &	name,
		const Tuple< idx_t, 2 > &	sh
	)

void jem::gl::zeroVectorError	(	const String &	where,
		const String &	name
	)

void jem::gl::swap	(	Font &	lhs,
		Font &	rhs
	)

void jem::gl::print	(	TextOutput &	out,
		const Font &	font
	)

bool jem::gl::passAction	(	Ref< GfxNode >	child,
		const String &	action,
		const Properties &	params
	)

bool jem::gl::passGLAction	(	Ref< GfxNode >	child,
		GfxContext &	gtx,
		int	action,
		const Properties &	params
	)

void jem::gl::configChild	(	Ref< GfxNode >	child,
		const Properties &	props
	)

Ref<MessageBox> jem::gl::showMessage	(	Viewer &	viewer,
		const Ref< GfxNode > &	node,
		const String &	text,
		Alignment	hAlign = CENTERED,
		Alignment	vAlign = CENTERED
	)

Ref<MessageBox> jem::gl::showMessage	(	GfxContext &	gtx,
		const Ref< GfxNode > &	node,
		const String &	text,
		Alignment	hAlign = CENTERED,
		Alignment	vAlign = CENTERED
	)

Ref<MessageBox> jem::gl::showMessageUntil	(	GfxContext &	gtx,
		const Ref< GfxNode > &	node,
		const String &	text,
		const Time &	deadline,
		Alignment	hAlign = CENTERED,
		Alignment	vAlign = CENTERED
	)

void jem::gl::explode	(	MultiNode &	multi,
		double	scale = 0.1
	)

double jem::gl::mapColorToValue	(	double &	val,
		double	prec,
		const Color &	color,
		const Color &	minColor,
		const Color &	maxColor
	)

void jem::gl::makeLinearColorMap	(	ColorMap &	colorMap,
		idx_t	colorCount,
		const Palette &	palette
	)

void jem::gl::swap	(	Rect &	lhs,
		Rect &	rhs
	)

void jem::gl::print	(	TextOutput &	out,
		const Rect &	rect
	)

void jem::gl::getViewport

(

Rect &

vport

)

Rect jem::gl::getViewport

(

)

void jem::gl::loadOrtho	(	const Rect &	vport,
		GLdouble	clip0,
		GLdouble	clip1
	)

bool jem::gl::isRedrawRoot

(

const Ref< GfxNode > &

node

)

GfxNode* jem::gl::findRedrawRoot

(

const Ref< GfxNode > &

node

)

template<class T >

void jem::gl::swap	(	Size2< T > &	lhs,
		Size2< T > &	rhs
	)

template<class T >

Size2< T > jem::gl::makeSize	(	T	width,
		T	height
	)

template<class Output , class T >

void jem::gl::print	(	Output &	out,
		const Size2< T > &	size
	)

Ref<TextBalloon> jem::gl::showBalloon	(	GfxContext &	gtx,
		const Ref< GfxNode > &	node,
		const String &	text
	)

Ref<TextBalloon> jem::gl::showBalloon	(	GfxContext &	gtx,
		const Ref< GfxNode > &	node,
		const String &	text,
		int	xPos,
		int	yPos
	)

void jem::gl::swap	(	Transform &	lhs,
		Transform &	rhs
	)

void jem::gl::print	(	TextOutput &	out,
		const Transform &	tr
	)

void jem::gl::getCurrent

(

Transform &

tr

)

void jem::gl::setCurrent

(

const Transform &

tr

)

void jem::gl::multCurrent

(

const Transform &

tr

)

Vertex2d jem::gl::matmul	(	const Transform &	a,
		const Vertex2d &	b
	)

Vertex3d jem::gl::matmul	(	const Transform &	a,
		const Vertex3d &	b
	)

Vertex4d jem::gl::matmul	(	const Transform &	a,
		const Vertex4d &	b
	)

Transform jem::gl::matmul	(	const Transform &	a,
		const Transform &	b
	)

void jem::gl::matmul	(	Vertex2d &	r,
		const Transform &	a,
		const Vertex2d &	b
	)

void jem::gl::matmul	(	Vertex3d &	r,
		const Transform &	a,
		const Vertex3d &	b
	)

void jem::gl::matmul	(	Vertex4d &	r,
		const Transform &	a,
		const Vertex4d &	b
	)

void jem::gl::matmul	(	Transform &	r,
		const Transform &	a,
		const Transform &	b
	)

Vertex3d jem::gl::project	(	const Transform &	p,
		const Vertex3d &	v
	)

bool jem::gl::project	(	Vertex3d &	d,
		const Transform &	p,
		const Vertex3d &	v
	)

bool jem::gl::project	(	Vertex2d &	d,
		const Transform &	p,
		const Vertex3d &	v
	)

Vertex3d jem::gl::unproject	(	const Transform &	p,
		const Vertex3d &	d
	)

bool jem::gl::unproject	(	Vertex3d &	v,
		const Transform &	p,
		const Vertex3d &	d
	)

void jem::gl::getProjection

(

Transform &

p

)

void jem::gl::toWindow	(	Vertex3d &	v,
		const Rect &	vport
	)

void jem::gl::fromWindow	(	Vertex2d &	v,
		const Rect &	vport
	)

void jem::gl::fromWindow	(	Vertex3d &	v,
		const Rect &	vport
	)

Transform jem::gl::inverse

(

const Transform &

tr

)

bool jem::gl::invert

(

Transform &

tr

)

GLdouble jem::gl::reldiff	(	const Transform &	a,
		const Transform &	b
	)

bool jem::gl::isTransformable

(

const Ref< GfxNode > &

node

)

Transformable * jem::gl::toTransformable

(

const Ref< GfxNode > &

node

)

Transformable& jem::gl::toTransformable

(

GfxNode &

node

)

Transform jem::gl::getTransformOf

(

const Ref< GfxNode > &

node

)

Transform jem::gl::getProjectionOf

(

const Ref< GfxNode > &

node

)

bool jem::gl::fromWindowToNode	(	Vertex3d &	v,
		const GfxNode &	node
	)

GLdouble jem::gl::getAngle	(	const Vertex2d &	e1,
		const Vertex2d &	e2
	)

template<class T , int N>

T jem::gl::normalize

(

Tuple< T, N > &

vx

)

template<class T >

T jem::gl::getNormal	(	Tuple< T, 3 > &	n,
		const Tuple< T, 3 > &	a,
		const Tuple< T, 3 > &	b
	)

template<class T >

T jem::gl::normalize

(

Tuple< T, 2 > &

vx

)

template<class T >

T jem::gl::normalize

(

Tuple< T, 3 > &

vx

)