#include <glvertex_nodes.h>

Inheritance diagram for lgl_VBONode:

[legend]

Public Types
enum	lgl_control_mode_enum
	control mode enum

enum	lgl_export_enum
	scene graph export modes

Public Member Functions
virtual std::string	getClassId () const
	get the class id

virtual bool	stateless () const
	is the node stateless?

virtual void	control (bool override=true)
	control the node as specified by the control mode

lgl_control_mode_enum	getControlMode () const
	get the control mode

void	setControlMode (lgl_control_mode_enum mode)
	set the control mode

std::string	getId () const
	get the node identifier

void	setId (const std::string &id="")
	set the node identifier

std::string	getAltId () const
	get the alternate node identifier

void	setAltId (const std::string &id="")
	set the alternate node identifier

unsigned int	children () const
	get the number of children of the node

bool	leaf () const
	is the node a leaf?

unsigned int	references () const
	get the number of references to the node

bool	shared () const
	is the node shared?

lgl_Node *	get (unsigned int i=0) const
	get a child node

template<class T >
T *	add (T *node)
	add a child node with a specific type

void	remove (unsigned int i=0)
	remove a child from the node

void	replace (lgl_Node *node, unsigned int i=0)
	replace a child of the node

lgl_Node *	take (unsigned int i=0)
	unlink a child and take ownership

void	link (lgl_Node *node)
	add the links of a node

void	unlink ()
	remove the links of the node

virtual bool	checkForCycles ()
	check for graph cycles

bool	enabled () const
	is the node enabled?

bool	disabled () const
	is the node disabled?

void	enable (bool yes=true)
	enable the node

void	disable (bool yes=true)
	disable the node

void	toggle ()
	toggle the node

bool	shown () const
	is the node shown?

bool	hidden () const
	is the node hidden?

void	show (bool yes=true)
	show the node and its children

void	hide (bool yes=true)
	hide the node and its children

virtual lgl_Node *	find (const std::string &id)
	find a node with a specific identifier

template<class T >
T *	find ()
	find a node with a specific type

template<class T >
T *	find (const std::string &id)
	find a node with a specific identifier and type

void	renderSceneGraph (double dt=0)
	render and update the entire scene subgraph

void	drawSceneGraph (vec4 color=vec4(1))
	draw the entire scene subgraph without updating

void	drawSceneGraph (const mat4 &m)
	draw the entire scene subgraph without updating

void	preupdateSceneGraph (double dt)
	pre-update the entire scene subgraph

void	updateSceneGraph (double dt)
	update the entire scene subgraph

virtual void	getBoundingBox (vec3 &bboxmin, vec3 &bboxmax)
	get the bounding box of the entire subgraph More...

double	getBoundingSphere (vec3 &center)
	get the bounding sphere of the entire subgraph More...

vec3	getCenter ()
	get the bounding box center of the entire subgraph

vec3	getExtent ()
	get the bounding box extent of the entire subgraph

double	getRadius ()
	get the bounding sphere radius of the entire subgraph More...

double	getNorm ()
	get the bounding sphere norm of the entire subgraph More...

virtual std::vector< vec4 >	getVertexCoordinates (mat4 trans=mat4())

void	getExactBoundingBox (vec3 &bboxmin, vec3 &bboxmax)
	get the exact bounding box of the entire subgraph More...

lglVBO *	pickSceneGraph (vec3 origin, vec3 direction, double mindist=0)
	pick the entire scene subgraph

bool	hasTransparency ()
	check the entire subgraph whether or not it contains semi-transparent geometry

virtual unsigned int	countAll ()
	count all nodes (count multiply linked nodes)

virtual unsigned int	countAllOnce ()
	count all nodes (count multiply linked nodes once)

virtual unsigned int	countAllPrimitives ()
	count all primitives

unsigned int	countAllVertices ()
	count all vertices

virtual bool	ordered () const
	is the node ordered?

bool	convertable () const
	is the node convertable?

bool	cloneable () const
	is the node cloneable?

bool	optimizable () const
	is the node optimizable?

virtual void	optimizeAll ()
	optimize all nodes

virtual void	restartAll (double animation=0)
	restart all animations

virtual void	pauseAll (bool yes=true)
	pause all animations

