# Visualization Library A lightweight C++ OpenGL middleware for 2D/3D graphics | [Home] [Tutorials] [All Classes] [Grouped Classes]

# Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

vl::A3DSLoader | Loads an Autodesk 3DS file and generates a vector of A3DSObject and A3DSMaterial objects
vl::A3DSMaterial | Material in a 3DS file
vl::A3DSMaterialFaceMapping | Material/face mapping in a 3DS file
vl::A3DSObject | Object in a 3DS file
vl::A3DSTexture | Texture in a 3DS file
vl::A3DSTriFace | Triangle in a 3DS file
vl::A3DSVertex | Vertex in a 3DS file
vl::AABB | Implements an axis-aligned bounding box using vl::Real precision
vl::Actor | Associates a Renderable object to an Effect and Transform
vl::ActorKdTree | ActorKdTree class extends the ActorTreeAbstract class implementing a space partitioning scheme based on a Kd-Tree
vl::ActorRenderingCallback | Defines a callback object to be executed just before an Actor is rendered but after the render states are setup
vl::ActorTree | Implements a generic tree whose nodes contain Actor[s]
vl::ActorTreeAbstract | Implements the interface of a generic tree containing Actor[s] in its nodes
vl::AlphaFunc | Wraps the OpenGL function glAlphaFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glAlphaFunc.xml for more information
vl::Array< vector_type, scalar_type, gl_size, gl_type > | The Array class is a template array used to conveniently manipulate data stored in a GLBufferObject
vl::ArrayAbstract | Defines an abstract interface to conveniently manipulate data stored in a GLBufferObject
vl::BezierPatch | Defines one or more concatenated bicubic Bézier patches to be used with the BezierSurface class
vl::BezierSurface | Implements a Geometry that is capable of visualizing multiple bicubic Bézier patches (see BezierPatch)
vl::Billboard | A Transform that aligns an Actor towards the camera
vl::BlendColor | Wraps the OpenGL function glBlendColor(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendColor.xml for more information
vl::BlendEquation | Wraps the OpenGL function glBlendEquation()/glBlendEquationSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquation.xml and http://www.opengl.org/sdk/docs/man/xhtml/glBlendEquationSeparate.xml for more information
vl::BlendFunc | Wraps the OpenGL function glBlendFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendFunc.xml for more information
vl::BlitFramebuffer | A RenderingCallback that can be used to copy pixels from a framebuffer to another as described in GL_EXT_framebuffer_blit
vl::Buffer | Implements a buffer whose storage is in local memory
vl::BufferedStream< Element_Type, Chunk_Size > | The BufferedStream class is a template class that that performs a buffered read of Element_Type data from a VirtualFile
vl::Camera | Represents a virtual camera defining, among other things, the point of view from which scenes can be rendered
vl::CatmullRomInterpolator< T > | The LinearInterpolator class is a template class that implements Catmull-Rom spline interpolation
vl::CatmullRomInterpolatorDouble | Interpolates `double` values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorDVec2 | Interpolates vl::dvec2 values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorDVec3 | Interpolates vl::dvec3 values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorDVec4 | Interpolates vl::dvec4 values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorFloat | Interpolates `float` values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorFVec2 | Interpolates vl::fvec2 values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorFVec3 | Interpolates vl::fvec3 values using a CatmullRomInterpolator
vl::CatmullRomInterpolatorFVec4 | Interpolates vl::fvec4 values using a CatmullRomInterpolator
vl::Clear | Renderable used to clear the whole or a portion of the color, stencil or depth buffer
vl::ClipPlane | Wraps the OpenGL function glClipPlane()
vl::Collection< T > | Reference counted container that encapsulates the base functionalites of an std::vector<>
vl::ColorMask | Wraps the OpenGL function glColorMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glColorMask.xml for more information
vl::CopyTexSubImage | Wrapper class of the OpenGL function glCopyTexSubImage
vl::CopyTexSubImage1D | Wraps glCopyTexSubImage1D, see also CopyTexSubImage
vl::CopyTexSubImage2D | Wraps glCopyTexSubImage2D, see also CopyTexSubImage. To be used also for 1D array textures
vl::CopyTexSubImage3D | Wraps glCopyTexSubImage3D, see also CopyTexSubImage. To be used also for 2D array textures
vl::CRC32CheckSum | Computes the a CRC32 checksum of a given buffer or VirtualFile
vl::CullFace | Wraps the OpenGL function glCullFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glCullFace.xml for more information
vl::DepthFunc | Wraps the OpenGL function glDepthFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthFunc.xml for more information
vl::DepthMask | Wraps the OpenGL function glDepthMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthMask.xml for more information
vl::DepthRange | Wraps the OpenGL function glDepthRange(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthRange.xml for more information
vl::DepthSortCallback | Sorts the primitives of the Geometry object bound to the Actor in which the callback is installed
vl::DiskDirectory | A VirtualDirectory that operates on reguar disk directories
vl::DiskFile | A VirtualFile that operates on regular disk files
vl::DistanceLODEvaluator | A LODEvaluator that computes the appropriate LOD based on the distance of an Actor from the Camera
vl::DoubleVertexRemover | Removes from a Geometry the vertices with the same attributes
vl::DrawArrays | Wraps the OpenGL function glDrawArrays(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDrawArrays.xml for more information
vl::DrawElements< index_type, Tgltype, arr_type > | Wrapper for the OpenGL function glDrawElements(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDrawElements.xml for more information
vl::DrawPixels | Wraps the OpenGL function glDrawPixels()
vl::DrawPixels::Pixels | Represents a bitmap to be drawn on the screen
vl::EdgeExtractor | Extracts the edges from one or more Geometry objects
vl::EdgeExtractor::Edge | A single edge as extracted from the EdgeExtractor class
vl::EdgeRenderer | Implements a special Renderer that automatically extracts and renders the edges of the objects in the scene
vl::EdgeUpdateCallback | Updates at every frame the edges of an Actor for the purpose of edge-enhancement
vl::Effect | Defines the sequence of Shader objects used to render an Actor
vl::EnableSet | A set of enables managed by Shader
vl::Extrusion | Generates a Geometry extruding a silhouette along a path
vl::FBOAttachmentAbstract | Abstract class that represents a framebuffer object attachment, i.e
vl::FBOColorBufferAttachment | A color renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBODepthBufferAttachment | A depth renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBODepthStencilBufferAttachment | A depth+stencil renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBORenderbufferAttachment | Abstract class that represents a framebuffer renderbuffer attachment, i.e
vl::FBORenderTarget | Implements a framebuffer object to be used as a rendering target as specified by the GL_EXT_framebuffer_object extension
vl::FBOStencilBufferAttachment | A stencil renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBOTexture1DAttachment | A 1D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBOTexture2DAttachment | A 2D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBOTexture3DAttachment | A 3D texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBOTextureAttachment | A texture renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FBOTextureLayerAttachment | A texture layer renderbuffer to be attached to a framebuffer object rendering target (FBORenderTarget)
vl::FileSystem | Manages multiple VirtualDirectory objects
vl::Fog | Wraps the OpenGL function glFog(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFog.xml for more information
vl::Font | A font to be used with a Text renderable
vl::FontManager | Keeps a map associating a font path, size and smoothing flag to a Font object
vl::FrontFace | Wraps the OpenGL function glFrontFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFrontFace.xml for more information
vl::Frustum | A set of planes defining a frustum used for culling purposes (frustum culling)
vl::Geometry | Renderable that implements a polygonal mesh made of polygons, lines and points
vl::GeometryLoadCallback | Defines a set of actions to be executed to a Geometry as soon as it is loaded
vl::GhostCameraManipulator | UIEventListener that controls the position and orientation of a Camera
vl::GLBufferObject | Buffer that can upload its data on the GPU memory
vl::GLSLFragmentShader | Wraps a GLSL fragment shader to be bound to a GLSL program
vl::GLSLGeometryShader | Wraps a GLSL geometry shader to be bound to a GLSL program
vl::GLSLProgram | Wraps a GLSL program to which you can bind vertex, fragment and geometry shaders
vl::GLSLShader | Base class for GLSLVertexShader, GLSLFragmentShader and GLSLGeometryShader
vl::GLSLVertexShader | Wraps a GLSL vertex shader to be bound to a GLSL program
vl::Glyph | The Glyph associated to a character of a given Font
vl::GZipCodec | VirtualFile that transparently encodes and decodes a stream of data using the GZip compression algorithm
vl::Hint | Wraps the OpenGL function glHint(), see also http://www.opengl.org/sdk/docs/man/xhtml/glHint.xml for more information
vl::Image | Implements a generic 1d, 2d, 3d and cubemap image that can have mipmaps
vl::Interpolator | Abstract class for all the interpolators
vl::InterpolatorDouble | Abstract class that interpolates `double` values
vl::InterpolatorDVec2 | Abstract class that interpolates vl::dvec2 values
vl::InterpolatorDVec3 | Abstract class that interpolates vl::dvec3 values
vl::InterpolatorDVec4 | Abstract class that interpolates vl::dvec4 values
vl::InterpolatorFloat | Abstract class that interpolates `float` values
vl::InterpolatorFVec2 | Abstract class that interpolates vl::fvec2 values
vl::InterpolatorFVec3 | Abstract class that interpolates vl::fvec3 values
vl::InterpolatorFVec4 | Abstract class that interpolates vl::fvec4 values
vl::KeyValues | A set of key/value pairs used to store generic information
vl::Light | Wraps the OpenGL function glLight()
vl::LightModel | Wraps the OpenGL function glLightModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLightModel.xml for more information
vl::LinearInterpolator< T > | The LinearInterpolator class is a template class that implements linear interpolation
vl::LinearInterpolatorDouble | Interpolates `double` values using a LinearInterpolator
vl::LinearInterpolatorDVec2 | Interpolates vl::dvec2 values using a LinearInterpolator
vl::LinearInterpolatorDVec3 | Interpolates vl::dvec3 values using a LinearInterpolator
vl::LinearInterpolatorDVec4 | Interpolates vl::dvec4 values using a LinearInterpolator
vl::LinearInterpolatorFloat | Interpolates `float` values using a LinearInterpolator
vl::LinearInterpolatorFVec2 | Interpolates vl::fvec2 values using a LinearInterpolator
vl::LinearInterpolatorFVec3 | Interpolates vl::fvec3 values using a LinearInterpolator
vl::LinearInterpolatorFVec4 | Interpolates vl::fvec4 values using a LinearInterpolator
vl::LineStipple | Wraps the OpenGL function glLineStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineStipple.xml for more information
vl::LineWidth | Wraps the OpenGL function glLineWidth(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineWidth.xml for more information
vl::LoadCallback | Defines an operation to be exectued to a ResourceDatabase as soon as its loaded, see also LoadWriterManager, WriteCallback
vl::LoadWriter3DS | ResourceLoadWriter capable of reading 3DS files
vl::LoadWriterAC3D | ResourceLoadWriter capable of reading AC3D files
vl::LoadWriterBMP | ResourceLoadWriter capable of reading BMP files
vl::LoadWriterDAT | ResourceLoadWriter capable of reading DAT files
vl::LoadWriterDDS | ResourceLoadWriter capable of reading DDS files
vl::LoadWriterDICOM | ResourceLoadWriter capable of reading DICOM files
vl::LoadWriterJPG | ResourceLoadWriter capable of reading JPG files
vl::LoadWriterManager | Loads and writes resources using the registered ResourceLoadWriter objects
vl::LoadWriterMD2 | ResourceLoadWriter capable of reading MD2 files
vl::LoadWriterOBJ | ResourceLoadWriter capable of reading OBJ files
vl::LoadWriterPLY | ResourceLoadWriter capable of reading PLY files
vl::LoadWriterPNG | ResourceLoadWriter capable of reading PNG files
vl::LoadWriterSTL | ResourceLoadWriter capable of reading STL files
vl::LoadWriterTGA | ResourceLoadWriter capable of reading TGA files
vl::LoadWriterTIFF | ResourceLoadWriter capable of reading TIFF files
vl::LODEvaluator | Abstract class to compute the appropriate LOD of an Actor or Effect
vl::Log | Abstract base class used to generate logging data
vl::LogicOp | Wraps the OpenGL function glLogicOp(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLogicOp.xml for more information
vl::Material | Wraps the OpenGL function glMaterial() and glColorMaterial(), see also http://www.opengl.org/sdk/docs/man/xhtml/glMaterial.xml and http://www.opengl.org/sdk/docs/man/xhtml/glColorMaterial.xml for more information
vl::Matrix2< scalar_type > | The Matrix2 class is a template class that implements a generic 2x2 matrix, see also vl::dmat2, vl::fmat2, vl::umat2, vl::imat2
vl::Matrix3< scalar_type > | The Matrix3 class is a template class that implements a generic 3x3 matrix, see also vl::dmat3, vl::fmat3, vl::umat3, vl::imat3
vl::Matrix4< scalar_type > | The Matrix4 class is a template class that implements a generic 4x4 matrix, see also vl::dmat4, vl::fmat4, vl::umat4, vl::imat4
vl::MD5CheckSum | Computes the MD5 of a given buffer or VirtualFile
vl::MemoryDirectory | A VirtualDirectory to manipulate directories stored in memory
vl::MemoryFile | A VirtualFile to manipulate files stored in memory
vl::MorphingActor | Animates a Geometry by interpolating its position and normal array
vl::MorphingCallback | Used by MorphingActor to implement the morphing animation on the GPU
vl::Object | The base class for all the reference counted objects
vl::ObjLoader | Loads a Wavefront OBJ file
vl::ObjMaterial | Represents a Wavefront OBJ material as loaded from an MTL file. See also ObjLoader
vl::ObjMesh | Represents a Wavefront OBJ mesh. See also ObjLoader
vl::ObjTexture | Represents a Wavefront OBJ texture. See also ObjMaterial and ObjLoader
vl::OpenGLContext | Represents an abstract GUI object containing an OpenGL context to which also keyboard, mouse or system events can be sent
vl::OpenGLContextFormat | Encapsulates the settings of an OpenGL rendering context
vl::PixelLODEvaluator | A LODEvaluator that computes the appropriate LOD based on the approximate 2d area that an Actor covers on the screen
vl::PixelTransfer | Wraps the OpenGL function glPixelTransfer(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPixelTransfer.xml for more information
vl::Plane | Defines a plane using a normal and an origin
vl::PlyLoader | Loads a PLY file
vl::PlyLoader::PlyElement | Used by PlyLoader
vl::PlyLoader::PlyPropertyAbstract | Used by PlyLoader
vl::PlyLoader::PlyScalar | Used by PlyLoader
vl::PlyLoader::PlyScalarList | Used by PlyLoader
vl::PointParameter | Wraps the OpenGL function glPointParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointParameter.xml for more information
vl::PointSize | Wraps the OpenGL function glPointSize(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointSize.xml for more information
vl::PolygonMode | Wraps the OpenGL function glPolygonMode(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonMode.xml for more information
vl::PolygonOffset | Wraps the OpenGL function glPolygonOffset(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information
vl::PolygonSimplifier | Reduces the amount of polygons present in a Geometry using a quadric error metric
vl::PolygonSimplifier::QErr | The quadric error metric as defined by PolygonSimplifier
vl::PolygonSimplifier::Triangle | A Triangle as defined by PolygonSimplifier
vl::PolygonSimplifier::Vertex | A Vertex as defined by PolygonSimplifier
vl::PolygonStipple | Wraps the OpenGL function glPolygonStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonStipple.xml for more information
vl::Portal | A planar convex polygon used to define the visibility from one Sector to another
vl::Primitives | This is the base class of DrawElements and DrawArrays which respectively wrap the OpenGL functions glDrawElements() and glDrawArrays()
vl::quat | Implements a quaternion using vl::Real precision
vl::Ray | Defines a ray as an origin and direction using Real precision
vl::RayIntersection | The RayIntersection encapsulates all the information relative to a Ray/Actor intersection
vl::RayIntersectionGeometry | The RayIntersectionGeometry encapsulates all the information relative to a Ray/Actor intersection, providing also extra information relative to the intersection on the Geometry in use by the Actor
vl::RayIntersector | Used to detect the intersection points between a Ray and a set of Actor[s]
vl::ReadPixels | A RenderingCallback that copyes a rectangular pixel area from a source buffer to an Image at the end of a rendering
vl::Rect< T > | Implements the common functions of RectI and RectF
vl::RectF | 2D rectangular area using `float` precision
vl::RectI | 2D rectangular area using `int` precision
vl::ref< T > | The ref<> class is used to reference-count an Object
vl::Renderable | An abstract class that represents all the objects that can be rendered
vl::Renderer | Executes the actual rendering on the given RenderQueue
vl::Rendering | Collects all the information to perform the rendering of a scene
vl::RenderingAbstract | Implements the abstract rendering interface
vl::RenderingCallback | An abstract class used to perform operations at the end or at the beginning of a rendering
vl::RenderingTree | Organizes a set of renderings into a tree-like data structure
vl::RenderQueue | Collects a list of RenderToken objects to be sorted and rendered
vl::RenderQueueSorter | Abstract base class of all the algorithms used to sort a set of RenderToken
vl::RenderQueueSorterAggressive | Sorts the RenderTokens by Effect rank -> Actor rank -> blending on/off -> Z distance form the Camera -> GLSL program -> render state set -> enable set -> texture set -> light set -> Shader pointer -> Renderable pointer
vl::RenderQueueSorterBasic | Sorts the RenderTokens by their Effect rank -> Actor rank -> Shader pointer -> Renderable pointer
vl::RenderQueueSorterByRenderable | Sorts the RenderTokens by their Renderable pointer
vl::RenderQueueSorterByShader | Sorts the RenderTokens by their Shader pointer
vl::RenderQueueSorterOcclusion | Implements a RenderQueueSorter to be used with occlusion culling
vl::RenderQueueSorterStandard | Implements the default RenderQueueSorter
vl::RenderState | Base class for most of the OpenGL render state wrapper classes
vl::RenderStateSet | A set of RenderState objects managed by a Shader
vl::RenderTarget | Defines an abstract 'surface' where OpenGL can render into
vl::RenderToken | Internally used by the rendering engine
vl::ResourceDatabase | And manipulates a set of resources
vl::ResourceLoadWriter | Abstract class used to implement read/write support for one or more resource types
vl::SampleCoverage | Wraps the OpenGL function glSampleCoverage(), see also http://www.opengl.org/sdk/docs/man/xhtml/glSampleCoverage.xml for more information
vl::Say | A simple String formatting class
vl::SayArg | Used internally by the Say class
vl::SceneManager | Base class for all the scene managers
vl::SceneManagerActorKdTree | A SceneManagerBVH that implements its spatial partitioning strategy using an ActorKdTree
vl::SceneManagerActorTree | A SceneManagerBVH that implements its spatial partitioning strategy using an ActorTree
vl::SceneManagerBVH< T > | The SceneManagerBVH class implements the basic functionalities for bounding-volume-hierarchy based scene managers
vl::SceneManagerPortals | The SceneManagerPortals calss implements a portal-based hidden surface removal algorithm to efficently render highly occluded scenes
vl::Scissor | Wraps the OpenGL function glScissor(), see http://www.opengl.org/sdk/docs/man/xhtml/glScissor.xml for more information
vl::Sector | Defines an area containg a set if Actor[s] that is connected to other Sector[s] through its Portal[s]
vl::Sector::VisibilityCallback | A callback object called each time a Sector becomes visible through a Portal
vl::ShadeModel | Wraps the OpenGL function glShadeModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glShadeModel.xml for more information
vl::Shader | Manages most of the OpenGL rendering states responsible of the final aspect of the rendered objects
vl::ShaderNode | Used to conveniently manage complex hierarchies of Shader[s]
vl::ShaderSequence | A sequence of Shader objects each of which represent a rendering pass
vl::Sphere | Defines a sphere using a center and a radius using vl::Real precision
vl::StandardLog | Outputs the log messages on the stdout device and optionally also on a specified file
vl::StencilFunc | Wraps the OpenGL functions glStencilFunc() and glStencilFuncSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilFunc.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilFuncSeparate.xml for more information
vl::StencilMask | Wraps the OpenGL function glStencilMask() and glStencilMaskSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilMask.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilMaskSeparate.xml for more information
vl::StencilOp | Wraps the OpenGL function glStencilOp() and glStencilOpSeparate(), see also http://www.opengl.org/sdk/docs/man/xhtml/glStencilOp.xml and http://www.opengl.org/sdk/docs/man/xhtml/glStencilOpSeparate.xml for more information
vl::STLLoader | Loads an STL file
vl::String | Implements an advanced UTF16 (Unicode BMP) string manipulation engine
vl::Terrain | Implements a ActorKdTree-based terrain scene manager
vl::Tessellator | Tessellates a complex polygon defined by a set of outlines into a set of triangles that can be rendered by Visualization Library
vl::TexEnv | Wraps the OpenGL function glTexEnv(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexEnv.xml for more information
vl::TexGen | Wraps the OpenGL function glTexGen(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexGen.xml for more information
vl::TexParameter | Wraps the OpenGL function glTexParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexParameter.xml for more information
vl::Text | A Renderable that renders text with a given Font
vl::TextStream | Can be used to conveniently read or parse utf8-encoded text files
vl::Texture | Wraps an OpenGL texture object
vl::Texture::SetupParams | The SetupParams function wraps all the parameters neede to crate a Texture
vl::TextureMatrix | Uses a 4x4 matrix to transform the texture coordinates of a texture unit
vl::TextureUnit | Associates a Texture object to an OpenGL texture unit
vl::Time | Simple class to be used as a timer and to retrieve the current time and date
vl::TrackballManipulator | This class lets you rotate a Camera or a Transform node using a vitual trackball
vl::Transform | Implements a 4x4 matrix transform usually used to define the position and orientation of an Actor
vl::TriangleStripGenerator | Used to substitute lists of triangles or quads with triangle strips
vl::UIEventListener | Listens to the events emitted by an OpenGLContext
vl::Uniform | Wraps an OpenGL Shading Language uniform to be associated to a GLSLProgram
vl::UniformSet | A set of Uniform objects managed by a Shader
vl::Vector2< scalar_type > | The Vector2 class is a template class that implements a generic 2 components vector, see also vl::fvec2, vl::dvec2, vl::uvec2, vl::ivec2, vl::svec2, vl::usvec2, vl::bvec2, vl::ubvec2
vl::Vector3< scalar_type > | The Vector3 class is a template class that implements a generic 3 components vector, see also vl::fvec3, vl::dvec3, vl::uvec3, vl::ivec3, vl::svec3, vl::usvec3, vl::bvec3, vl::ubvec3
vl::Vector4< scalar_type > | The Vector4 class is a template class that implements a generic 4 components vector, see also vl::fvec4, vl::dvec4, vl::uvec4, vl::ivec4, vl::svec4, vl::usvec4, vl::bvec4, vl::ubvec4
vl::VertexAttributeArray | Implements a generic OpenGL Shading Language vertex attribute to be used with a Geometry
vl::VertexMapper | Generates a set of new vertices from the old one
vl::Viewport | Implements the viewport and clearing settings associated to a Camera
vl::VirtualDirectory | Abstact class representing a directory of files
vl::VirtualFile | An abstract class representing a file
vl::VisualizationLibrary | Used to initialize/shutdown VisualizationLibrary and to access important global data
vl::WriteCallback | Defines an operation to be exectued to a ResourceDatabase just before it is written, see also LoadWriterManager, LoadCallback
vl::ZippedDirectory | A VirtualDirectory capable of reading files from a .zip file
vl::ZippedFile | A VirtualFile used to read a file contained in a .zip archive
vl::ZippedFileInfo | Collects the information about a ZippedFile
vlGLUT::GLUTWindow | Implements an OpenGLContext using the GLUT API
vlMFC::MFCWindow | MFC CWnd with the functionalities of a Win32Context
vlMolecule::Atom | Atom to be used with the Molecule class
vlMolecule::AtomInfo | Encapsulates information regarding an atom type
vlMolecule::Bond | Bond to be used with the Molecule class
vlMolecule::Molecule | Used to manage and render 3D molecular structures
vlMolecule::RingExtractor | Traverses a molecule's graph and detects various types of cycles, mainly used for aromatic ring detection
vlQt4::Qt4Widget | Implements an OpenGLContext using the Trolltech's Qt4 API
vlSDL::SDLWindow | Implements an OpenGLContext using the SDL API
vlut::Applet | Utilitly UIEventListener that features a ghost manipulator, trackball manipulator, an FPS counter and a simple rendering pipeline
vlVG::SceneManagerVectorGraphics | SceneManager that contains VectorGraphics objects
vlVG::VectorGraphics | Used in conjuction with SceneManagerVectorGraphics to generate and render 2D vector graphics
vlVolume::MarchingCubes | An efficient implementation of the Marching Cubes algorithm
vlVolume::SlicedVolume | An actor encapsulating all the geometry and effects needed to directly render a volume using viewport aligned slices
vlVolume::Volume | Defines the volume data to be used with a MarchingCube object
vlVolume::VolumeInfo | Defines the volume parameters to be used with a MarchingCube and Volume object
vlVolume::VolumePlot | Generates a 3D plot with labels and isosurface. The isosurface is generated using the MarchingCubes algorithm
vlVolume::VolumePlot::Function | A function to be used with VolumePlot
vlWin32::Win32Context | Implements an OpenGLContext using the Win32 API
vlWin32::Win32Window | Win32Context that can be used as a top or child window
vlWX::vlWXGLCanvas | Implements a vl::OpenGLContext using the wxWidgets library

Visualization Library v2009.08 Reference Documentation
Copyright 2005-2009 Michele Bosi. All rights reserved.
Updated on Sun Nov 29 11:11:43 2009.
Permission is granted to use this page to write and publish articles regarding Visualization Library.