unit cylinder vbo More...

#include <glvertex_geometry.h>

Inheritance diagram for lglCylinder:

Public Member Functions
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 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
vec4f	setupStereoMode (lgl_interlacing_enum mode)
	interlaced stereo modes: More...

Detailed Description

unit cylinder vbo

the lglCylinder class provides a pre-defined vbo, which contains a single cylinder with unit size

the rotation axis of the cylinder corresponds to the z-axis
as it is unit sized, the extents range from -0.5 to 0.5
by default it contains normal and texture coordinate attributes but no color attribute