virtual void	speedupAll (double speedup=1)
	speedup all animations

virtual void	finishAll ()
	finish all transitions

std::string	exportAll (lgl_export_enum mode=LGL_EXPORT_NODES, int indentation=0, int increment=3)
	export all nodes

void	exportNodes (std::string filename)
	export graph nodes

void	exportGraph (std::string filename)
	export link graph

void	exportCommands (std::string filename)
	export graphics commands

bool	saveObj (std::string filename)
	save into OBJ file

std::string	getName () const
	get the vbo name

void	setName (std::string name="")
	set the vbo name

void	lglVertex (double x, double y, double z, double w=1)
	specify a vertex in immediate mode fashion (and compile it into vbo)

void	reset ()
	reset all buffers

void	clear ()
	clear all buffers

void	lglColor (float r, float g, float b, float a=1)
	specify the color attribute for the next vertex

vec4	lglGetColor () const
	get the actual color attribute

void	lglNormal (float x, float y, float z)
	specify the normal attribute for the next vertex

void	lglTexCoord (float s, float t=0, float r=0, float w=1)
	specify the texture coordinate attribute for the next vertex

void	lglAttribute (float x, float y, float z, float w=1.0f, unsigned int n=0)
	specify a custom vertex attribute

void	lglBegin (lgl_primitive_enum primitive)
	begin a series of vertices for a particular graphics primitive

void	lglEnd ()
	end a series of vertices

void	lglVertexArray (lgl_primitive_enum primitive, unsigned int vertices, const float vertex_array, const float color_array, const float normal_array=NULL, const float texcoord_array=NULL)
	specify a series of vertices and attributes as buffers (and copy them into vbo)

void	lglInterleavedVertexArray (lgl_primitive_enum primitive, const float *interleaved_array, unsigned int vertices, int colors=0, int normals=0, int texcoords=0)
	specify a series of vertices as interleaved buffer (and copy it into vbo)

void	lglClearColors ()
	clear colors

void	lglClearNormals ()
	clear normals

void	lglClearTexCoords ()
	clear texture coordinates

void	lglClearAttributes ()
	clear attributes

virtual void	lglRender (const lgl *vbo=NULL)
	render the series of vertices contained in vbo

lgl_primitive_enum	lglGetVertexMode () const
	get the primitive mode of vertices contained in vbo

int	lglGetVertexCount () const
	get the number of vertices contained in vbo

int	lglGetPrimitiveCount () const
	get the number of primitives contained in vbo

void	lglGetBoundingBox (vec3 &bboxmin, vec3 &bboxmax) const
	get the bounding box of the contained vertices in vbo More...

double	lglGetBoundingSphere (vec3 &center) const
	get the bounding sphere of the contained vertices in vbo More...

vec3	lglGetCenter () const
	get the bounding box barycenter of the contained vertices in vbo

vec3	lglGetExtent () const
	get the bounding box extent of the contained vertices in vbo

double	lglGetRadius () const
	get the bounding sphere radius of the contained vertices in vbo More...

double	lglGetNorm () const
	get the bounding sphere norm of the contained vertices in vbo More...

double	lglGetMaxExtent () const
	get the maximum extent of the contained vertices in vbo More...

double	lglGetMaxAbsCoord () const
	get the maximum absolute value of the coordinates in vbo More...

std::vector< vec4 >	lglGetVertexCoordinates () const
	return a copy of the vertex coordinates in vbo

std::vector< vec4f >	lglGetColorAttributes () const
	return a copy of the color attributes in vbo

std::vector< vec3f >	lglGetNormalAttributes () const
	return a copy of the normal attributes in vbo

std::vector< vec4f >	lglGetTexCoordAttributes () const
	return a copy of the texture coordinate attributes in vbo

void	lglAppendVerticesTo (lgl *vbo) const
	append a copy of the vertices and attributes in vbo to another vbo

void	lglMatrixMode (lgl_matrixmode_enum mode=LGL_MODELVIEW)
	determine the actual matrix mode

lgl_matrixmode_enum	lglGetMatrixMode () const
	get the actual matrix mode

void	lglLoadIdentity ()
	load the identity matrix in immediate mode fashion

void	lglLoadMatrix (const mat4 &matrix)
	load a specific matrix in immediate mode fashion

