| ►Nvcl | |
| ►Ncomp | |
| CAdjacentEdges | The AdjacentEdges class is a container of Edge indices or pointers. It could be used by any Element to save adjacencies information (also the Edge element itself) |
| CAdjacentFaces | The AdjacentFaces class is a container of Face indices or pointers. It could be used by any Element to save adjacencies information (also the Face element itself) |
| CAdjacentVertices | The AdjacentVertices class is a container of Vertex indices or pointers. It is a component that makes sense to use mostly on Vertex Elements. For Faces and Edges, see the VertexPointers component (which is similar, but has different member function names) |
| CBitFlags | The BitFlags component class represents a collection of 8 bits that will be part of an Element (e.g. Vertex, Face, ...) |
| CBoundingBox | The BoundingBox component class represents an axis aligned bounding box. This class is usually used as a component of a Mesh |
| CColor | The Color class represents a RGBA color that will be part of an Element (e.g. Vertex, Face, ...) or Mesh |
| CContainerComponent | The ContainerComponent class is the base class for all the components of VCLib that store a container of objects of a given type T |
| CCoordinate | The Coordinate class represents a N-Dimensional point that will be part of an Element (e.g. Vertex...) |
| CCustomComponents | The CustomComponents Component is a container of additional components associated to an Element (e.g. Vertex, Face) |
| CIndexContainerComponent | The IndexContainerComponent is the base class for all the components of VCLib that store a container of indices of an Element |
| CMark | The Mark class is an utility class useful to un-mark components in constant time |
| CName | The Name component class represents a simple name stored as string. This class is usually used as a component of a Mesh |
| CNormal | The Normal class represents a N-Dimensional normal vector that will be part of an Element (e.g. Vertex, Face...) |
| CParentMeshPointer | The ParentMeshPointer class |
| CPointerContainerComponent | The PointerContainerComponent is the base class for all the components of VCLib that store a container of pointers to an Element |
| CPolygonBitFlags | The PolygonBitFlags class represents a collection of 8 bits plus 8 bits for each edge that will be part of a generic Polygonal Face of a Mesh |
| CPrincipalCurvature | The PrincipalCurvature class represents a component that stores the principal curvature directions and values at a point on a surface. This component could be part of Vertices or Faces |
| CQuality | The Quality class represents a component that stores the quality of a mesh element, that is represented by a scalar |
| CReferenceContainerComponent | The ReferenceContainerComponent is a class that inherits from the IndexContainerComponent or PointerContainerComponent classes, depending on the STORE_INDICES template parameter |
| CReferencesComponentTriggerer | |
| CTexCoord | The TexCoord class represents a component that stores a texture coordinate |
| CTextureImages | Component that stores the textures used by a mesh. This component makes sense only if it is used by meshes, and therefore it cannot be stored vertically or be optional (no template arguments are needed for these options) |
| CTexturePaths | Component that stores the paths of the textures used by a mesh. This component makes sense only if it is used by meshes, and therefore it cannot be stored vertically or be optional (no template arguments are needed for these options) |
| CTransformMatrix | The TransformMatrix class represents a component that stores a 4x4 matrix that can be used for a transformation. This class is usually used as a component of a Mesh |
| CTriangleBitFlags | The TriangleBitFlags class represents a collection of 16 bits that will be part of a Triangle of a Mesh |
| CVertexReferences | The VertexReferences class represents a component that stores a container of indices or pointers to vertices that will be part of an Element (e.g. Face, Edge, Tetrahedron, etc.) |
| CWedgeColors | The WedgeColors class is a container of colors associated to the wedges of a Face element |
| CWedgeTexCoords | The WedgeTexCoords class is a container of texture coordinates associated to the wedges of a Face element |
| ►Nedgemesh | |
| CEdge | |
| CVertex | |
| ►Nglfw | |
| CWindowManager | |
| ►Nimgui | |
| CImGuiDrawer | |
| CImguiStatsDrawer | |
| CMeshViewerDrawerImgui | |
| ►Nmesh | |
| CContainerOfElement | The ContainerOfElement structure exposes the type of the container of the given MeshType having element with the given ELEM_ID |
| CCustomComponentsVectorMap | The CustomComponentsVectorMap class stores a map of vectors of custom components |
| CCustomComponentsVectorMap< true > | |
| CEdgeContainer | The EdgeContainer class represents a container of Edge elements that can be used in a Mesh class |
| CElementContainer | |
| CElementContainerTriggerer | |
| CFaceContainer | The FaceContainer class represents a container of Face elements that can be used in a Mesh class |
| CHasContainerOfElementPred | |
| CHasContainerOfPred | |
| CIsElementContainerPred | The predicate IsElementContainerPred sets its bool value to true when the type T satisfies the ElementContainerConcept concept |
| CVertexContainer | The Vertex Container class, will be used when the template argument given to the Mesh is a Vertex |
| CVerticalComponentsVectorTuple | |
| CVerticalComponentsVectorTuple< TypeWrapper< Comp... > > | |
| ►Npointcloud | |
| CVertex | |
| ►Npolyedgemesh | |
| CEdge | |
| CFace | |
| CVertex | |
| ►Npolymesh | |
| CFace | |
| CVertex | |
| ►Nqt | |
| CDebugIODevice | |
| CDrawableObjectFrame | |
| CDrawableObjectVectorFrame | |
| CEdgesFrame | |
| CErrorIODevice | |
| CGenericMeshRenderSettingsFrame | |
| CMeshRenderSettingsFrame | |
| CMeshViewer | |
| CMessageHider | |
| CMessageIODevice | |
| CPointsFrame | |
| CQClickableLabel | The QClickableLabel class |
| CScreenShotDialog | |
| CSurfaceFrame | |
| CTextEditLogger | |
| CWarningIODevice | |
| CWidgetManager | |
| CWireframeFrame | |
| ►Ntriedgemesh | |
| CEdge | |
| CFace | |
| CVertex | |
| ►Ntrimesh | |
| CFace | |
| CVertex | |
| CAbstractDrawableMesh | |
| ►CAbstractGrid | The AbstractGrid class describes a generic Spatial Data Structure organized on a regular grid, that allows to store elements (ValueType) in a particular way that will be managed by its derived classes (e.g. StaticGrid, HashTableGrid) |
| CDistIterPairComparator | |
| CIterComparator | |
| CAbstractLogger | Used as common ancestor class for all the logger types in the library |
| CAbstractViewerDrawer | The AbstractViewerDrawer class is a base class for all viewer drawers implementations |
| CArray | The Array class is a dynamically allocated N-dimensional array stored in RowWise mode |
| CBadCustomComponentTypeException | Exception thrown when the type of a custom component is not the one expected |
| CBadVertexIndexException | Exception thrown when an index is out of bounds in a vertex container |
| CBipartiteGraph | |
| CBitProxy | The BitProxy class allows to access to a bool reference from a bit saved in a mask, and then allow assignment |
| CBitSet | The BitSet class allows to treat an integral type as an array of booleans of a guaranteed size |
| CBlockerEventDrawer | Special EventDrawer class for the case where the drawer can request to block the event propagation |
| CBox | A class representing a box in N-dimensional space |
| CCallback | |
| ►CCamera | |
| CProjectionMode | |
| CCameraUniforms | |
| CCannotOpenFileException | Exception thrown when the file cannot be opened |
| CCanvasBGFX | The Canvas class describes a canvas on which bgfx can draw |
| CCanvasOpenGL2 | The Canvas class describes a canvas on which opengl2 can draw |
| CCellIterator | |
| CColor | 32 bit color |
| CCompId | The CompId struct enumerates the components that can compose a element or a mesh |
| CComponentString | The ComponentString class is used to retrieve the string associated to a COMP_ID value, trough its member 'str' |
| CComputeLoader | |
| CConsoleLogger | |
| CConstMeshEdgeUtil | |
| CConstPointerIterator | The ConstPointerIterator class is a utility class that wraps an iterator of a container of [shared] pointers, and returns a const [shared] pointer when dereferencing the iterator |
| CConstStaticGridIterator | |
| CContext | |
| CCreateSphereArgs | The CreateSphereArgs structs contains a series of parameters to generate a sphere |
| ►CCustomComponentVectorHandle | Allows to access directly to a custom component |
| CConstIterator | |
| CIterator | |
| CDesktopTrackBall | |
| CDirectionalLight | |
| CDirectionalLightUniforms | Manages the uniforms which describe a directional light that can be used by bgfx shaders |
| CDistribution | The Distribution class allows to collect a set of values and then compute some statistics like average, variance, standardDeviation, and percentiles |
| CDrawableAxis | |
| CDrawableAxisUniforms | |
| CDrawableDirectionalLight | |
| CDrawableDirectionalLightUniforms | |
| CDrawableMeshBGFX | |
| CDrawableMeshOpenGL2 | |
| CDrawableMeshUniforms | |
| CDrawableObject | Base class for all the objects that can be drawn in a 3D viewer |
| CDrawableObjectVector | |
| CDrawableTrackBall | |
| CDrawableTrackballUniforms | |
| CDynamicIndexBuffer | The DynamicIndexBuffer manages the lifetime of a bgfx::DynamicIndexBufferHandle |
| CDynamicVertexBuffer | The DynamicVertexBuffer manages the lifetime of a bgfx::DynamicVertexBufferHandle |
| CEdge | The Edge class represents an Edge element of the vcl::Mesh class |
| CEdge< MeshType, TypeWrapper< Comps... > > | |
| CEdgeAdjFaceIterator | |
| CEdgeMeshT | The EdgeMeshT class is a mesh class that represents a mesh that stores only vertices and edges (no faces) |
| ►CElement | The Element class |
| ►CComponentIDPred | |
| CSameCmpPred | |
| ►CGetComponentFromID | |
| CTypeUnwrapper | |
| CTypeUnwrapper< TypeWrapper< C > > | |
| CElementContainerIterator | |
| CElementString | The ElementString class is used to retrieve the string associated to a ELEM_ID value, trough its member 'str' |
| CElemId | The ElemId struct enumerates the elements that can compose a mesh |
| CEmbeddedFont | |
| CEmbeddedFont< VclFont::DROID_SANS > | |
| CEventDrawer | The EventDrawer class is a base class for drawers that can handle events |
| CFace | The Face class represents an Face element of the vcl::Mesh class |
| CFace< MeshType, TypeWrapper< Comps... > > | |
| CFakePointerWithValue | A simple utility class to represent a pointer with a value |
| CFileFormat | File format |
| CFileInfo | |
| CFileType | Class that defines whether a file is binary or text, and (if binary) the endianness of the file |
| CFilterTypesByCondition | Removes all types that do not satisfy a condition, and get them as a tuple |
| CFilterTypesByCondition< Pred, Head, Tail... > | Removes all types that do not satisfy a condition, and get them as a tuple. |
| CFilterTypesByCondition< Pred, TypeWrapper< Tail... > > | Removes all types that do not satisfy a condition, and get them as a tuple. |
| CFirstElementPairComparator | The FirstElementPairComparator struct is an utility comparator that allow to sort std::pair (or any type that has a sortable member called 'first') using only its first element. The second element of the Pair type is ignored and won't be considered by the comparator. This means that pairs having equal first elements but different second elements will be considered as equals |
| CFirstRefPair | |
| CFirstType | Get the first type of a pack of types (variadic templates) or a TypeWrapper |
| CFirstType< TemplatedTypeWrapper< Args... > > | |
| CFirstType< TypeWrapper< Args... > > | Get the first type of a pack of types (variadic templates) or a TypeWrapper. |
| CFontData | |
| CFontManager | |
| CForEachType | Allows to apply a function to each type in a variadic template pack |
| CForEachType< TypeWrapper< T... > > | |
| CGenericBuffer | The GenericBuffer manages the lifetime of a bgfx BufferHandle |
| CGetTypeByCondition | The the first type of a pack that satisfies the given condition |
| CGetTypeByCondition< Pred, TypeWrapper< Args... > > | The the first type of a pack that satisfies the given condition. |
| CHashTableGrid | The HashTableGrid class stores N-Dimensional spatial elements (that could be anything on which it can be computed a N-dimensional bounding box) in a regular grid, using a Hash Table having the Cell Grid coordinate as key type |
| CHausdorffDistResult | |
| CHistogram | The Histogram class allows to collect a set of values and then compute some statistics like average, variance, standardDeviation, and percentiles |
| CImage | Stores an Image in 4 bytes RGBA format |
| CImGuiShaders | |
| CInconsistentMeshException | Exception thrown when the mesh is inconsistent |
| CIndexBuffer | The IndexBuffer manages the lifetime of a bgfx::IndexBufferHandle |
| CIndexFromPointerIterator | This iterator is used to iterate over a container of pointers to elements and return the index of the element |
| CIndexInTypes | |
| CIndexInTypes< T, TypeWrapper< Us... > > | |
| CIndirectBuffer | |
| ►CKDTree | |
| CNode | |
| CQueryNode | |
| CKey | |
| CKeyModifier | |
| CKeyRefValueRefPair | |
| CKeyValueRefPair | |
| CLoadSettings | The LoadSettings structure contains the settings that can be used to load a mesh from a stream/file |
| CLogger | |
| CMakeConstPointer | Utility type that makes possible to treat const pointers in a templated class that can treat a both const and non-const pointer type |
| CMakeConstPointer< T * > | Utility type that makes possible to treat const pointers in a templated class that can treat a both const and non-const pointer type. |
| CMalformedFileException | Exception thrown when the file is malformed |
| CMatrix | |
| ►CMesh | The Mesh class represents a generic 3D mesh. A mesh is composed of a generic number of containers of Elements (which can be vertices, faces, edges...), plus some other components |
| CContainerOf | The ContainerOf struct allows to get the Container of an Element on this Mesh |
| CContainerOfElement | |
| CMeshEdgeUtil | Utility class that represents a edge in a Mesh |
| CMeshInertia | The MeshInertia class provides several for computing Polyhedral Mass properties (like inertia tensor, volume, etc) |
| ►CMeshInfo | A simple class that allows to store which elements and their components have been imported/loaded or are going to be exported/saved on a mesh file or some other data structure |
| CCustomComponent | The CustomComponent struct is a simple structure that describes a custom component of an Element (or of the Mesh) |
| CMeshPos | The MeshPos class describes a "Position in a Mesh" that can be identified with a triplet of Face-Vertex-Edge, where: |
| CMeshRenderBuffers | |
| CMeshRenderData | The MeshRenderData class provides a common interface to automatically update the buffers used to render a mesh, with the possibility to update only a subset of the buffers, taking into account different scenarios (e.g., vertex duplication, polygonal faces triangulation) consistently |
| CMeshRenderInfo | Collection of rendering settings for a Mesh |
| CMeshRenderSettings | Allows an easy management of render settings of a Mesh. This class stores the rendering status of a Mesh, the rendering capability of a Mesh and a series of other data like user colors used for the mesh primitives |
| CMeshRenderSettingsUniforms | |
| CMeshRenderVectors | |
| CMeshSampler | |
| CMissingCompactnessException | Exception thrown when the mesh is not compact |
| CMissingComponentException | Exception thrown when a mesh/element component is missing (not enabled) |
| CMissingPreconditionException | Exception thrown when a precondition on an input/output mesh is missing |
| CMissingQuadRequirementException | Exception thrown when an input/output mesh is not composed of quads |
| CMissingTriangularRequirementException | Exception thrown when an input/output mesh is not composed of triangles |
| CMouseButton | |
| CNestedInitializerListsProcessor | The NestedInitializerListsProcessor class |
| CNestedInitializerListsProcessor< T, 1 > | |
| CNodeIterator | |
| CNoIntersectionException | Exception thrown when the intersection between two objects is empty |
| CNullLogger | Used as default type in all the library functions that take as input a logger type |
| CNumberOfTypes | |
| CNumberOfTypes< TypeWrapper< Args... > > | |
| CPairComparator | The PairComparator struct is an utility comparator to allow to sort pairs in lexical order |
| CPlainDrawer | |
| CPlane | The Plane class represent a 2D plane in 3D space |
| CPoint | The Point class represents an N-dimensional point containing N scalar values |
| CPointCloudT | The PointCloudT class is a mesh class that represents a point cloud |
| CPointerFromIndexIterator | This iterator is used to iterate over a container of pointers to elements and return the index of the element |
| CPointerVector | The PointerVector class is a utility container that stores a sequence of pointers that preserve their constness when the container is constant |
| CPointSampler | |
| CPolyEdgeMeshT | The PolyEdgeMeshT class is a mesh class that represents a polygonal mesh with edges |
| CPolygon | The Polygon class represents a polygon in a N-dimensional Euclidean space |
| CPolyMeshT | The PolyMeshT class is a mesh class that represents a polygonal mesh |
| CPolymorphicObjectVector | The PolymorphicObjectVector class is a container that stores a collection of polymorphic objects, having a common base class T |
| CPrincipalCurvature | The PrincipalCurvature class stores the principal curvature directions and values at a point on a 3D surface |
| CProgramManager | |
| CQuaternion | Quaternion class |
| CReadBufferTypes | |
| CRefPair | |
| CRegularGrid | |
| ►CRenderApp | The RenderApp class is a template class that combines a canvas, a window manager, and a set of drawers, allowing them to work together and communicate with each other |
| CCNV | The RenderApp::CNV inner class is an Attorney that allow access to some private member functions of the RenderApp class to the CanvasType class |
| CDRW | The RenderApp::DRW inner class is an Attorney that allow access to some private member functions of the RenderApp class to the Drawer classes |
| CWM | The RenderApp::WM inner class is an Attorney that allow access to some private member functions of the RenderApp class to the WindowManagerType class |
| CSaveSettings | The SaveSettings structure contains the settings that can be used to save a mesh to a stream/file |
| CSecondRefPair | |
| CSegment | A class representing a line segment in n-dimensional space. The class is parameterized by a PointConcept, which must provide the DIM constant and the [] operator for accessing the point coordinates |
| CSphere | |
| CStaticGrid | |
| ►CStaticGridIterator | |
| CArrowHelper | |
| CTemplatedTypeWrapper | |
| CTexCoord | The TexCoord class represents a 2-dimensional texture coordinate containing two scalar values |
| CTexCoordIndexed | The TexCoordIndexed class represents a texture coordinate with an index |
| CTextDrawer | |
| CTextManager | |
| CTexture | |
| CTextureBuffer | |
| CTextureUnit | |
| CTextView | |
| CTimer | Allows to instantiate simple Timer objects that can be used everywhere |
| CTokenizer | The Tokenizer class |
| ►CTrackBall | The TrackBall class implements a trackball camera |
| CTransformArgs | |
| CTriangle | |
| CTriangleWrapper | The TriangleWrapper class is a wrapper around a N-Dimensional triangle |
| CTriEdgeMeshT | The TriEdgeMeshT class is a mesh class that represents a triangle mesh with edges |
| CTriMeshT | The TriMeshT class is a mesh class that represents a triangle mesh |
| CTriPolyIndexBiMap | Allows to store a bidirectional mapping between a Polygon Mesh and a Triangle Mesh generated by the polygon mesh |
| CTypeAt | |
| CTypeAt< I, TypeWrapper< T... > > | |
| CTypesSatisfyCondition | Its value is set to true if there is at least one type in the given pack Args... that satisfies the given condition |
| CTypesSatisfyCondition< Pred, TypeWrapper< Args... > > | Its value is set to true if there is at least one type in the given pack Args... that satisfies the given condition. |
| CTypeWrapper | A simple structure that wraps a list of variadic templates, without instantiating anything. Useful when you need to wrap a list of types, and consider them as a single type |
| CUndirectedNode | |
| CUniform | Wraps a bgfx::UniformHandle and provides a simple interface to set the uniform data |
| CUnknownFileFormatException | Exception thrown when the file format is unknown |
| CUnorderedPairComparator | The UnorderedPairComparator struct is an utility comparator to allow to sort unordered std::pair<T, T>, that means that it is not important the order of the first and the second element of the pair. This menas that pairs (1, 2) and (2, 1) are considered equal, and (3, 1) < (2, 3) |
| CVclFont | |
| CVector | The Vector class is a generic container of objects of type T, that could have fixed or dynamic size, depending on the templated size N |
| CVertex | The Vertex class represents an Vertex element of the vcl::Mesh class |
| CVertex< MeshType, TypeWrapper< Comps... > > | |
| CVertexBuffer | The VertexBuffer manages the lifetime of a bgfx::VertexBufferHandle |
| CVertFragLoader | |
| CVertFragLoader< VertFragProgram::DRAWABLE_AXIS > | |
| CVertFragLoader< VertFragProgram::DRAWABLE_DIRECTIONAL_LIGHT > | |
| CVertFragLoader< VertFragProgram::DRAWABLE_MESH_EDGES > | |
| CVertFragLoader< VertFragProgram::DRAWABLE_MESH_POINTS > | |
| CVertFragLoader< VertFragProgram::DRAWABLE_MESH_SURFACE > | |
| CVertFragLoader< VertFragProgram::DRAWABLE_MESH_WIREFRAME > | |
| CVertFragLoader< VertFragProgram::DRAWABLE_TRACKBALL > | |
| CVertFragLoader< VertFragProgram::FONT_BASIC > | |
| CVertFragLoader< VertFragProgram::FONT_DISTANCE_FIELD > | |
| CVertFragLoader< VertFragProgram::FONT_DISTANCE_FIELD_DROP_SHADOW > | |
| CVertFragLoader< VertFragProgram::FONT_DISTANCE_FIELD_DROP_SHADOW_IMAGE > | |
| CVertFragLoader< VertFragProgram::FONT_DISTANCE_FIELD_OUTLINE > | |
| CVertFragLoader< VertFragProgram::FONT_DISTANCE_FIELD_OUTLINE_DROP_SHADOW_IMAGE > | |
| CVertFragLoader< VertFragProgram::FONT_DISTANCE_FIELD_OUTLINE_IMAGE > | |
| CVertFragLoader< VertFragProgram::FONT_DISTANCE_FIELD_SUBPIXEL > | |
| CView | The View class is a simple class that stores and exposes two iterators begin and end |
| CViewerDrawerBGFX | |
| CViewerDrawerOpenGL2 | |
| CWindowManagerId | The WindowManagerId struct enumerates the window managers that can be used to create and manage a window and its events |
| CWrongSizeException | Exception thrown when the size (generally of a container) is not the expected one |
| CImGui_ImplQt_Data | |
| CImGuiQtEventFilter | |
| COcornutImguiContext | |
1.9.8