| ►CCView | |
| CvlMFC::MDIWindow | MFC CView with the functionalities of a Win32Context (experimental) |
| ►CCWnd | |
| CvlMFC::MFCWindow | MFC CWnd with the functionalities of a Win32Context |
| Cvl::Matrix4< double > | |
| Cvl::Matrix4< float > | |
| ►CQGLWidget | |
| CvlQt4::Qt4Widget | Implements an OpenGLContext using the Qt4 API |
| CvlQt5::Qt5Widget | Implements an OpenGLContext using the Qt5 API |
| ►CQOpenGLWidget | |
| CvlQt6::Qt6Widget | Implements an OpenGLContext using the Qt6 API |
| ►Cvl::Rect< float > | |
| Cvl::RectF | 2D rectangular area using float precision |
| ►Cvl::Rect< int > | |
| Cvl::RectI | 2D rectangular area using int precision |
| Cvl::ref< Actor > | |
| Cvl::ref< ActorKdTree > | |
| Cvl::ref< ActorTree > | |
| Cvl::ref< arr_type > | |
| Cvl::ref< ArrayUByte1 > | |
| Cvl::ref< ArrayUInt1 > | |
| Cvl::ref< ArrayUShort1 > | |
| Cvl::ref< Light > | |
| Cvl::ref< Shader > | |
| Cvl::ref< StringData > | |
| Cvl::ref< vl::Actor > | |
| Cvl::ref< vl::ActorCollection > | |
| Cvl::ref< vl::ActorEventCallback > | |
| Cvl::ref< vl::ActorKdTree > | |
| Cvl::ref< vl::ActorTree > | |
| Cvl::ref< vl::ActorTreeAbstract > | |
| Cvl::ref< vl::ArrayAbstract > | |
| Cvl::ref< vl::ArrayFloat3 > | |
| Cvl::ref< vl::ArrayFloat4 > | |
| Cvl::ref< vl::ArrayUByte4 > | |
| Cvl::ref< vl::Atom > | |
| Cvl::ref< vl::BezierPatch > | |
| Cvl::ref< vl::Bond > | |
| Cvl::ref< vl::Buffer > | |
| Cvl::ref< vl::BufferObject > | |
| Cvl::ref< vl::Camera > | |
| Cvl::ref< vl::CatmullRomInterpolator > | |
| Cvl::ref< vl::Collection< vl::RenderEventCallback > > | |
| Cvl::ref< vl::Collection< vl::RenderingAbstract > > | |
| Cvl::ref< vl::Collection< vl::SceneManager > > | |
| Cvl::ref< vl::Dae::Effect > | |
| Cvl::ref< vl::Dae::Input > | |
| Cvl::ref< vl::Dae::Material > | |
| Cvl::ref< vl::Dae::Mesh > | |
| Cvl::ref< vl::Dae::NewParam > | |
| Cvl::ref< vl::Dae::Node > | |
| Cvl::ref< vl::Dae::Primitive > | |
| Cvl::ref< vl::Dae::Sampler2D > | |
| Cvl::ref< vl::Dae::Source > | |
| Cvl::ref< vl::Dae::Surface > | |
| Cvl::ref< vl::Dae::TechniqueCOMMON > | |
| Cvl::ref< vl::DrawCall > | |
| Cvl::ref< vl::DrawElementsUShort > | |
| Cvl::ref< vl::DrawPixels::Pixels > | |
| Cvl::ref< vl::EdgeUpdateCallback > | |
| Cvl::ref< vl::Effect > | |
| Cvl::ref< vl::EnableSet > | |
| Cvl::ref< vl::FBOAbstractAttachment > | |
| Cvl::ref< vl::Font > | |
| Cvl::ref< vl::FramebufferObject > | |
| Cvl::ref< vl::Geometry > | |
| Cvl::ref< vl::GhostCameraManipulator > | |
| Cvl::ref< vl::GLSLProgram > | |
| Cvl::ref< vl::GLSLShader > | |
| Cvl::ref< vl::Glyph > | |
| Cvl::ref< vl::Image > | |
| Cvl::ref< vl::ImagePBO > | |
| Cvl::ref< vl::IndexIteratorAbstract > | |
| Cvl::ref< vl::KeyValues > | |
| Cvl::ref< vl::Light > | |
| Cvl::ref< vl::LinearInterpolator > | |
| Cvl::ref< vl::LoadCallback > | |
| Cvl::ref< vl::LoadWriterDae::LoadOptions > | |
| Cvl::ref< vl::LODEvaluator > | |
| Cvl::ref< vl::MemoryFile > | |
| Cvl::ref< vl::NaryQuickMap< EEnable, EEnable, EN_EnableCount > > | |
| Cvl::ref< vl::NaryQuickMap< ERenderState, vl::RenderStateSlot, RS_RenderStateCount > > | |
| Cvl::ref< vl::Object > | |
| Cvl::ref< vl::ObjMaterial > | |
| Cvl::ref< vl::ObjMesh > | |
| Cvl::ref< vl::PatchParameter > | |
| Cvl::ref< vl::PlyLoader::PlyElement > | |
| Cvl::ref< vl::PlyLoader::PlyPropertyAbstract > | |
| Cvl::ref< vl::PlyLoader::PlyScalar > | |
| Cvl::ref< vl::Portal > | |
| Cvl::ref< vl::ProjViewTransfCallback > | |
| Cvl::ref< vl::RayIntersection > | |
| Cvl::ref< vl::ReadPixels > | |
| Cvl::ref< vl::Renderable > | |
| Cvl::ref< vl::Renderer > | |
| Cvl::ref< vl::RenderEventCallback > | |
| Cvl::ref< vl::RenderingAbstract > | |
| Cvl::ref< vl::RenderQueue > | |
| Cvl::ref< vl::RenderQueueSorter > | |
| Cvl::ref< vl::RenderState > | |
| Cvl::ref< vl::RenderStateSet > | |
| Cvl::ref< vl::RenderToken > | |
| Cvl::ref< vl::ResourceDatabase > | |
| Cvl::ref< vl::ResourceLoadWriter > | |
| Cvl::ref< vl::SceneManager > | |
| Cvl::ref< vl::SceneManagerActorTree > | |
| Cvl::ref< vl::Scissor > | |
| Cvl::ref< vl::Sector > | |
| Cvl::ref< vl::Sector::VisibilityCallback > | |
| Cvl::ref< vl::Shader > | |
| Cvl::ref< vl::ShaderAnimator > | |
| Cvl::ref< vl::ShaderNode > | |
| Cvl::ref< vl::ShaderPasses > | |
| Cvl::ref< vl::TexParameter > | |
| Cvl::ref< vl::Text > | |
| Cvl::ref< vl::Texture > | |
| Cvl::ref< vl::Texture::SetupParams > | |
| Cvl::ref< vl::TrackballManipulator > | |
| Cvl::ref< vl::Transform > | |
| Cvl::ref< vl::TriangleIteratorAbstract > | |
| Cvl::ref< vl::UIEventListener > | |
| Cvl::ref< vl::Uniform > | |
| Cvl::ref< vl::UniformSet > | |
| Cvl::ref< vl::VectorGraphics > | |
| Cvl::ref< vl::Viewport > | |
| Cvl::ref< vl::VirtualDirectory > | |
| Cvl::ref< vl::VirtualFile > | |
| Cvl::ref< vl::Volume > | |
| Cvl::ref< vl::VolumeInfo > | |
| Cvl::ref< vl::WriteCallback > | |
| Cvl::ref< vl::ZippedFile > | |
| Cvl::ref< vl::ZippedFileInfo > | |
| Cvl::ref< vlX::ClassWrapper > | |
| Cvl::ref< vlX::Registry > | |
| Cvl::ref< vlX::VLTTokenizer > | |
| Cvl::ref< vlX::VLXStructure > | |
| Cvl::ref< vlX::VLXTaggedValue > | |
| Cvl::ref< WFInfo > | |
| ►Cstd::vector< T > | STL class |
| Cvl::Say | A simple String formatting class |
| Cvl::Vector2< float > | |
| Cvl::Vector2< int > | |
| Cvl::Vector3< float > | |
| Cvl::Vector3< int > | |
| Cvl::Vector4< double > | |
| Cvl::Vector4< float > | |
| Cvl::Vector4< int > | |
| Cvl::Vector4< unsigned int > | |
| Cvl::A3DSLoader | Loads an Autodesk 3DS file and generates a vector of A3DSObject and A3DSMaterial objects |
| Cvl::A3DSMaterial | Material in a 3DS file |
| Cvl::A3DSMaterialFaceMapping | Material/face mapping in a 3DS file |
| Cvl::A3DSObject | Object in a 3DS file |
| Cvl::A3DSTexture | Texture in a 3DS file |
| Cvl::A3DSTriFace | Triangle in a 3DS file |
| Cvl::A3DSVertex | Vertex in a 3DS file |
| Cvl::AABB | Implements an axis-aligned bounding box using vl::real precision |
| Cvl::AdjacencyExtractor | |
| Cvl::AtomInfo | Encapsulates information regarding an atom type |
| Cvl::CRC32CheckSum | Computes the a CRC32 checksum of a given buffer or VirtualFile |
| Cvl::Dae::Vert | COLLADA vertex |
| Cvl::DaeLoader | COLLADA loader |
| Cvl::degree | Simple class representing quantities in degrees, converts automatically to vl::radian and real |
| Cvl::EdgeExtractor::Edge | A single edge as extracted from the EdgeExtractor class |
| Cvl::Flags< T_FlagEnum > | Simple class to manage flags in a type safe manner |
| Cvl::half | Represents an half-precision floating point value |
| Cvl::IMutex | An interface to implement simple platform-independent mutexes used to protect critical sections |
| ►Cvl::IVertexAttribSet | Abstract interface to manipulate OpenGL's vertex attribute arrays |
| ►Cvl::Geometry | Renderable that implements a polygonal mesh made of polygons, lines and points |
| Cvl::BezierSurface | Implements a Geometry that is capable of visualizing multiple bicubic Bézier patches (see BezierPatch) |
| Cvl::MarchingCubes | An efficient implementation of the Marching Cubes algorithm |
| Cvl::Matrix2< T_Scalar > | The Matrix2 class is a template class that implements a generic 2x2 matrix, see also vl::dmat2, vl::fmat2, vl::umat2, vl::imat2 |
| Cvl::Matrix3< T_Scalar > | The Matrix3 class is a template class that implements a generic 3x3 matrix, see also vl::dmat3, vl::fmat3, vl::umat3, vl::imat3 |
| Cvl::Matrix4< T_Scalar > | The Matrix4 class is a template class that implements a generic 4x4 matrix, see also vl::dmat4, vl::fmat4, vl::umat4, vl::imat4 |
| Cvl::MD5CheckSum | Computes the MD5 of a given buffer or VirtualFile |
| ►Cvl::Object | The base class for all the reference counted objects |
| ►Cvl::BufferedStream< char, 128 *1024 > | |
| CvlX::VLTTokenizer | Tokenizer used to parse VLT files |
| ►Cvl::BufferedStream< unsigned char, 128 *1024 > | |
| Cvl::TextStream | Can be used to conveniently read or parse utf8-encoded text files |
| ►Cvl::Collection< Actor > | |
| Cvl::ActorCollection | Defined as a simple subclass of Collection<Actor>, see Collection for more information |
| ►Cvl::Collection< Shader > | |
| Cvl::ShaderPasses | A sequence of Shader objects each of which represent a rendering pass |
| Cvl::Collection< vl::ActorEventCallback > | |
| Cvl::Collection< vl::DrawCall > | |
| Cvl::Collection< vl::DrawPixels::Pixels > | |
| Cvl::Collection< vl::Renderer > | |
| Cvl::Collection< vl::RenderEventCallback > | |
| Cvl::Collection< vl::RenderingAbstract > | |
| Cvl::Collection< vl::SceneManager > | |
| Cvl::Collection< vl::VectorGraphics > | |
| Cvl::Collection< vl::VolumeInfo > | |
| Cvl::NaryQuickMap< EEnable, EEnable, EN_EnableCount > | |
| Cvl::NaryQuickMap< ERenderState, vl::RenderStateSlot, RS_RenderStateCount > | |
| Cvl::Actor | Associates a Renderable object to an Effect and Transform |
| ►Cvl::ActorEventCallback | Defines a callback object to react to Actor-related events |
| Cvl::DepthSortCallback | DepthSortCallback sorts the primitives of the Geometry bound to the Actor in which the callback is installed |
| Cvl::EdgeUpdateCallback | Updates at every frame the edges of an Actor for the purpose of edge-enhancement |
| Cvl::MorphingCallback | Implements a simple morphing animation mechanism using the GPU acceleration where available |
| Cvl::RaycastVolume | A ActorEventCallback used to render a volume using GPU raycasting |
| Cvl::SlicedVolume | A ActorEventCallback used to render a volume using viewport aligned slices |
| ►Cvl::ActorTreeAbstract | Implements the interface of a generic tree containing Actors in its nodes |
| Cvl::ActorKdTree | ActorKdTree class extends the ActorTreeAbstract class implementing a space partitioning scheme based on a Kd-Tree |
| Cvl::ActorTree | Implements a generic tree whose nodes contain Actors |
| ►Cvl::ArrayAbstract | Defines an abstract interface to conveniently manipulate data stored in a BufferObject |
| ►Cvl::Array< bvec2, GLbyte, 2, GL_BYTE > | |
| Cvl::ArrayByte2 | An array of vl::bvec2 |
| ►Cvl::Array< bvec3, GLbyte, 3, GL_BYTE > | |
| Cvl::ArrayByte3 | An array of vl::bvec3 |
| ►Cvl::Array< bvec4, GLbyte, 4, GL_BYTE > | |
| Cvl::ArrayByte4 | An array of vl::bvec4 |
| ►Cvl::Array< dvec2, GLdouble, 2, GL_DOUBLE > | |
| Cvl::ArrayDouble2 | An array of vl::dvec2 |
| ►Cvl::Array< dvec3, GLdouble, 3, GL_DOUBLE > | |
| Cvl::ArrayDouble3 | An array of vl::dvec3 |
| ►Cvl::Array< dvec4, GLdouble, 4, GL_DOUBLE > | |
| Cvl::ArrayDouble4 | An array of vl::dvec4 |
| ►Cvl::Array< fvec2, GLfloat, 2, GL_FLOAT > | |
| Cvl::ArrayFloat2 | An array of vl::fvec2 |
| ►Cvl::Array< fvec3, GLfloat, 3, GL_FLOAT > | |
| Cvl::ArrayFloat3 | An array of vl::fvec3 |
| ►Cvl::Array< fvec4, GLfloat, 4, GL_FLOAT > | |
| Cvl::ArrayFloat4 | An array of vl::fvec4 |
| ►Cvl::Array< GLbyte, GLbyte, 1, GL_BYTE > | |
| Cvl::ArrayByte1 | An array of GLbyte |
| ►Cvl::Array< GLdouble, GLdouble, 1, GL_DOUBLE > | |
| Cvl::ArrayDouble1 | An array of GLdouble |
| ►Cvl::Array< GLfloat, GLfloat, 1, GL_FLOAT > | |
| Cvl::ArrayFloat1 | An array of GLfloat |
| ►Cvl::Array< GLint, GLint, 1, GL_INT > | |
| Cvl::ArrayInt1 | An array of GLint |
| ►Cvl::Array< GLint, GLint, 1, GL_INT_2_10_10_10_REV > | |
| Cvl::ArrayInt_2_10_10_10_REV1 | An array of GL_INT_2_10_10_10_REV |
| ►Cvl::Array< GLshort, GLshort, 1, GL_SHORT > | |
| Cvl::ArrayShort1 | An array of GLshort |
| ►Cvl::Array< GLubyte, GLubyte, 1, GL_UNSIGNED_BYTE > | |
| Cvl::ArrayUByte1 | An array of GLubyte |
| ►Cvl::Array< GLuint, GLuint, 1, GL_FIXED > | |
| Cvl::ArrayFixed1 | An array of GL_FIXED |
| ►Cvl::Array< GLuint, GLuint, 1, GL_UNSIGNED_INT > | |
| Cvl::ArrayUInt1 | An array of GLuint |
| ►Cvl::Array< GLuint, GLuint, 1, GL_UNSIGNED_INT_2_10_10_10_REV > | |
| Cvl::ArrayUInt_2_10_10_10_REV1 | An array of GL_UNSIGNED_INT_2_10_10_10_REV |
| ►Cvl::Array< GLushort, GLushort, 1, GL_UNSIGNED_SHORT > | |
| Cvl::ArrayUShort1 | An array of GLushort |
| ►Cvl::Array< half, half, 1, GL_HALF_FLOAT > | |
| Cvl::ArrayHFloat1 | An array of GL_HALF_FLOAT |
| ►Cvl::Array< hvec2, half, 2, GL_HALF_FLOAT > | |
| Cvl::ArrayHFloat2 | A 2d array of GL_HALF_FLOAT vectors |
| ►Cvl::Array< hvec3, half, 3, GL_HALF_FLOAT > | |
| Cvl::ArrayHFloat3 | A 3d array of GL_HALF_FLOAT vectors |
| ►Cvl::Array< hvec4, half, 4, GL_HALF_FLOAT > | |
| Cvl::ArrayHFloat4 | A 4d array of GL_HALF_FLOAT vectors |
| ►Cvl::Array< ivec2, GLint, 2, GL_INT > | |
| Cvl::ArrayInt2 | An array of vl::ivec2 |
| ►Cvl::Array< ivec2, GLint, 2, GL_INT_2_10_10_10_REV > | |
| Cvl::ArrayInt_2_10_10_10_REV2 | A 2d array of GL_INT_2_10_10_10_REV vectors |
| ►Cvl::Array< ivec3, GLint, 3, GL_INT > | |
| Cvl::ArrayInt3 | An array of vl::ivec3 |
| ►Cvl::Array< ivec3, GLint, 3, GL_INT_2_10_10_10_REV > | |
| Cvl::ArrayInt_2_10_10_10_REV3 | A 3d array of GL_INT_2_10_10_10_REV vectors |
| ►Cvl::Array< ivec4, GLint, 4, GL_INT > | |
| Cvl::ArrayInt4 | An array of vl::ivec4 |
| ►Cvl::Array< ivec4, GLint, 4, GL_INT_2_10_10_10_REV > | |
| Cvl::ArrayInt_2_10_10_10_REV4 | A 4d array of GL_INT_2_10_10_10_REV vectors |
| ►Cvl::Array< svec2, GLshort, 2, GL_SHORT > | |
| Cvl::ArrayShort2 | An array of vl::svec2 |
| ►Cvl::Array< svec3, GLshort, 3, GL_SHORT > | |
| Cvl::ArrayShort3 | An array of vl::svec3 |
| ►Cvl::Array< svec4, GLshort, 4, GL_SHORT > | |
| Cvl::ArrayShort4 | An array of vl::svec4 |
| ►Cvl::Array< ubvec2, GLubyte, 2, GL_UNSIGNED_BYTE > | |
| Cvl::ArrayUByte2 | An array of vl::ubvec2 |
| ►Cvl::Array< ubvec3, GLubyte, 3, GL_UNSIGNED_BYTE > | |
| Cvl::ArrayUByte3 | An array of vl::ubvec3 |
| ►Cvl::Array< ubvec4, GLubyte, 4, GL_UNSIGNED_BYTE > | |
| Cvl::ArrayUByte4 | An array of vl::ubvec4 |
| ►Cvl::Array< usvec2, GLushort, 2, GL_UNSIGNED_SHORT > | |
| Cvl::ArrayUShort2 | An array of vl::usvec2 |
| ►Cvl::Array< usvec3, GLushort, 3, GL_UNSIGNED_SHORT > | |
| Cvl::ArrayUShort3 | An array of vl::usvec3 |
| ►Cvl::Array< usvec4, GLushort, 4, GL_UNSIGNED_SHORT > | |
| Cvl::ArrayUShort4 | An array of vl::usvec4 |
| ►Cvl::Array< uvec2, GLuint, 2, GL_FIXED > | |
| Cvl::ArrayFixed2 | An array 2d GL_FIXED vectors |
| ►Cvl::Array< uvec2, GLuint, 2, GL_UNSIGNED_INT > | |
| Cvl::ArrayUInt2 | An array of vl::uvec2 |
| ►Cvl::Array< uvec2, GLuint, 2, GL_UNSIGNED_INT_2_10_10_10_REV > | |
| Cvl::ArrayUInt_2_10_10_10_REV2 | A 2d array of GL_UNSIGNED_INT_2_10_10_10_REV vectors |
| ►Cvl::Array< uvec3, GLuint, 3, GL_FIXED > | |
| Cvl::ArrayFixed3 | An array 3d GL_FIXED vectors |
| ►Cvl::Array< uvec3, GLuint, 3, GL_UNSIGNED_INT > | |
| Cvl::ArrayUInt3 | An array of vl::uvec3 |
| ►Cvl::Array< uvec3, GLuint, 3, GL_UNSIGNED_INT_2_10_10_10_REV > | |
| Cvl::ArrayUInt_2_10_10_10_REV3 | A 3d array of GL_UNSIGNED_INT_2_10_10_10_REV vectors |
| ►Cvl::Array< uvec4, GLuint, 4, GL_FIXED > | |
| Cvl::ArrayFixed4 | An array 4d GL_FIXED vectors |
| ►Cvl::Array< uvec4, GLuint, 4, GL_UNSIGNED_INT > | |
| Cvl::ArrayUInt4 | An array of vl::uvec4 |
| ►Cvl::Array< uvec4, GLuint, 4, GL_UNSIGNED_INT_2_10_10_10_REV > | |
| Cvl::ArrayUInt_2_10_10_10_REV4 | A 4d array of GL_UNSIGNED_INT_2_10_10_10_REV vectors |
| Cvl::Array< T_VectorType, T_Scalar, T_GL_Size, T_GL_Type > | The Array class is a template array used to conveniently manipulate data stored in a BufferObject |
| Cvl::Atom | Atom to be used with the Molecule class |
| Cvl::BezierPatch | Defines one or more concatenated bicubic Bézier patches to be used with the BezierSurface class |
| Cvl::Bond | Bond to be used with the Molecule class |
| ►Cvl::Buffer | Implements a buffer whose storage is in local memory |
| Cvl::BufferObject | Buffer that can upload its data on the GPU memory |
| Cvl::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 |
| ►Cvl::Camera | Represents a virtual camera defining, among other things, the point of view from which scenes can be rendered |
| Cvl::CalibratedCamera | Calibrated camera for augmented reality |
| Cvl::CatmullRomInterpolator< T > | The LinearInterpolator class is a template class that implements Catmull-Rom spline interpolation |
| Cvl::Collection< T > | It's basically an std::vector for Objects that is itself an Object so it can be reference counted and passed around with ease |
| Cvl::Dae::ColorOrTexture | COLLADA color or texture input |
| Cvl::Dae::Effect | COLLADA effect |
| Cvl::Dae::Input | COLLADA input stream |
| Cvl::Dae::Material | COLLADA material |
| Cvl::Dae::Mesh | COLLADA mesh |
| Cvl::Dae::NewParam | COLLADA newparam |
| Cvl::Dae::Node | COLLADA node |
| Cvl::Dae::Primitive | COLLADA primitive |
| Cvl::Dae::Sampler2D | COLLADA sampler2D |
| Cvl::Dae::Source | COLLADA data source |
| Cvl::Dae::Surface | COLLADA surface |
| Cvl::Dae::TechniqueCOMMON | COLLADA common technique |
| ►Cvl::DrawCall | The base class of DrawArrays, DrawElements, MultiDrawElements and DrawRangeElements |
| Cvl::DrawArrays | Wraps the OpenGL function glDrawArrays() |
| ►Cvl::DrawElementsBase | Base interface for all DrawElements* sub classes |
| ►Cvl::DrawElements< ArrayUByte1 > | |
| Cvl::DrawElementsUByte | See DrawElements |
| ►Cvl::DrawElements< ArrayUInt1 > | |
| Cvl::DrawElementsUInt | See DrawElements |
| ►Cvl::DrawElements< ArrayUShort1 > | |
| Cvl::DrawElementsUShort | See DrawElements |
| Cvl::DrawElements< arr_type > | Wrapper for the OpenGL function glDrawElements() |
| ►Cvl::DrawRangeElementsBase | Base interface for all DrawRangeElements* sub classes |
| ►Cvl::DrawRangeElements< ArrayUByte1 > | |
| Cvl::DrawRangeElementsUByte | See DrawRangeElements |
| ►Cvl::DrawRangeElements< ArrayUInt1 > | |
| Cvl::DrawRangeElementsUInt | See DrawRangeElements |
| ►Cvl::DrawRangeElements< ArrayUShort1 > | |
| Cvl::DrawRangeElementsUShort | See DrawRangeElements |
| Cvl::DrawRangeElements< arr_type > | Wrapper for the OpenGL function glDrawRangeElements() |
| ►Cvl::MultiDrawElementsBase | Base interface for all MultiDrawElements* sub classes |
| ►Cvl::MultiDrawElements< ArrayUByte1 > | |
| Cvl::MultiDrawElementsUByte | See MultiDrawElements |
| ►Cvl::MultiDrawElements< ArrayUInt1 > | |
| Cvl::MultiDrawElementsUInt | See MultiDrawElements |
| ►Cvl::MultiDrawElements< ArrayUShort1 > | |
| Cvl::MultiDrawElementsUShort | See MultiDrawElements |
| Cvl::MultiDrawElements< arr_type > | Wrapper for the OpenGL function glMultiDrawElements() |
| Cvl::DrawPixels::Pixels | Represents a bitmap to be drawn on the screen |
| Cvl::EdgeExtractor | Extracts the edges from one or more Geometry objects |
| Cvl::Effect | Defines the sequence of Shader objects used to render an Actor |
| Cvl::EnableSet | A set of enables managed by Shader |
| Cvl::Extrusion | Generates a Geometry extruding a silhouette along a path |
| Cvl::Extrusions | Generates a Geometry extruding a silhouette along a path |
| ►Cvl::FBOAbstractAttachment | Abstract class that represents a framebuffer object attachment to be used with FramebufferObject |
| ►Cvl::FBOAbstractTextureAttachment | Base class for all the framebuffer texture attachments (see also FramebufferObject) |
| Cvl::FBOTexture1DAttachment | A 1D texture renderbuffer to be attached to a FramebufferObject (wraps glFramebufferTexture1D()) |
| Cvl::FBOTexture2DAttachment | A 2D texture renderbuffer to be attached to a FramebufferObject (wraps glFramebufferTexture2D()) |
| Cvl::FBOTexture3DAttachment | A 3D texture renderbuffer to be attached to a FramebufferObject (wraps glFramebufferTexture3D()) |
| Cvl::FBOTextureAttachment | A texture renderbuffer to be attached to a FramebufferObject (wraps glFramebufferTexture()) |
| Cvl::FBOTextureLayerAttachment | A texture layer renderbuffer to be attached to a FramebufferObject (wraps glFramebufferTextureLayer()) |
| ►Cvl::FBORenderbufferAttachment | Abstract class that represents a framebuffer renderbuffer attachment, that is, a non-texture fbo attachment (wraps glFramebufferRenderbuffer()) |
| Cvl::FBOColorBufferAttachment | A color renderbuffer to be attached to a FramebufferObject |
| Cvl::FBODepthBufferAttachment | A depth renderbuffer to be attached to a FramebufferObject |
| Cvl::FBODepthStencilBufferAttachment | A depth+stencil renderbuffer to be attached to a FramebufferObject |
| Cvl::FBOStencilBufferAttachment | A stencil renderbuffer to be attached to a FramebufferObject |
| Cvl::FileSystem | Manages multiple VirtualDirectory objects |
| Cvl::Font | A font to be used with a Text renderable |
| Cvl::FontManager | Keeps a map associating a font path, size and smoothing flag to a Font object |
| Cvl::FramebufferObject | Implements a framebuffer object to be used as a rendering target as specified by the ARB_framebuffer_object extension |
| Cvl::Frustum | A set of planes defining a frustum used for culling purposes (frustum culling) |
| Cvl::GlobalSettings | Global application settings controlling how Visualization Library behaves |
| ►Cvl::GLSLShader | For internal use only |
| Cvl::GLSLFragmentShader | Wraps a GLSL fragment shader to be bound to a GLSLProgram: the shader this shader will run on the programmable fragment processor |
| Cvl::GLSLGeometryShader | Wraps a GLSL geometry shader to be bound to a GLSLProgram: the shader this shader will run on the programmable geometry processor |
| Cvl::GLSLTessControlShader | Wraps a GLSL tessellation control shader to be bound to a GLSLProgram: the shader this shader will run on the programmable tessellation processor in the control stage |
| Cvl::GLSLTessEvaluationShader | Wraps a GLSL tessellation evaluation shader to be bound to a GLSLProgram: this shader will run on the programmable tessellation processor in the evaluation stage |
| Cvl::GLSLVertexShader | Wraps a GLSL vertex shader to be bound to a GLSLProgram: the shader this shader will run on the programmable vertex processor |
| Cvl::Glyph | The Glyph associated to a character of a given Font |
| ►Cvl::Image | Implements a generic 1d, 2d, 3d and cubemap image that can have mipmaps |
| Cvl::ImagePBO | Represents a vl::Image with an associated Pixel Buffer Object |
| Cvl::IndexIterator | Wraps a IndexIteratorAbstract to iterate over the indices of a DrawCall |
| ►Cvl::IndexIteratorAbstract | Abstract class used as base for all the index iterators specializations |
| Cvl::IndexIteratorDrawArrays | Index iterator operating used by DrawArrays |
| Cvl::IndexIteratorElements< TArray > | Index iterator operating over DrawElements, DrawRangeElements and MultiDrawElements |
| ►Cvl::Interpolator | Abstract class for all the interpolators |
| ►Cvl::InterpolatorDouble | Abstract class that interpolates double values |
| Cvl::CatmullRomInterpolatorDouble | Interpolates double values using a CatmullRomInterpolator |
| Cvl::LinearInterpolatorDouble | Interpolates double values using a LinearInterpolator |
| ►Cvl::InterpolatorDVec2 | Abstract class that interpolates vl::dvec2 values |
| Cvl::CatmullRomInterpolatorDVec2 | Interpolates dvec2 values using a CatmullRomInterpolator |
| Cvl::LinearInterpolatorDVec2 | Interpolates dvec2 values using a LinearInterpolator |
| ►Cvl::InterpolatorDVec3 | Abstract class that interpolates vl::dvec3 values |
| Cvl::CatmullRomInterpolatorDVec3 | Interpolates dvec3 values using a CatmullRomInterpolator |
| Cvl::LinearInterpolatorDVec3 | Interpolates dvec3 values using a LinearInterpolator |
| ►Cvl::InterpolatorDVec4 | Abstract class that interpolates vl::dvec4 values |
| Cvl::CatmullRomInterpolatorDVec4 | Interpolates dvec4 values using a CatmullRomInterpolator |
| Cvl::LinearInterpolatorDVec4 | Interpolates dvec4 values using a LinearInterpolator |
| ►Cvl::InterpolatorFloat | Abstract class that interpolates float values |
| Cvl::CatmullRomInterpolatorFloat | Interpolates float values using a CatmullRomInterpolator |
| Cvl::LinearInterpolatorFloat | Interpolates float values using a LinearInterpolator |
| ►Cvl::InterpolatorFVec2 | Abstract class that interpolates vl::fvec2 values |
| Cvl::CatmullRomInterpolatorFVec2 | Interpolates fvec2 values using a CatmullRomInterpolator |
| Cvl::LinearInterpolatorFVec2 | Interpolates fvec2 values using a LinearInterpolator |
| ►Cvl::InterpolatorFVec3 | Abstract class that interpolates vl::fvec3 values |
| Cvl::CatmullRomInterpolatorFVec3 | Interpolates fvec3 values using a CatmullRomInterpolator |
| Cvl::LinearInterpolatorFVec3 | Interpolates fvec3 values using a LinearInterpolator |
| ►Cvl::InterpolatorFVec4 | Abstract class that interpolates vl::fvec4 values |
| Cvl::CatmullRomInterpolatorFVec4 | Interpolates fvec4 values using a CatmullRomInterpolator |
| Cvl::LinearInterpolatorFVec4 | Interpolates fvec4 values using a LinearInterpolator |
| Cvl::KeyValues | A set of key/value pairs usually used to associate generic information, tags, attributes etc. to another class |
| Cvl::LinearInterpolator< T > | The LinearInterpolator class is a template class that implements linear interpolation |
| ►Cvl::LoadCallback | Defines an operation to be exectued to a ResourceDatabase as soon as its loaded, see also LoadWriterManager, WriteCallback |
| Cvl::GeometryLoadCallback | Defines a set of actions to be executed to a Geometry as soon as it is loaded |
| Cvl::LoadWriterDae::LoadOptions | Loading options used by LoadWriterDae and DaeLoader |
| Cvl::LoadWriterManager | Loads and writes resources using the registered ResourceLoadWriter objects |
| ►Cvl::LODEvaluator | Abstract class to compute the appropriate LOD of an Actor or Effect |
| Cvl::DistanceLODEvaluator | A LODEvaluator that computes the appropriate LOD based on the distance of an Actor from the Camera |
| Cvl::PixelLODEvaluator | A LODEvaluator that computes the appropriate LOD based on the approximate 2d area that an Actor covers on the screen |
| ►Cvl::Log | Utility class to generate logs |
| Cvl::StandardLog | Outputs the log messages on the stdout device and optionally also on a specified file |
| Cvl::MersenneTwister | |
| Cvl::Molecule | Used to manage and render 3D molecular structures |
| Cvl::NaryQuickMap< KeyType, ValueType, MaxMapType > | Simple map used to add, remove, iterate, clear elements efficiently (all O(1)) |
| Cvl::ObjMaterial | Represents a Wavefront OBJ material as loaded from an MTL file. See also ObjLoader |
| Cvl::ObjMesh | Represents a Wavefront OBJ mesh. See also ObjLoader |
| ►Cvl::OpenGLContext | Represents an OpenGL context, possibly a widget or a pbuffer, which can also respond to keyboard, mouse or system events |
| CvlEGL::EGLWindow | EGLContext that can be used as a top or child window |
| CvlGLFW::GLFWWindow | Implements an OpenGLContext using the GLFW API |
| CvlGLUT::GLUTWindow | Implements an OpenGLContext using the GLUT API |
| CvlQt4::Qt4Widget | Implements an OpenGLContext using the Qt4 API |
| CvlQt5::Qt5Widget | Implements an OpenGLContext using the Qt5 API |
| CvlQt6::Qt6Widget | Implements an OpenGLContext using the Qt6 API |
| CvlSDL::SDLWindow | Implements an OpenGLContext using the SDL API |
| ►CvlWin32::Win32Context | Implements an OpenGLContext using the Win32 API |
| CvlMFC::MDIWindow | MFC CView with the functionalities of a Win32Context (experimental) |
| CvlMFC::MFCWindow | MFC CWnd with the functionalities of a Win32Context |
| CvlWin32::Win32Window | Win32Context that can be used as a top or child window |
| CvlWX::WXGLCanvas | Implements a vl::OpenGLContext using the wxWidgets library |
| Cvl::PatchParameter | Wrapper of glPatchParameter(), specifies the parameters for patch primitives, used by vl::DrawCall::setPatchParameter() |
| Cvl::Plane | Defines a plane using a normal and an origin |
| Cvl::PlyLoader::PlyElement | Used by PlyLoader |
| ►Cvl::PlyLoader::PlyPropertyAbstract | Used by PlyLoader |
| Cvl::PlyLoader::PlyScalar | Used by PlyLoader |
| Cvl::PlyLoader::PlyScalarList | Used by PlyLoader |
| Cvl::PolygonSimplifier | Reduces the amount of polygons present in a Geometry using a quadric error metric |
| Cvl::Portal | A planar convex polygon used to define the visibility from one Sector to another |
| Cvl::ProjViewTransfCallback | Callback class to update the state of the projection, view, transform and normal matrices of a GLSLProgram or fixed function pipeline |
| Cvl::Random | Cryptographic random number generator |
| ►Cvl::RayIntersection | The RayIntersection encapsulates all the information relative to a Ray/Actor intersection |
| Cvl::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 |
| Cvl::RayIntersector | Used to detect the intersection points between a Ray and a set of Actor[s] |
| ►Cvl::Renderable | An abstract class that represents all the objects that can be rendered |
| Cvl::Clear | Renderable used to clear the whole or a portion of the color, stencil or depth buffer |
| Cvl::CoreText | Experimental |
| Cvl::DrawPixels | Wraps the OpenGL function glDrawPixels() |
| Cvl::Geometry | Renderable that implements a polygonal mesh made of polygons, lines and points |
| Cvl::Text | A Renderable that renders text with a given Font |
| ►Cvl::RendererAbstract | Base class providing all the basic funtionalities of a Renderer |
| ►Cvl::Renderer | Executes the actual rendering on the given RenderQueue |
| Cvl::EdgeRenderer | Implements a special Renderer that automatically extracts and renders the edges of the objects in the scene |
| Cvl::OcclusionCullRenderer | Wraps a Renderer performing occlusion culling acceleration |
| ►Cvl::RenderEventCallback | An abstract class used to react to rendering events |
| Cvl::BlitFramebuffer | A RenderEventCallback that can be used to copy pixels from a framebuffer to another as described in GL_EXT_framebuffer_blit |
| ►Cvl::CopyTexSubImage | Wrapper class of the OpenGL function glCopyTexSubImage |
| Cvl::CopyTexSubImage1D | Wraps glCopyTexSubImage1D, see also CopyTexSubImage |
| Cvl::CopyTexSubImage2D | Wraps glCopyTexSubImage2D, see also CopyTexSubImage. To be used also for 1D array textures |
| Cvl::CopyTexSubImage3D | Wraps glCopyTexSubImage3D, see also CopyTexSubImage. To be used also for 2D array textures |
| Cvl::ReadPixels | A RenderEventCallback that copyes a rectangular pixel area from a source buffer to an Image at the end of a rendering |
| ►Cvl::RenderingAbstract | Base of all the rendering related sub-classes |
| Cvl::Rendering | Collects all the information to perform the rendering of a scene |
| Cvl::RenderingTree | Organizes a set of renderings into an N-ary tree |
| Cvl::RenderQueue | Collects a list of RenderToken objects to be sorted and rendered |
| ►Cvl::RenderQueueSorter | Abstract base class of all the algorithms used to sort a set of RenderToken |
| Cvl::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 |
| Cvl::RenderQueueSorterBasic | Sorts the RenderTokens by their Effect rank -> Actor rank -> Shader pointer -> Renderable pointer |
| Cvl::RenderQueueSorterByRenderable | Sorts the RenderTokens by their Renderable pointer |
| Cvl::RenderQueueSorterByShader | Sorts the RenderTokens by their Shader pointer |
| Cvl::RenderQueueSorterOcclusion | Implements a RenderQueueSorter that maximizes the z-buffer test efficiency as much as possible |
| Cvl::RenderQueueSorterStandard | Implements the default RenderQueueSorter |
| ►Cvl::RenderState | Base class for most of the OpenGL render state wrapper classes |
| ►Cvl::RenderStateIndexed | Base class for those render states which have more than one binding points like lights, clipping planes and texture unit states |
| Cvl::ClipPlane | Wraps the OpenGL function glClipPlane() |
| Cvl::Light | Wraps the OpenGL function glLight() |
| Cvl::TexEnv | RenderState wrapping the OpenGL function glTexEnv(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexEnv.xml for more information |
| Cvl::TexGen | RenderState wrapping the OpenGL function glTexGen(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexGen.xml for more information |
| Cvl::TextureImageUnit | Associates a Texture object to an OpenGL texture unit |
| Cvl::TextureMatrix | Uses a 4x4 matrix to transform the texture coordinates of a texture unit |
| Cvl::VertexAttrib | RenderState wrapping the OpenGL function glVertexAttrib(), see also http://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml for more information |
| ►Cvl::RenderStateNonIndexed | Base class for those render states which have only one binding point (the vast majority) |
| Cvl::AlphaFunc | RenderState wrapping the OpenGL function glAlphaFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glAlphaFunc.xml for more information |
| Cvl::BlendColor | RenderState wrapping the OpenGL function glBlendColor(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendColor.xml for more information |
| Cvl::BlendEquation | RenderState wrapping 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 |
| Cvl::BlendFunc | RenderState wrapping the OpenGL function glBlendFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glBlendFunc.xml for more information |
| Cvl::Color | RenderState wrapping the OpenGL function glColor(), see also http://www.opengl.org/sdk/docs/man/xhtml/glColor.xml for more information |
| Cvl::ColorMask | RenderState wrapping the OpenGL function glColorMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glColorMask.xml for more information |
| Cvl::CullFace | RenderState wrapping the OpenGL function glCullFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glCullFace.xml for more information |
| Cvl::DepthFunc | RenderState wrapping the OpenGL function glDepthFunc(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthFunc.xml for more information |
| Cvl::DepthMask | RenderState wrapping the OpenGL function glDepthMask(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthMask.xml for more information |
| Cvl::DepthRange | RenderState wrapping the OpenGL function glDepthRange(), see also http://www.opengl.org/sdk/docs/man/xhtml/glDepthRange.xml for more information |
| Cvl::Fog | RenderState wrapping the OpenGL function glFog(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFog.xml for more information |
| Cvl::FrontFace | RenderState wrapping the OpenGL function glFrontFace(), see also http://www.opengl.org/sdk/docs/man/xhtml/glFrontFace.xml for more information |
| Cvl::GLSLProgram | Wraps a GLSL program to which you can bind vertex, fragment and geometry shaders |
| Cvl::Hint | RenderState wrapping the OpenGL function glHint(), see also http://www.opengl.org/sdk/docs/man/xhtml/glHint.xml for more information |
| Cvl::LightModel | RenderState wrapping the OpenGL function glLightModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLightModel.xml for more information |
| Cvl::LineStipple | RenderState wrapping the OpenGL function glLineStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineStipple.xml for more information |
| Cvl::LineWidth | RenderState wrapping the OpenGL function glLineWidth(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLineWidth.xml for more information |
| Cvl::LogicOp | RenderState wrapping the OpenGL function glLogicOp(), see also http://www.opengl.org/sdk/docs/man/xhtml/glLogicOp.xml for more information |
| Cvl::Material | RenderState wrapping 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 |
| Cvl::Normal | RenderState wrapping the OpenGL function glNormal(), see also http://www.opengl.org/sdk/docs/man/xhtml/glNormal.xml for more information |
| Cvl::PixelTransfer | RenderState wrapping the OpenGL function glPixelTransfer(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPixelTransfer.xml for more information |
| Cvl::PointParameter | RenderState wrapping the OpenGL function glPointParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointParameter.xml for more information |
| Cvl::PointSize | RenderState wrapping the OpenGL function glPointSize(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPointSize.xml for more information |
| Cvl::PolygonMode | RenderState wrapping the OpenGL function glPolygonMode(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonMode.xml for more information |
| Cvl::PolygonOffset | RenderState wrapping the OpenGL function glPolygonOffset(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonOffset.xml for more information |
| Cvl::PolygonStipple | RenderState wrapping the OpenGL function glPolygonStipple(), see also http://www.opengl.org/sdk/docs/man/xhtml/glPolygonStipple.xml for more information |
| Cvl::SampleCoverage | RenderState wrapping the OpenGL function glSampleCoverage(), see also http://www.opengl.org/sdk/docs/man/xhtml/glSampleCoverage.xml for more information |
| Cvl::SecondaryColor | RenderState wrapping the OpenGL function glSecondaryColor(), see also http://www.opengl.org/sdk/docs/man/xhtml/glSecondaryColor.xml for more information |
| Cvl::ShadeModel | RenderState wrapping the OpenGL function glShadeModel(), see also http://www.opengl.org/sdk/docs/man/xhtml/glShadeModel.xml for more information |
| Cvl::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 |
| Cvl::StencilMask | RenderState wrapping 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 |
| Cvl::StencilOp | RenderState wrapping 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 |
| Cvl::RenderStateSet | A set of RenderState objects managed by a Shader |
| Cvl::RenderToken | Internally used by the rendering engine |
| Cvl::ResourceDatabase | And manipulates a set of resources |
| ►Cvl::ResourceLoadWriter | Abstract class used to implement read/write support for one or more resource types |
| Cvl::LoadWriter3DS | ResourceLoadWriter capable of reading 3DS files |
| Cvl::LoadWriterAC3D | ResourceLoadWriter capable of reading AC3D files |
| Cvl::LoadWriterBMP | ResourceLoadWriter capable of reading BMP files |
| Cvl::LoadWriterDae | ResourceLoadWriter capable of reading COLLADA files |
| Cvl::LoadWriterDAT | ResourceLoadWriter capable of reading DAT files |
| Cvl::LoadWriterDDS | ResourceLoadWriter capable of reading DDS files |
| Cvl::LoadWriterDICOM | ResourceLoadWriter capable of reading DICOM files (.dcm, .dicom, .dic, .ima, .ph, .mag) using GDCM 2.0 library |
| Cvl::LoadWriterJPG | ResourceLoadWriter capable of reading JPG files |
| Cvl::LoadWriterMD2 | ResourceLoadWriter capable of reading MD2 files |
| Cvl::LoadWriterMHD | ResourceLoadWriter capable of reading MHD files |
| Cvl::LoadWriterOBJ | ResourceLoadWriter capable of reading OBJ files |
| Cvl::LoadWriterPLY | ResourceLoadWriter capable of reading PLY files |
| Cvl::LoadWriterPNG | ResourceLoadWriter capable of reading PNG files |
| Cvl::LoadWriterSTL | ResourceLoadWriter capable of reading STL files |
| Cvl::LoadWriterTGA | ResourceLoadWriter capable of reading TGA files |
| Cvl::LoadWriterTIFF | ResourceLoadWriter capable of reading TIFF files |
| CvlX::LoadWriterVLX | A vl::ResourceLoadWriter capable of reading Visualization Library's VLT and VLB files |
| ►Cvl::SceneManager | Base class for all the scene managers |
| ►Cvl::SceneManagerBVH< ActorKdTree > | |
| ►Cvl::SceneManagerActorKdTree | A SceneManagerBVH that implements its spatial partitioning strategy using an ActorKdTree |
| Cvl::Terrain | Implements a ActorKdTree-based terrain scene manager |
| ►Cvl::SceneManagerBVH< ActorTree > | |
| Cvl::SceneManagerActorTree | A SceneManagerBVH that implements its spatial partitioning strategy using an ActorTree |
| Cvl::SceneManagerBVH< T > | The SceneManagerBVH class implements the basic functionalities for bounding-volume-hierarchy based scene managers |
| Cvl::SceneManagerPortals | The SceneManagerPortals calss implements a portal-based hidden surface removal algorithm to efficently render highly occluded scenes |
| Cvl::SceneManagerVectorGraphics | SceneManager that contains VectorGraphics objects |
| Cvl::Scissor | Wraps the OpenGL function glScissor(), see http://www.opengl.org/sdk/docs/man/xhtml/glScissor.xml for more information |
| Cvl::Sector | Defines an area containg a set if Actors that is connected to other Sector[s] through its Portal[s] |
| Cvl::Sector::VisibilityCallback | A callback object called each time a Sector becomes visible through a Portal |
| Cvl::Shader | Manages most of the OpenGL rendering states responsible of the final aspect of the rendered objects |
| Cvl::ShaderAnimator | Callback object used to update/animate a Shader during the rendering |
| Cvl::ShaderNode | Used to conveniently manage complex hierarchies of Shader[s] |
| Cvl::StereoCamera | Utility class to setup a pair of left/right cameras for stereo rendering |
| Cvl::Tessellator | Tessellates a complex polygon defined by a set of outlines into a set of triangles that can be rendered by Visualization Library |
| Cvl::TexParameter | Wraps the OpenGL function glTexParameter(), see also http://www.opengl.org/sdk/docs/man/xhtml/glTexParameter.xml for more information |
| Cvl::Texture | Wraps an OpenGL texture object representing and managing all the supported texture types |
| Cvl::Texture::SetupParams | SetupParams wraps all the parameters needed to crate a Texture |
| Cvl::Time | Simple class to be used as a timer and to retrieve the current time and date |
| ►Cvl::Transform | Implements a 4x4 matrix transform used to define the position and orientation of an Actor |
| Cvl::Billboard | A Transform that aligns an Actor towards the camera |
| ►Cvl::TriangleIteratorAbstract | For internal use only |
| Cvl::TriangleIteratorDirect | For internal use only |
| ►Cvl::TriangleIteratorIndexed< TArray > | For internal use only |
| Cvl::TriangleIteratorMulti< TArray > | For internal use only |
| ►Cvl::UIEventListener | Listens to the events emitted by an OpenGLContext |
| Cvl::Applet | Utilitly UIEventListener that features a ghost manipulator, trackball manipulator, an FPS counter and a simple rendering pipeline |
| Cvl::FlatManipulator | This class lets you pan (translate) and zoom a 2D scene using the mouse |
| Cvl::GhostCameraManipulator | UIEventListener that controls the position and orientation of a Camera |
| Cvl::TrackballManipulator | This class lets you rotate a Camera or a Transform node using a virtual trackball |
| Cvl::Uniform | Wraps an OpenGL Shading Language uniform to be associated to a GLSLProgram (see vl::GLSLProgram documentation) |
| Cvl::UniformSet | A set of Uniform objects managed by a Shader |
| Cvl::VectorGraphics | Used in conjuction with SceneManagerVectorGraphics to generate and render 2D vector graphics |
| ►Cvl::VertexMapper | Generates a set of new vertices from the old one |
| Cvl::DoubleVertexRemover | Removes from a Geometry the vertices with the same attributes |
| Cvl::Viewport | Implements the viewport and clearing settings associated to a Camera |
| ►Cvl::VirtualDirectory | Abstact class representing a directory of files |
| Cvl::DiskDirectory | A VirtualDirectory that operates on reguar disk directories |
| Cvl::MemoryDirectory | A VirtualDirectory to manipulate directories stored in memory |
| Cvl::QtDirectory | A VirtualDirectory that uses Qt's QDir |
| Cvl::QtDirectory | A VirtualDirectory that uses Qt's QDir |
| Cvl::QtDirectory | A VirtualDirectory that uses Qt's QDir |
| Cvl::ZippedDirectory | A VirtualDirectory capable of reading files from a .zip file |
| ►Cvl::VirtualFile | An abstract class representing a file |
| Cvl::DiskFile | A VirtualFile that operates on regular disk files |
| Cvl::GZipCodec | VirtualFile that transparently encodes and decodes a stream of data using the GZip compression algorithm |
| Cvl::MemoryFile | A VirtualFile to manipulate files stored in memory |
| Cvl::QtFile | A VirtualFile that uses Qt's QFile |
| Cvl::QtFile | A VirtualFile that uses Qt's QFile |
| Cvl::QtFile | A VirtualFile that uses Qt's QFile |
| Cvl::ZippedFile | A VirtualFile used to read a file contained in a .zip archive |
| Cvl::Volume | Defines the volume data to be used with a MarchingCube object |
| Cvl::VolumeInfo | Defines the volume parameters to be used with a MarchingCube and Volume object |
| Cvl::VolumePlot | Generates a 3D plot with labels and isosurface. The isosurface is generated using the MarchingCubes algorithm |
| Cvl::WriteCallback | Defines an operation to be exectued to a ResourceDatabase just before it is written, see also LoadWriterManager, LoadCallback |
| Cvl::ZippedFileInfo | Collects the information about a ZippedFile |
| ►CvlX::ClassWrapper | Base cass for all class wrappers implementing the translation to/from its VLX representation |
| CvlX::VLXClassWrapper_Actor | VLX wrapper of vl::Actor |
| CvlX::VLXClassWrapper_ActorEventCallback | VLX wrapper of vl::DepthSortCallback |
| CvlX::VLXClassWrapper_Array | VLX wrapper of vl::Array |
| CvlX::VLXClassWrapper_Camera | VLX wrapper of vl::Camera |
| CvlX::VLXClassWrapper_ClipPlane | VLX wrapper of vl::ClipPlane |
| CvlX::VLXClassWrapper_Color | VLX wrapper of vl::Color |
| CvlX::VLXClassWrapper_DrawCall | VLX wrapper of vl::DrawCall and subclasses |
| CvlX::VLXClassWrapper_Effect | VLX wrapper of vl::Effect |
| CvlX::VLXClassWrapper_GLSLProgram | VLX wrapper of vl::GLSLProgram |
| CvlX::VLXClassWrapper_GLSLShader | VLX wrapper of vl::GLSLVertexShader, vl::GLSLFragmentShader, vl::GLSLGeometryShader, vl::GLSLTessControlShader, vl::GLSLTessEvaluationShader |
| CvlX::VLXClassWrapper_Light | VLX wrapper of vl::Light |
| CvlX::VLXClassWrapper_LODEvaluator | VLX wrapper of vl::DistanceLODEvaluator and vl::PixelLODEvaluator |
| CvlX::VLXClassWrapper_Material | VLX wrapper of vl::Material |
| CvlX::VLXClassWrapper_Normal | VLX wrapper of vl::Normal |
| CvlX::VLXClassWrapper_PatchParameter | VLX wrapper of vl::PatchParameter |
| ►CvlX::VLXClassWrapper_Renderable | VLX wrapper of vl::Renderable |
| CvlX::VLXClassWrapper_Geometry | VLX wrapper of vl::Geometry |
| CvlX::VLXClassWrapper_ResourceDatabase | VLX wrapper of vl::ResourceDatabase |
| CvlX::VLXClassWrapper_SecondaryColor | VLX wrapper of vl::SecondaryColor |
| CvlX::VLXClassWrapper_Shader | VLX wrapper of vl::Shader |
| CvlX::VLXClassWrapper_TexParameter | VLX wrapper of vl::TexParameter |
| CvlX::VLXClassWrapper_Texture | VLX wrapper of vl::Texture |
| CvlX::VLXClassWrapper_TextureImageUnit | VLX wrapper of vl::TextureImageUnit |
| CvlX::VLXClassWrapper_Transform | VLX wrapper of vl::Transform |
| CvlX::VLXClassWrapper_Uniform | VLX wrapper of vl::Uniform |
| CvlX::VLXClassWrapper_VertexAttrib | VLX wrapper of vl::VertexAttrib |
| CvlX::VLXClassWrapper_Viewport | VLX wrapper of vl::Viewport |
| ►CvlX::Parser | Base class for VLX parsers |
| CvlX::ParserVLB | Parses a VLT file translating it into a VLX hierarchy |
| CvlX::ParserVLT | Parses a VLT file translating it into a VLX hierarchy |
| CvlX::Registry | Registry of vl::ClassWrapper objects, used by vl::VLXSerializer, see also vl::defVLXRegistry() |
| ►CvlX::Visitor | Base class for all visitors visiting a VLX hierarchy |
| CvlX::VisitorExportToVLB | Translates a VLX hierarchy into VLB format writing to the provided VirtualFile |
| CvlX::VisitorExportToVLT | Translates a VLX hierarchy into VLT notation |
| CvlX::VisitorIDCounter | Counts the number of occurrencies of each ID |
| CvlX::VisitorLinker | Substitutes IDs into VLXStructures using the provided link map |
| CvlX::VisitorLinkMapper | Compiles the link-map which associates a VLXStructure to it's ID, to be used later by other visitors |
| CvlX::VLXSerializer | Translates an arbitrary set of vl::Object (and subclasses) into VLB and VLT format |
| ►CvlX::VLXTaggedValue | Base class for VLX values with a tag |
| ►CvlX::VLXArray | Base class for all arrays of VLX values |
| CvlX::VLXArrayTemplate< T > | A templated VLXArray |
| ►CvlX::VLXArrayTemplate< double > | |
| CvlX::VLXArrayReal | An array of 64 bits floating point numbers, can also have a tag |
| ►CvlX::VLXArrayTemplate< long long > | |
| CvlX::VLXArrayInteger | An array of 64 bits integers, can also have a tag |
| CvlX::VLXList | A simple sequence of VLXValue objects, can also have a tag |
| CvlX::VLXRawtextBlock | A block of raw text |
| CvlX::VLXStructure | A list of key/VLXValue pairs, can also have a tag |
| Cvl::ObjLoader | Loads a Wavefront OBJ file |
| Cvl::ObjTexture | Represents a Wavefront OBJ texture. See also ObjMaterial and ObjLoader |
| Cvl::OpenGLContextFormat | Encapsulates the settings of an OpenGL rendering context |
| Cvl::PlyLoader | Loads a PLY file |
| Cvl::PolygonSimplifier::QErr | The quadric error metric as defined by PolygonSimplifier |
| Cvl::PolygonSimplifier::Triangle | A Triangle as defined by PolygonSimplifier |
| Cvl::PolygonSimplifier::Vertex | A Vertex as defined by PolygonSimplifier |
| Cvl::Quaternion< T_Scalar > | Implements a Quaternion usually used to represent rotations and orientations |
| Cvl::radian | Simple class representing quantities in radians, converts automatically to vl::degree and real |
| Cvl::Ray | Defines a ray as an origin and direction using real precision |
| Cvl::Rect< T > | Implements the common functions of RectI and RectF |
| Cvl::ref< T > | The ref<> class is used to reference-count an Object |
| Cvl::RenderStateSlot | |
| Cvl::RingExtractor | Traverses a molecule's graph and detects various types of cycles, mainly used for aromatic ring detection |
| Cvl::SayArg | Used internally by the Say class |
| Cvl::ScopedMutex | A class that locks the specified mutex when constructed and unlocks it when destructed |
| Cvl::ShaderNode::EnableInfo | ShaderNode's representation of an enable |
| Cvl::ShaderNode::RenderStateInfo | ShaderNode's representation of a RenderState |
| Cvl::ShaderNode::UniformInfo | ShaderNode's representation of a Uniform |
| Cvl::Sphere | Defines a sphere using a center and a radius using vl::real precision |
| Cvl::STLLoader | Loads an STL file |
| Cvl::String | Implements an advanced UTF16 (Unicode BMP) string manipulation engine |
| Cvl::TriangleIterator | Iterator used to extract the indices of every single triangle of a DrawCall regardless of the primitive type |
| Cvl::TriangleStripGenerator | Used to substitute lists of triangles or quads with triangle strips |
| Cvl::TypeInfo | Represents a class type |
| Cvl::UUID | Simple implementation of a 16 bytes Universally Unique ID based on http://www.ietf.org/rfc/rfc4122.txt |
| Cvl::Vector2< T_Scalar > | 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 |
| Cvl::Vector3< T_Scalar > | 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 |
| Cvl::Vector4< T_Scalar > | 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 |
| Cvl::VisualizationLibrary | Used to initialize/shutdown VisualizationLibrary and to access important global data |
| Cvl::VolumePlot::Function | A function to be used with VolumePlot |
| CvlX::Linker | Links several VLX hierachies also resolving IDs across them |
| CvlX::VLTToken | A token of information as defined by VLT specification |
| CvlX::VLXStructure::KeyValue | Key/value pair used by VLXStructure |
| CvlX::VLXValue | Wrapper for all VLX value types |
| ►CwxGLCanvas | |
| CvlWX::WXGLCanvas | Implements a vl::OpenGLContext using the wxWidgets library |