void	lglMultMatrix (const mat4 &matrix)
	multiply a specific matrix in immediate mode fashion

void	lglPushMatrix ()
	push the top entry of the matrix stack

void	lglPopMatrix ()
	pop the top entry of the matrix stack

mat4	lglGetMatrix () const
	get the top entry of the matrix stack

mat4	lglGetProjectionMatrix () const
	get the actual projection matrix

mat4	lglGetModelViewMatrix () const
	get the actual modelview matrix

mat4	lglGetInverseModelViewMatrix () const
	get the inverse of the actual modelview matrix

mat4	lglGetInverseTransposeModelViewMatrix () const
	get the inverse transpose of the actual modelview matrix

mat4	lglGetModelViewProjectionMatrix () const
	get the combined modelview and projection matrix

mat4	lglGetTextureMatrix () const
	get the actual texture matrix

void	lglScale (const vec4 &c)
	scale in immediate mode fashion

void	lglScale (double s, double t, double r, double w=1)
	scale in immediate mode fashion

void	lglScale (double s, double w=1)
	scale in immediate mode fashion

void	lglTranslate (const vec4 &v)
	translate in immediate mode fashion

void	lglTranslate (double x, double y, double z, double w=1)
	translate in immediate mode fashion

void	lglRotate (double angle, const vec3 &v)
	rotate in immediate mode fashion

void	lglRotate (double angle, double vx, double vy, double vz)
	rotate in immediate mode fashion

void	lglRotateX (double angle)
	rotate about x-axis in immediate mode fashion

void	lglRotateY (double angle)
	rotate about y-axis in immediate mode fashion

void	lglRotateZ (double angle)
	rotate about z-axis in immediate mode fashion

void	lglOrtho (double left, double right, double bottom, double top, double nearp=-1, double farp=1)
	orthographic projection

void	lglFrustum (double left, double right, double bottom, double top, double nearp, double farp)
	frustum projection

void	lglParallel (const vec3 &p, const vec3 &n, const vec3 &d)
	parallel projection

void	lglPerspective (double fovy, double aspect, double nearp, double farp)
	perspective projection

double	getFovy ()
	get fovy parameter for last projection transformation

double	getAspect ()
	get aspect parameter for last projection transformation

double	getNear ()
	get near parameter for last projection transformation

double	getFar ()
	get far parameter for last projection transformation

void	lglLookAt (const vec3 &eye, const vec3 &at, const vec3 &up=vec3(0, 1, 0))
	lookat transformation

void	lglLookAt (double eye_x, double eye_y, double eye_z, double at_x, double at_y, double at_z, double up_x=0, double up_y=1, double up_z=0)
	lookat transformation

vec3	getEye () const
	get eye point for last lookat transformation

vec3	getLookAt () const
	get lookat point for last lookat transformation

vec3	getUp () const
	get up vector for last lookat transformation

void	lglProjection ()
	reset the actual projection matrix

void	lglProjection (const mat4 &projection)
	set the actual projection matrix

void	lglProjection (double left, double right, double bottom, double top, double nearp, double farp)
	set the actual projection matrix

void	lglProjection (double fovy, double aspect, double nearp, double farp)
	set the actual projection matrix

void	lglModelView ()
	reset the actual modelview matrix

void	lglModelView (const mat4 &modelview)
	set the actual modelview matrix

void	lglView (const vec3 &eye, const vec3 &at, const vec3 &up=vec3(0, 1, 0))
	set the actual modelview matrix

void	lglView (double eye_x, double eye_y, double eye_z, double at_x, double at_y, double at_z, double up_x=0, double up_y=1, double up_z=0)
	set the actual modelview matrix

void	lglTexture ()
	reset the actual texture matrix

void	lglTexture (const mat4 &texture)
	set the actual texture matrix

void	lglModel ()
	reset the vbo modeling matrix

void	lglModel (const mat4 &model)
	specify the vbo modeling matrix

mat4	lglGetModelMatrix () const
	get the vbo modeling matrix

mat4	lglGetInverseTransposeModelMatrix () const
	get the inverse transpose of the vbo modeling matrix

void	lglApplyModelMatrix ()
	apply the vbo modeling matrix to the vbo and reset the matrix

void	lglTex ()
	reset the vbo texturing matrix

void	lglTex (const mat4 &tex)
	specify the vbo texturing matrix

void	lglTex (const vec4 &scale, const vec4 &offset)
	specify the vbo texturing matrix

mat4	lglGetTexMatrix () const
	get the vbo texturing matrix

void	lglApplyTexMatrix ()
	apply the vbo texturing matrix to the vbo and reset the matrix

void	lglApplyColor (const vec4f &c)
	add a color channel to the vbo More...

void	lglUseProgram (GLuint program, bool clear=true)
	use a custom GLSL program More...

void	lglUseDefaultProgram (bool clear=true)
	use the default GLSL program which simulates the fixed function OpenGL pipeline More...

void	lglReplaceDefaultProgram (GLuint program, bool colors=false, bool normals=true, bool texcoords=false, bool tex3D=false)
	replace default GLSL program

GLuint	lglGetProgram () const
	get the actual custom GLSL program in use

void	lglReuseProgram (GLuint program)
	reuse a compiled GLSL program /wo clearing and updating uniforms

bool	lglCustomProgram () const
	check whether or not a custom GLSL program is in use

GLuint	lglGetActiveProgram () const
	get the actual GLSL program in use

bool	lglActiveColoring () const
	check for active vertex color attributes

bool	lglAppliedColoring () const
	check for applied vertex color attributes

bool	lglActiveLighting () const
	check for active vertex normal attributes

bool	lglActiveTexturing () const
	check for active vertex texture coordinate attributes

void	lglColoring (bool on)
	enable or disable the vertex color attributes contained in vbo

bool	lglGetColoring () const
	check for coloring

void	lglLighting (bool on)
	enable or disable the vertex normal attributes contained in vbo

bool	lglGetLighting () const
	check for lighting

void	lglTexturing (bool on)
	enable or disable the vertex texture coordinate attributes contained in vbo

bool	lglGetTexturing () const
	check for texturing

unsigned int	lglUniform (std::string uniform, bool warn=true)
	specify a uniform for the actual compiled GLSL program (undefined)

unsigned int	lglUniformi (std::string uniform, int value, bool warn=true)
	specify a uniform for the actual compiled GLSL program (integer)

void	lglUniformi (unsigned int index, int value, bool warn=true)
	specify a uniform for the actual compiled GLSL program (integer, indexed)

unsigned int	lglUniformf (std::string uniform, double value, bool warn=true)
	specify a uniform for the actual compiled GLSL program (float)

void	lglUniformf (unsigned int index, double value, bool warn=true)
	specify a uniform for the actual compiled GLSL program (float, indexed)

unsigned int	lglUniformfv (std::string uniform, const vec2f &value, bool warn=true)
	specify a uniform for the actual compiled GLSL program (vec2f)

void	lglUniformfv (unsigned int index, const vec2f &value, bool warn=true)
	specify a uniform for the actual compiled GLSL program (vec2f, indexed)

unsigned int	lglUniformfv (std::string uniform, const vec3f &value, bool warn=true)
	specify a uniform for the actual compiled GLSL program (vec3f)

void	lglUniformfv (unsigned int index, const vec3f &value, bool warn=true)
	specify a uniform for the actual compiled GLSL program (vec3f, indexed)

unsigned int	lglUniformfv (std::string uniform, const vec4f &value, bool warn=true)
	specify a uniform for the actual compiled GLSL program (vec4f)

void	lglUniformfv (unsigned int index, const vec4f &value, bool warn=true)
	specify a uniform for the actual compiled GLSL program (vec4f, indexed)

unsigned int	lglUniformfv (std::string uniform, const mat2f &value, bool warn=true)
	specify a uniform for the actual compiled GLSL program (mat2f)

void	lglUniformfv (unsigned int index, const mat2f &value, bool warn=true)
	specify a uniform matrix for the actual compiled GLSL program (mat2f, indexed)

unsigned int	lglUniformfv (std::string uniform, const mat3f &value, bool warn=true)
	specify a uniform for the actual compiled GLSL program (mat3f)

void	lglUniformfv (unsigned int index, const mat3f &value, bool warn=true)
	specify a uniform matrix for the actual compiled GLSL program (mat3f, indexed)

unsigned int	lglUniformfv (std::string uniform, const mat4f &value, bool warn=true)
	specify a uniform for the actual compiled GLSL program (mat4f)

void	lglUniformfv (unsigned int index, const mat4f &value, bool warn=true)
	specify a uniform matrix for the actual compiled GLSL program (mat4f, indexed)

unsigned int	lglUniform2fv (std::string uniform, const float value[2], bool warn=true)
	specify a uniform for the actual compiled GLSL program (float[2])

unsigned int	lglUniform3fv (std::string uniform, const float value[3], bool warn=true)
	specify a uniform for the actual compiled GLSL program (float[3])

unsigned int	lglUniform4fv (std::string uniform, const float value[4], bool warn=true)
	specify a uniform for the actual compiled GLSL program (float[4])

unsigned int	lglUniformMatrix2fv (std::string uniform, const float value[4], bool warn=true)
	specify a uniform matrix for the actual compiled GLSL program (float[4])

unsigned int	lglUniformMatrix3fv (std::string uniform, const float value[9], bool warn=true)
	specify a uniform matrix for the actual compiled GLSL program (float[9])

unsigned int	lglUniformMatrix4fv (std::string uniform, const float value[16], bool warn=true)
	specify a uniform matrix for the actual compiled GLSL program (float[16])

unsigned int	lglSampler (std::string sampler, int value=0, bool warn=true)
	specify a uniform sampler for the actual compiled GLSL program

void	lglSampler (unsigned int index, int value=0, bool warn=true)
	specify a uniform sampler for the actual compiled GLSL program (indexed)

unsigned int	lglSampler2D (std::string sampler, GLuint texid2D, int value=0, bool warn=true)
	bind a 2D sampler for the actual compiled GLSL program

void	lglSampler2D (unsigned int index, GLuint texid2D, int value=0, bool warn=true)
	bind a 2D sampler for the actual compiled GLSL program (indexed)

unsigned int	lglSampler3D (std::string sampler, GLuint texid3D, int value=0, bool warn=true)
	bind a 3D sampler for the actual compiled GLSL program

void	lglSampler3D (unsigned int index, GLuint texid3D, int value=0, bool warn=true)
	bind a 3D sampler for the actual compiled GLSL program (indexed)

void	lglCloneUniforms (const lgl *vbo)
	clone uniforms from vbo

void	lglCopyUniforms (const lgl *vbo, bool warn=false)
	copy uniforms from vbo

void	lglPrintUniforms ()
	print GLSL uniforms

void	lglCloneProgram (const lgl *vbo)
	clone GLSL program and uniforms from vbo

void	lglCopyProgram (const lgl *vbo)
	copy GLSL program and uniforms from vbo

void	lglLight (vec4f light=vec4f(0, 0, 1, 0), bool camera_light=true, vec3f ka=vec3f(0.1f), vec3f kd=vec3f(0.7f), vec3f ks=vec3f(0.2f), vec3f Ia=vec3f(1), vec3f Id=vec3f(1), vec3f Is=vec3f(1), float exponent=30, vec3f falloff=vec3f(1, 0, 0))
	specify the lighting parameters as supported by the default GLSL program

void	lglLightDirection (vec3f light=vec3f(0, 0, 1), bool camera_light=true)
	set the light direction

void	lglLightPosition (vec3f light=vec3f(0, 0, 0), bool camera_light=true)
	set the light position

void	lglLightVector (vec4f light=vec4f(0, 0, 1, 0), bool camera_light=true)
	set the light vector

vec4	lglGetLightVector () const
	get the light vector (in camera coordinates)

void	lglLightParameters (vec3f ka=vec3f(0.1f), vec3f kd=vec3f(0.7f), vec3f ks=vec3f(0.2f), vec3f Ia=vec3f(1), vec3f Id=vec3f(1), vec3f Is=vec3f(1), float exponent=30, vec3f falloff=vec3f(1, 0, 0))
	set the light parameters

void	lglGetLightParameters (vec3f &ka, vec3f &kd, vec3f &ks, vec3f &Ia, vec3f &Id, vec3f &Is, float &exponent, vec3f &falloff) const
	get the light parameters

void	lglLightSourceParameters (vec3f Ia=vec3f(1), vec3f Id=vec3f(1), vec3f Is=vec3f(1), vec3f falloff=vec3f(1, 0, 0))
	set the light source parameters

void	lglGetLightSourceParameters (vec3f &Ia, vec3f &Id, vec3f &Is, vec3f &falloff) const
	get the light source parameters

void	lglMaterialParameters (vec3f ka=vec3f(0.1f), vec3f kd=vec3f(0.7f), vec3f ks=vec3f(0.2f), float exponent=30)
	set the material parameters

void	lglGetMaterialParameters (vec3f &ka, vec3f &kd, vec3f &ks, float &exponent) const
	get the material parameters

void	lglTexture2D (GLuint texid, bool owner=false)
	bind a 2D texture for the default GLSL program

GLuint	lglGetTexture2D () const
	get the bound 2D texture

void	lglTexture3D (GLuint texid, bool owner=false)
	bind a 3D texture for the default GLSL program

GLuint	lglGetTexture3D () const
	get the bound 3D texture

void	lglDeleteTexture2D ()
	delete 2D texture map

void	lglDeleteTexture3D ()
	delete 3D texture map

void	lglDeleteTexture ()
	delete any texture map

void	lglTexCoordGen (lgl_texgenmode_enum mode=LGL_TEXGEN_LINEAR, double mix=0.5)
	enable texture coordinate generation

lgl_texgenmode_enum	lglGetTexCoordGen ()
	check whether or not texture coordinate generation is enabled

void	lglCloneState (const lgl *vbo)
	clone state from vbo (coloring, lighting and texturing)

void	lglClipPlane (vec4 equation=vec4(0, 0, 0, 0), unsigned int n=0, bool camera_plane=false)
	specify a clip plane as supported by the default GLSL program

void	lglClipPlane (double a, double b, double c, double d, unsigned int n=0, bool camera_plane=false)
	specify a clip plane as supported by the default GLSL program

void	lglClipPlane (vec3 point, vec3 normal, unsigned int n=0, bool camera_plane=false)
	specify a clip plane by a point on the plane and a plane normal

double	lglIntersect (vec3 origin, vec3 direction, mat4 m, double mindist=0) const
	cast a ray and intersect it with the transformed triangles contained in the vbo

double	lglIntersect (vec3 origin, vec3 direction, double mindist=0) const
	cast a ray and intersect it with the transformed triangles contained in the vbo

Static Public Member Functions
static GL *	getGL ()
	get the scene graph GL singleton

static void	lglManip (bool on=true)
	enable or disable the manipulator matrix

static void	lglManip (const mat4 &manip)
	update the manipulator matrix by multiplying it with a custom matrix

static void	lglManip (double focus, double angle, double tilt, double zoom)
	update the manipulator matrix by applying a rotation about a focus point and a zoom factor

static void	lglManip (double dx, double dy, double zoom=1)
	update the manipulator matrix by applying a screen-space delta

static void	lglManip (vec2 delta, double zoom=1)
	update the manipulator matrix by applying a screen-space delta

static void	lglResetManip ()
	reset the manipulator matrix

static mat4	lglGetManip ()
	get the manipulator matrix

static bool	lglIsManipApplied ()
	is the manipulator matrix applied?

static mat4	lglGetInverseTransposeManip ()
	get the inverse transpose of the manipulator matrix

static bool	lglSupportsGLSL ()
	check for GLSL support

static std::string	lglGetGLSLVersionString ()
	get GLSL version string

static std::string	lglPlainGLSLVertexShader ()
	get the LGL plain GLSL vertex shader

static std::string	lglPlainGLSLFragmentShader ()
	get the LGL plain GLSL fragment shader

static std::string	lglPlainGLSLProgram ()
	get the combined LGL plain GLSL program

static std::string	lglBasicGLSLVertexShader (bool colors=false, bool normals=false, bool texcoords=false)
	get the LGL default vertex shader

static std::string	lglBasicGLSLFragmentShader (bool colors=false, bool normals=false, bool texcoords=false, bool tex3D=false)
	get the LGL default fragment shader

static GLuint	lglCompileGLSLVertexShader (std::string shader)
	compile GLSL vertex shader

static GLuint	lglCompileGLSLFragmentShader (std::string shader)
	compile GLSL fragment shader

static GLuint	lglLinkGLSLProgram (GLuint vertex_shader_id, GLuint fragment_shader_id, GLuint custom_shader_program=0)
	link GLSL program

static GLuint	lglCompileGLSLProgram (std::string vertex_shader, std::string fragment_shader)
	compile a GLSL program from a vertex and a fragment shader source

static GLuint	lglCompileGLSLProgram (std::string shader="")
	compile a GLSL program from a combined vertex and fragment shader source

static GLuint	lglLoadGLSLProgram (const char vertex_shader_file, const char fragment_shader_file)
	compile a GLSL program from a vertex and a fragment shader source file

static GLuint	lglLoadGLSLProgram (const char *shader_file)
	compile a GLSL program from a combined vertex and fragment shader source file

static std::string	lglCombineGLSLProgram (const std::string &vertex_shader, const std::string &fragment_shader)
	combine GLSL program

static bool	lglSplitGLSLProgram (std::string shader, std::string &vertex_shader, std::string &fragment_shader)
	split GLSL program

static void	lglDeleteGLSLShader (GLuint shader_id)
	delete a compiled GLSL shader

static void	lglDeleteGLSLProgram (GLuint program)
	delete a compiled GLSL program

static void	lglDisableColoring (bool off)
	entirely disable vertex colors

static void	lglDisableLighting (bool off)
	entirely disable vertex normals

static void	lglDisableTexturing (bool off)
	entirely disable texture coordinates

static void	lglInitializeOpenGL (float r=0, float g=0, float b=0, float a=1, bool ztest=true, bool culling=false)
	initialize the OpenGL state (clear color, depth test, back-face culling)

static void	lglViewport (int ax, int ay, int bx, int by)
	set the viewport

static void	lglClearColor (float r, float g, float b, float a=1)
	set the clear color

static void	lglClear (GLuint bits=GL_COLOR_BUFFER_BIT\|GL_DEPTH_BUFFER_BIT)
	clear the color and depth buffer

static void	lglRGBAWrite (bool r=true, bool g=true, bool b=true, bool a=true)
	specify the RGBA write mask

static bool	lglGetRGBAWrite ()
	get the RGBA write mask

static void	lglZWrite (bool on=true)
	specify the depth write mask

static bool	lglGetZWrite ()
	get the depth write mask

static void	lglDepthTest (bool on=true)
	enable or disable depth testing

static bool	lglGetDepthTest ()
	check whether or not depth testing is enabled

static void	lglBackFaceCulling (bool on=true)
	enable or disable back-face culling

static bool	lglGetBackFaceCulling ()
	check whether or not back-face culling is enabled

static void	lglBlendMode (lgl_blendmode_enum mode=LGL_BLEND_NONE)
	enable or disable blending

static bool	lglGetBlending ()
	check whether or not blending is enabled

static lgl_blendmode_enum	lglGetBlendMode ()
	get the actual blending mode

static void	lglAlphaTest (bool on=false, float value=0.0f, bool greater=true, bool equal=false)
	enable or disable alpha testing

static bool	lglGetAlphaTest ()
	check whether or not alpha testing is enabled

static float	lglGetAlphaTestValue ()
	get the actual alpha test comparison value

static bool	lglGetAlphaTestGreater ()
	get the actual alpha test comparison mode

static bool	lglGetAlphaTestEqual ()
	get the actual alpha test equality mode

static bool	lglGetClipPlane (unsigned int n=0)
	check whether or not a clip plane is enabled

static vec4	lglGetClipPlaneEquation (unsigned int n=0)
	get the actual clip plane equation

static vec4	lglGetClipPlaneEquation (vec3 point, vec3 normal)
	compute a clip plane equation from a point and a normal

static void	lglFog (float density=0.0f, vec4f color=vec4f(1))
	specify the fog parameters as supported by the default GLSL program

static bool	lglGetFog ()
	check whether or not fogging is enabled

static float	lglGetFogDensity ()
	get the actual fog density

static vec4f	lglGetFogColor ()
	get the actual fog color

static void	lglLineWidth (float width=1.0f)
	specify the line rasterization width

static float	lglGetLineWidth ()
	get the line rasterization width

static void	lglPolygonMode (lgl_polygonmode_enum mode)
	specify the polygon mode

static lgl_polygonmode_enum	lglGetPolygonMode ()
	get the actual polygon mode

static void	lglInterlacingMode (lgl_interlacing_enum mode)
	specify the interlacing mode

static void	lglComplementaryInterlacingMode (lgl_interlacing_enum mode)
	specify the complementary interlacing mode

static lgl_interlacing_enum	lglGetInterlacingMode ()
	get the actual interlacing mode

static unsigned char *	lglReadRGBPixels (int x, int y, int width, int height)
	read frame buffer

static void	lglBeginRayCast (vec3 origin, vec3 direction, double mindist=0)
	begin ray casting in view coordinates

static void	lglRayCast (lgl *vbo)
	cast a ray and intersect it with the transformed triangles contained in the vbo

static lgl *	lglEndRayCast ()
	end ray casting

static double	lglGetRayCastDistance ()
	get distance to front-most hit point determined by ray casting

static void	lglEnableViewCulling (int minsize=0)
	enable view culling

static void	lglDisableViewCulling ()
	disable view culling

static void	lglBeginExport (void(callback)(lgl vbo, void data), void data, mat4 matrix=mat4(1))
	begin scene export More...

static void	lglExport (lgl *vbo)
	export vbo

static void	lglEndExport ()
	end scene export

static int	lglGetGLVersion ()
	get the OpenGL version

static int	lglMapGL2GLSLVersion (int glversion)
	map gl version to glsl version

static int	lglGetGLSLVersion ()
	get the GLSL version

static std::string	lglGetRenderer ()
	get the OpenGL renderer

static lgl_vendor_enum	lglGetVendor ()
	get the OpenGL vendor

static std::string	lglGetVendorName ()
	get the vendor name of the graphics hardware

static std::string	lglGetError ()
	get a description of the last occured error

static std::string	lglGetWarning ()
	get a description of the last occured warning

static void	lglMessage (std::string m)
	generate a status message

static void	lglError (std::string e)
	generate an error message

static void	lglWarning (std::string w)
	generate a warning message

static void	lglFatal (std::string e)
	generate a non-recoverable error

static void	lglVerbosity (lgl_verbosity_enum v)
	change verbosity level

Protected Member Functions
virtual void	render ()
	reimplement this method to render a node

virtual void	pick ()
	reimplement this method to pick a node

lgl_Node *	add_node (lgl_Node *node)
	add a child to the node

virtual void	update (double dt)
	reimplement this method to update a node

vec4f	setupStereoMode (lgl_interlacing_enum mode)
	interlaced stereo modes: More...

Detailed Description

vbo node

a vbo node encapsulates a triangle mesh by deriving from the lglVBO class

Member Function Documentation

◆ getBoundingBox()

virtual void lgl_Node::getBoundingBox	(	vec3 &	bboxmin,
		vec3 &	bboxmax
	)

inlinevirtualinherited

get the bounding box of the entire subgraph

the bounding box is invalid if a maximum component is less than the minimum component

Reimplemented in lgl_SubgraphNode.

◆ getBoundingSphere()

double lgl_Node::getBoundingSphere ( vec3 & center )

inlineinherited

get the bounding sphere of the entire subgraph

returns the radius of the bounding sphere
the bounding sphere is invalid if the radius is zero

◆ getExactBoundingBox()

void lgl_Node::getExactBoundingBox	(	vec3 &	bboxmin,
		vec3 &	bboxmax
	)

inlineinherited

get the exact bounding box of the entire subgraph

this is a computationally expensive operation

◆ getNorm()

double lgl_Node::getNorm ( )

inlineinherited

get the bounding sphere norm of the entire subgraph

zero norm means that the subgraph does not contain valid geometry

◆ getRadius()

double lgl_Node::getRadius ( )

inlineinherited

get the bounding sphere radius of the entire subgraph

zero radius means that the subgraph does not contain valid geometry

◆ getVertexCoordinates()

virtual std::vector<vec4> lgl_Node::getVertexCoordinates ( mat4 trans = mat4() )

inlinevirtualinherited

this is a computationally expensive operation

Reimplemented in lgl_SubgraphNode.