Class List

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

[detail level 1234]

NEagle	Gather general basic mathematic functions which are not available in cmath here
NPhysicalSpace	Geometric algebra of the physical 3D-space, by which we mean the Clifford algebara over Euclidean, three-dimensional space
CAABB	Simplistic class for Axis-Aligned Bounding Box
CAABB_2D	Axis-aligned bounding box in 2D dimensions out of 3D, allowing for projections other than XY
CAnalyticFunction	Abstract base class for analytical functions that are evaluated on a physical space
Cbivector	A three-dimensional Bi-Vector which is span by two vectors to define a plane
CFrustum	A frustum and operations on it, as described by either a set of corner points or six planes
CCornerPoints
CPlanes
CHessianNormalPlane
CMultiVector	A full multivector in 3D consists of components
COddMultiVector	The combination of a vector and a trivector yields an odd multivector, which is dual to a rotor
CPlane	Normal form of a plane
Cpoint	A point in physical 3D space
Crotor	A rotor is the sum of scalar with a bivector
CSpan
CSpan< 1 >	A one-dimensional span, also a known as a Ray
CSpan< 2 >	A two-dimensional span, also a known as the parametric form of a plane
CSpan< 3 >
Ctrivector	A Tri-Vector, or oriented volume in 3D space
Cvector	3-dimensional vector
CViewport	A helper class describing an axis-aligned rectangle
NPlane	Geometric algebra of the plane, by which we mean the Clifford algebra over Euclidean, two-dimensional space
Cvector
NPolarSpace
Cpoint
NSTA	Geometric algebra of spacetime, a.k.a
CCartesianChart4D
Cbivector	A four-dimensional Bi-Vector which is span by two vectors to define a plane
Cpoint
Ctrivector	A Tri-Vector, or oriented volume in 4D space
Cvector	4-dimensional vector
CSphericalChart4D
CAnalyticFunctionBase	Abstract base class for analytic functions, coordinate-independent
CAntiSymmetric
CAnyType
CAssert
CAssert< true >
CAssertion
CAssertion< true >
CAssignment	Convenience class to allow using the comma operator for assigning a sequence of elements to a given array-like class
CBinaryOperatorFunctor
CBinaryOperatorNode	Template node class to perform binary operations on evaluate-able nodes
CBoundingBall	Bounding container implemented by a ball
CBoundingBox	A coordinate-parallel bounding box in three dimensions
CCameraPath	A camera path with movements, motions and various constraints
CCartesian3D
CChristoffel	Christoffel symbols
CChunk	A class which handles a chunk of memory
CFiller
CColumn	A column vector
Ccomplex	STL class
CConstantNode	A node that constructs a type from a constant value
CConstantVectorNode	A node that implements a constant vector value
CConstructorNode	A node that constructs a vectorial type from three scalar values
CContext	A set of variable names, with indices associated to each type
CIterator	Iterator functor that allows to travers over all variables of a specific type
CVariableList
CContraVariant
CContravariantIndexingScheme	Indices are all upper indices, e.g
CCoordinateInfo
CCoordinateInfo< void >
CCoVariant
CCovariantIndexingScheme	Indices are all lower indices, e.g
CDegeneratedMatrix
CDerivationTrait	Template type trait class to compute analytical derivates
CDerivationTrait< BinaryOperatorFunctor< NodeType, NodeType, NodeType, '+'> >	Computes (u+v),x which is u,x+v,x
CDerivationTrait< BinaryOperatorFunctor< NodeType, NodeType, NodeType, '-'> >	Computes (u-v),x which is u,x-v,x
CDerivationTrait< BinaryOperatorFunctor< ScalarNode, ScalarNode, ScalarNode, ' *'> >	Computes (ab),x which is a,x b + a b,y
CDerivationTrait< BinaryOperatorFunctor< ScalarNode, ScalarNode, ScalarNode, '+'> >	Computes (a+b),x which is a,x+b,y
CDerivationTrait< BinaryOperatorFunctor< ScalarNode, ScalarNode, ScalarNode, '-'> >	Computes (a-b),x which is a,x-b,y
CDerivationTrait< BinaryOperatorFunctor< ScalarNode, ScalarNode, ScalarNode, '/'> >	Computes (a/b),x which is (a,x b - a b,y) / b^2
CDerivationTrait< LocationComponent< Component > >	Computes (v[i]),x
CDerivationTrait< ScalarCube >	Computes (y^3),x which is 3 y^2 y,x
CDerivationTrait< ScalarPlusBivector >	Computes (a+U),x which is a,x+U,v
CDerivationTrait< ScalarSquare >	Computes (y^2),x which is 2 y y,x
CDerivationTrait< ScalarTimesVector >	Computes (a*v),x which is a,x * v + a * v,x
CDerivationTrait< UnaryMinus< NodeType > >	Computes (-v),x which is -(v,x)
CDerivationTrait< VectorDotProduct >	Computes (uv),x which is u,x * v + u * v,x
CDerivationTrait< VectorSquare >	Computes (v^2),x which is 2 v v,x
CDerivationTrait< VectorTimesScalar >	Computes (a*v),x which is a,x * v + a * v,x
CDerivationTrait< VectorWedgeVector >	Computes which is
CDeterminantor	The determinantor recursively computes the determinant of a matrix
CDeterminantor< 1 >	The trivial determinant of a 1x1 matrix
CDeterminantor< 2 >	The simple determinant of a 2x2 matrix
CDeterminantor< 3 >
CDeterminantor< 4 >
CDomainFunctions
CDomainFunctions< RGB, DomainVector >
CDomainFunctions< RGBA, DomainVector >
CDomainVector	A vector type that is bound to a certain domain, inheriting all vector space properties, but provides type-safety to only operate within the same domain
CDomainVector< ScalarType[N], Domain, ScalarType >
CElementOfFunctor
CEvaluationContext	Class providing numerical values from some context ID for the evaluation of function trees
CEvaluator	Abstract base class providing numerical values from some context ID for the evaluation of function trees
CEye
CFA_CONVERT
CFixedArray	A FixedArray is a simple copy-by-value array providing random access to its elements
CFixedArrayFlattener	A template metaprogram class (type trait) to compute the flattened version of a FixedArray
CFixedArrayFlattener< FixedArray< FixedArray< T, M >, N > >
CFixedArrayFlattener< FixedArray< T, N > >
CFixedArrayType
CFixedArrayType< ElementType, 1 >
CGaussSolver
CGE
CGetFixedArrayType	A template metaprogram class to compute the an fixed array type of an homogeneous type
CGT
CHead	Properties of a camera floating around in space, or, alternatively, an eagle's eye
CInterpol	Interpolation of certain values
CInterval
CQuarticInterval
CInversionOperation
CIVec4Packed
CKDInterface
CKDTree	A multidimensional KDTree data structure rewritten from c-code by John Tsiombikas (http://code.google.com/p/kdtree/)
CKDTreeCallBackFunctor
CKDTreeResult
CKDTreeResult< std::list< T > >
CKDTreeResult< std::map< double, T > >
CKDTreeResult< std::multimap< double, T > >
CKDTreeResult< std::set< T > >
CKDTreeResult< std::vector< T > >
CKeyValue	Entry in interpolation table with some flags
CLE
CLeibnitzRule	Implements the Leibnitz rule for derivatives for binary operators o: [A o B ],x = [A,x o B + [A o B,x]
CLocationComponent	Extracts a component of a location
CLowerTriangular	A symmetric matrix stored in lower triangular form
CLT
Cmap	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CMatrix	Simple matrix class for performing fast operations on matrices of sizes known at compile-time
CMetaInfo
CMetaInfo< bivector3 >
CMetaInfo< bivector3f >
CMetaInfo< Christoffel< N, Scalar_t > >
CMetaInfo< ColorSpace::RGBA::tvector >
CMetaInfo< Column< N, Scalar_t > >
CMetaInfo< Coordinates< Cartesian3D, double >::bivector >
CMetaInfo< Coordinates< Cartesian3D, double >::covector >
CMetaInfo< Coordinates< Cartesian3D, double >::point >
CMetaInfo< Coordinates< Cartesian3D, double >::vector >
CMetaInfo< covector3f >
CMetaInfo< DomainVector< Vector< ValueType, 3 >, RGB > >
CMetaInfo< DomainVector< Vector< ValueType, 4 >, RGBA > >
CMetaInfo< DomainVector< VectorType, Domain, scalar_t > >
CMetaInfo< FixedArray< T, N > >	Implement the meta-information on fixed arrays
CMetaInfo< LowerTriangular< N, Scalar_t > >
CMetaInfo< Matrix< R, C, Value > >
CMetaInfo< metric33 >
CMetaInfo< point3 >
CMetaInfo< point3f >
CMetaInfo< Row< N, Scalar_t > >
CMetaInfo< trivector3 >
CMetaInfo< tvector3 >
CMetaInfo< vector3f >
CMetaInfo< Vector< T, N > >
CMetaInfo< void >
CMetaInfoElementIndex	For multidimensional types T of rank MetaInfo<T>::RANK, this class provides a mapping from index space to memory space
CMetaInfoElementIndex< Christoffel< N, Scalar_t > >
CMetaInfoElementIndex< LowerTriangular< N, Scalar_t > >
CMetaInfoElementIndex< Matrix< R, C, Value > >
CMetaInfoIO	Helper class which is provides some textual output for MetaInfo types
CMetaInfoIO< MetaInfo< T > >
CMetaInfoNonTensor
CMetaInfoNonTensor< Christoffel< N, Scalar_t > >
CMultiRange
CMultiVector
CMyDataHolder
CNode	Abstract base class for evaluation of arbitrary functions that have been parsed from some input
CNotElementOfFunctor
COcTree
COneNode	A scalar node that always returns one
COperator	An type-only template used as argument on computational constructors
COperator<' *','~'>	Multiply with transpose
COperator<' *'>
COperator<'&'>
COperator<'+','='>
COperator<'+'>
COperator<'-'>
COperator<'/'>
COperator<'='>
COperator<'~'>	Transpose
COperatorBase
CParserContext	Internal class for communicating with the Bison/Yacc Parser and Flexical Stanza Generator
CQuadratic	An n x n matrix (i.e., a vector of length n*n), stored row-wise: that is, A(i,j) = A[ij], where ij = i*n + j
CQuadTree
CRaster	Class for computing triangle strips on a uniform 2D distribution of points within a plane
CRef	Pointer to a refcountable object which automatically initializes the pointer with constructing an object
CRGB
CRGBA
Crgba_float_t
CRow	A row vector,
CScalarCube	Compute
CScalarPlusBivector	A node operator implementing creation of rotor from scalar and bivector
CScalarSquare
CScalarTimesVector	A node implementing scalar times vector multiplication
CSpherical3D
Cstring	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CStrongPtr	A reference counting pointer class which keeps objects alive as long as strong pointers to these objects exist
CCall
CCall< StrongPtr< ReturnType, typename ReturnType::reference_domain_t > >
CSubMatrix	SubMatrix is a Matrix with row R and column C deleted
CSubQuadratic
CSumDerivation	Implements the derivation of a sum [A + B ],x = A,x + B,x
CTensor3
CTensorBase	Tensor experiments
CTernaryOperatorNode	Template node class to perform ternary operations on evaluate-able nodes
CTorsion	Torsion Tensor
CTransposeOperation
CTriangleStrip	Class to compute a contiguous triangle strip for a two-dimensional set of points
CTypedChunkBase	The abstract base class for chunks that have a certain type
CTypedNode	Templatized trait class for Nodes that yield a specific return type
CTypeIndexingScheme
CTypeIndexingScheme< bivector3 >
CTypeIndexingScheme< bivector3f >
CTypeIndexingScheme< ColorSpace::RGBA::tvector >
CTypeIndexingScheme< covector3 >
CTypeIndexingScheme< covector3f >
CTypeIndexingScheme< trivector3 >
CTypeIndexingScheme< tvector3 >
CTypeIndexingScheme< vector3f >
CTypeIndexingScheme< Vector< T, N > >
CUIVec4Packed
CUnaryMinus
CUnaryOperatorNode	Template node class to perform unary operations on evaluate-able nodes
CUnit	Http://en.wikipedia.org/wiki/Fundamental_unit In the SI system there are 7 fundamental units: kilogram, meter, candela, second, ampere, kelvin, and mole
Cunit
CVariableNode	A node that references some variable which will be set by the Context of the Evaluator
CVec3Pack32bit	Generic unpacking from 32-bit integer with bits per channel given explicitly
CVec3Pack64bit	Generic unpacking from 64-bit integer with bits per channel given explicitly
CVec3Pack_10_11_11
CVec3Packed
CVec3Packed.packed
CVector	A Vector is an fixed-size array (see class FixedArray) with vector space operations, i.e
Csubvector	Access part of the vector as a vector of smaller size
CVectorDotProduct	Dot product between tangential vectors
CVectorizationTrait	A trait class to specify which vectorizations are possible
CVectorSquare	Computes v^2 for vector v
CVectorTimesScalar	A node implementing vector times scalar multiplication
CVectorWedgeVector	A node operator implementing creation of a bivector from two vectors
CViewPoints	A set of priority-weighted view points, used to recommend view points for objects
Citerator
CVPData
CYlmCoefficients
CZeroNode	A scalar node that always returns zero
NFiber
CVObjectSystemExecutor	VObject property to store a system command to be executed before loading an associated data file
Nfpng
Cdefl_huff
Cdefl_sym_freq
Cpng_chunk_prefix
Cpng_iend
Cpng_ihdr
NHTTP
CHeader
CRequest	Http://www.oreilly.com/openbook/cgi/ch03_04.html http://www.w3.org/TR/html4/interact/forms.html#form-content-type http://www-128.ibm.com/developerworks/linux/library/l-hisock.html?ca=dgr-lnxw01BoostSocket
NMemCore	Memory Management classes and routines
CAgeable	Base class for objects which change from time to time
CAlzheimerCreator	A Creator object which forgets its data when memory is going low
CAssertionCallback
CStackFrame
CAtomicityConfig
CAtomicityConfig< AtomicityConfigSelection::CXX_ATOMIC, 32 >
CAtomicityConfig< AtomicityConfigSelection::CXX_ATOMIC, 64 >
CAtomicityConfig< AtomicityConfigSelection::GCC_ATOMIC, 32 >
CAtomicityCounter
CAttributes	Attributes are a selection of named MemCore::ChunkBase objects, each of them may carry arbitrary data
CIterator	Attribute iterator base class
CAuto	A wrapper for constructing automatic or static objects or any kind of object whose destruction shall not be managed by strong reference pointers, but reference pointers to it are still allowed
CBaseChunk	Computing the right base class for a given element
CBaseChunk< T, Base, false >	Determine the base class for typed chunks of base classes that have another memory layout
CBaseChunk< T, Base, true >	Determine the base class for typed chunks of base classes that have the same memory layout
CBaseChunk< T, T, true >	Determine the base class for typed chunks of base classes
CC0	Standardized control characters
CCache	Main administrative Cache object container
COutOfMemory	Exception that is thrown when out of memory
CCacheable	A domain for objects which may be cached
CCacheBase	Abstract base class for Cache objects
CCacheMap	A list of cache queues for each cacheable type
CCacheMultiQueue	Cache queues of different purpose
CCacheQueue	A root object that holds a tail of cacheable objects
CIterator	Iterator class
CChunk	A class which handles a chunk of memory
CFiller
CChunkBase	Base class for chunks of managed memory (any type possible)
CChunkDataAddress
CChunkDataAddress< bool >
CChunkType
CConsole	C++ API for stdio's puts()
CCopyRef	Pointer to a refcountable object which automatically initializes the pointer with constructing an object, whereby copies of this pointer object also mean copying its value
CCounter	Base class for thread-safe counting, comes with an exception-safe incrementing/decrementing counter class
CIncrementer	Exception-safe incrementing/decrementing of a counter
CCrashHandler	Usage:
CCreator	A Creator is a forwarding of some data object to its creational object
CCreatorBase	A Domain-related abstract base class for reference-counted objects which occupy some memory but are able to release it on demand
CException	Associated Exception class
CProducer	Interface class for Creatures that allow on-demand creation of Creatures
CCreatorCacheMap	A list of cache maps for each creator type
CDeferredInitializationTrait	Trait class that allows to execute some action on an object when it receives the first strong reference count in its life
CDeferredInitializationTrait< Cacheable >
CDeferredInitializationTrait< Creature >
CDeferredInitializationTrait< ReferenceBase< Object > >
CDefineTypename	Convenience class to register and un-register names for types
CDefineTypenameBase	A typemap used for adding new type names
Cdomain_cast
CDynPtr	Encapsuled pointer class for pointers pointing to derived classes
CDynPtr< ObjectBase, ObjectBase >	Base class for pointers to base classes
CDynPtrNotification
CDynPtrNotification< A >
CException	Base class for exceptions
CExecutableInfo
CFileInfo	Encapsulation for portable file times
CFiletime	Encapsulation for portable file times
CFolder	Class for reading directory entries
CFunctionStackProfiler
CFunctor	An abstract base class for scalar functions on double values
CGlobals
CAllProfiles
CProfile
CRefCounterCheck
CRelativeTimings
CSectionProperties
Ctypeinfo_equal_to
Ctypeinfo_hash
CVerboseFiles
CIncrementDeadRefPtr	Exception class for cases when an invalid (dead) ref ptr is supposed to be incremented
CIntercube	A container that holds many Interfaces
Cinterfacemap
CIntercubeIterator	Iterator object for an Intercube
CInterface	Interface template
Cinterface_cast	Interface cast: Given an Intercube, retrive the an interface object which is stored there
CInterfaceBase	Base class for Interfaces
CInterfaceData	An interface for data
CInterfaceIterationParameter
CInterfacePtr
CIOItem
CIOTracer
CIrregularity	Handling irregular occurences in the program without terminating it but instead writing a logfile with extensive information and continuing program execution
CJohnConnor
CLastKnownSourceCodeLineEntry
CLexicon	An incomplete development class for associating objects with strings, using lexical lookup and easy extraction of chapters
CIterator
CLifeSupport
Clist	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CLoader	Abstract base class for object loaders, which are used by the LoaderRegistry
Cldrpar	An internal helper class, used for type-specific reduction, holds a ref ptr to the actual object to be modified during the load process
CLoaderBase	Base class for Loaders
Cldrpar	Abstract internal helper class
CLoaderParameters	Parameters for the loading process
CLoaderProgress	A base class for callbacks during the load process
CLoaderRegistry	Database for routines that may create objects of type X
CLoaderRegistryBase
CLoaderRequest	Control structure that describes a network connection to a certain URL
Clock
CMaxExceptionCount	Exception class for the rare case of a maximum reference count being reached
CMemoryException
CMemSizeConfig
CMemSizeConfig< 4 >
CMemSizeConfig< 8 >
CMemVector	A convenience class that looks like a std::vector<>, but is actually referring to a reference-counted common chunk of data
CMultiPtrMapHash
CMutableCacheable	Cache objects that are allowed to change their size after creation
CMutableName	A class holding a string whose changes are announced to a set of listeners
CNotifier	Base class of some listener
CNamedCreatures	A convenience class to remember Creatures, which are base classes of all Creators, by name
CNotNullPtr	A type to specify non-null pointer requirements
CNoVerboseRecursion
CNoVerboseStream
CIndentator
CNullPtrException	Exception class for accessing null pointer
COmegaPtr	The Omega pointer - forcibly makes an end to objects
COmegaRef	Omega Pointer to a refcountable object which automatically destroys the object pointed to no matter how many strong references still exist to it
CPreDestructionTrait	Trait class that allows to execute some action on an object when it is going to be deleted
CPreDestructionTrait< Cacheable >
CProfiler	Profiling Support
CInfo	Source code information
CProvenance	Keeping track of provenance, where are objects created from?
CPtrMap_t
CRangeException	Exception class for range violations
CRef	Pointer to a refcountable object which automatically initializes the pointer with constructing an object
Creference_base	An convenience class to allow using std::shared_ptr and the ecosystem of the STL library in a syntax similar to the MemCore::RefPtr
CReferenceBase	Base class for objects which do reference counting
CReferenceCount	Base class for thread-safe reference counting
CReferer
CReferer< ReferenceBase< Object > >	Internal class for indirectly referencing objects, even dead ones
CRefMap	Convenience template class for mapping of keys to strong reference pointers; provides a read-only search operation using the () operator
CRefPtrTypeTrait	Default type trait for the RefPtr pointer -> operator
CReserveOnly	Helper class as pseudo-argument for Chunk<> creators
CResizableChunk	A chunk that has no elements initially but can grow
CResult
CCluster
CSarahConnor
CSaveInterfaceCreator	Abstract base class for objects that may equip a certain class object X with an interface to write this structure into a file
CSaveInterfaceCreatorBase
CSaveParameters
CSaveError
CSaveRegistry	Database for routines saving a certain class to disk
CSaveRegistryBase
CIterator	Iterator class to find all saver creators for a given object domain
CSelfInitialize	Internal class used as an argument for a computational destructor
CSelfPtr	The kind of pointer used within a ReferenceBase as part of the reference-counted object itself
Cshared_mutex
Csimplestring
CSocketError	Exception class for socket failures
CSpan	Copying the definition from C++20 standard, to provide minimal API until it's fully available, see https://en.cppreference.com/w/cpp/container/span
CSpan< T, dynamic_extent >	Specialization of a span for the case of runtime-defined lengths
CSpeakPtr
CStackTrace
CStreamSaver
CStreamSaverInterface
Cstring	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CStringChunk	A StringChunk is a chunk of character spans which references data within a contiguous storage space
CStringList	A list of strings
CStrongPtr	A reference counting pointer class which keeps objects alive as long as strong pointers to these objects exist
CCall
CCall< StrongPtr< ReturnType, typename ReturnType::reference_domain_t > >
CTerminator
CThreadPool	A pool of threads, to be used in conjunction with async()
CTimer	A class to hide system dependent methods to count seconds
Ctype
CTypedChunk	Class of chunks of a specific type, recursively derived from chunks on base classes of the given type
CTypedChunkBase	The abstract base class for chunks that have a certain type
CTypeInfo	Helper class for mapping C++ data types to objects
Ctypemap	A class for mapping C++ types to some object
CIterator	Abstract Iterator base class for typemaps
Ctypeproperty
Ctypeproperty< RefPtr< T > >
CVerboseCatcher
CVerboseRecursion
CVerboseStream	The class provides verbose printing of messages
CIndentator
CWeakPtr	A pointer class which behaves like native C++ pointers, but knows about the lifetime of the referenced objects
CWeakRefMap	Convenience template class for mapping of keys to weak reference pointers; provides a read-only search operation using the () operator
CWorkerQueue
NMETA	META is a collection of low-level template metaprograms which can be used in various situations
C__is_result_convertible
C_META_THIS
CASSERT
CASSERT< true >
CBaseClass	A trait class for determining the base class of something
CBaseClass< Eagle::bivector3f >
CBaseClass< Eagle::Column< R, value > >
CBaseClass< Eagle::DomainVector< VectorType, Domain, scalar_t > >
CBaseClass< Eagle::Matrix< R, C, Value > >
CBaseClass< Eagle::PhysicalSpace::bivector >
CBaseClass< Eagle::PhysicalSpace::point >
CBaseClass< Eagle::PhysicalSpace::vector >
CBaseClass< Eagle::point3f >
CBaseClass< Eagle::rgba_float_t >
CBaseClass< Eagle::vector3f >
CBaseClass< Eagle::Vector< T, n > >
CBSort
CBubbleSort	Todd Veldhuizen Bubblesort Metaprogram http://osl.iu.edu/~tveldhui/papers/Template-Metaprograms/meta-art.html
CBubbleSort< T, 1, Comp >
CBubbleSortLoop
CBubbleSortLoop< T, 0, 0, Comp >
CChooseWithOutPermutation	Expression template to compute the number of possible combinations when choosing K elements from a set of N without differentiating between permutations
CComparator
CFac
CFac< 0 >
CFOREACH
CFOREACH< Exec, LIST< ListType > >
CFOREACH< Exec, LIST< ListTypes... > >	Traverse a single linked type list (a LIST metatemplate)
CFOREACH< Exec, LIST< NIL > >
CFOREACH< Exec, NIL >
CFOREACH< Exec, Type >
CForEachType
Chas_concept	Check if a class has a specified concept implemented
Chas_concept< Class, Result, Concept(Args...)>	Check if a class has a specified concept implemented
Chas_member
Chas_member< Result(Args...)>	Simple check if a member is implemented
Chas_member< T, Result, Name(Args...)>	Check a checkable member
Chas_member< T, Type, Name >	Check a checkable member
Chas_member< Type >	Simple check if a member is implemented
Chas_member_template
CIF	IF Metatemplate, used to compute a certain type based on the condition
CIF< false, A, B >
Cis_callable	Template to check whether a type T is callable like a function (functor and functions)
Cis_functor	Template to check whether a type T is callable like a function, i.e
CLIST	Single Linked LIST Metatemplate
CMETA_VOID
CMetaTypeInfo
CMetaTypeInfo< std::array< T, N > >
CMetaTypeInfo< std::vector< T > >
CMetaTypeInfo< T[N]>
CNIL
CPow
CPow< N, M, 1 >
CPreciserType
CPrecision
CPrecision< char >
CPrecision< ddouble >
CPrecision< double >
CPrecision< float >
CPrecision< int >
CPrecision< long >
CPrecision< long double >
CPrecision< qdouble >
CPrecision< short >
CSwap
CSymmetricChooseWithOutPermutation	Expression template to compute the combinatoric formula used for the number of elements of a supersymmetric cubical: (2n-1)!
CTypeDescriptor	For native and array types
NPosixThreads
CMutex
CThread
CCleanUp
CError
CKey
Nqrcodegen
CBitBuffer
Cdata_too_long
CQrCode
CQrSegment
CMode
Nstd	STL namespace
Chash< MemCore::StrongPtr< RefType, ObjectBase > >
Chash< MemCore::TypeInfo >
Chash< MemCore::WeakPtr< RefType, ObjectBase > >
NTraum	Traum - Integration and Solving Differential Equation in Time and Space, i.e
CAdaptiveRungeKutta	Explicit Runge Kutta, defined via a butcher tableau
CEvolutionVars	Set of variables that are updated at each integration step but keep their values from the previous step
COutputVars	Set of variables that contain output information
CStatisticVars
CBTFehlberg45	Butcher table for Fehlerberg4(5) method see Hairer, Norsett, Wanner, second edition 2000, page 176
CBTMerson45	Butcher table for Merson4(5) method see Hairer, Norsett, Wanner, second edition 2000, page 167
CBTRk32	Method of Griepentrog
CBTRk38r	Runge 3/8-Rule method
CBTRk4	THE Runge method
CButcherTableau	Template class specifying a butcher table:
Cdop853	Runge-Kutta solver of order 8 with dense output
Cstatistic_vars
Cdop_vars
CDynamicArray	A really simple array class that allows to set the size of the array at runtime (
CEuler	A solver implementing the so called explicit Euler method, using constant stepsize: y_{n+1} = y_n + h * f(t_n,y_n)
CEvolutionVars	Set of variables that are updated at each integration step but keep their values from the previous step
COutputVars	Set of variables that contain output information
CStatisticVars
CIntegratePath853
CIntegratePath853d
CIntegratePath853f
CIntegratePath853ld	DOP853 for second order differential equations solved using long doubles
CIntegrator	Abstract base class for integration over a certain real type, e.g
CIntegratorBase	Abstract base class for integrators
CIntegratorImpl
CIntegratorImpl< double >
CIntegratorImpl< float >
CIntegratorImpl< long double >
CRk4	A solver implementing the so called explicit RK4 method, using constant stepsize: y_{n+1} = y_n + h/6( k1 + 2k2 + 2k3 + k4)
CEvolutionVars	Set of variables that are updated at each integration step but keep their values from the previous step
COutputVars	Set of variables that contain output information
CStatisticVars
CSecondOrderDiffEquationIP853
CSecondOrderIntegrator853
CSecondOrderIntegrator853< double >
CSecondOrderIntegrator853< float >
CSecondOrderIntegrator853< long double >
CVirtualSecondOrderDiffEquation	Implementation of a differential equation of 2nd order for the dop853 solver
NVish
CFilter
CInput	An input slot for Vish Objects, bound to a specific type
NWizt	The Vish namespace
NRenderContextUpdater
CObjectContextSlot
CObjectContextValue	Helper class for automatic updates of render parameters from constant values that are modified via context-relative object member functions whereby the object is an arbitrary object that is referred to via a standard C pointer
CAcceptionGenerator
CAcceptList
CAcceptListIterator	Accepting arbitrary types directly as second argument of VCreator or VObject::AcceptableInputTypes
CAcceptListIterator< AcceptList< AcceptType, NextAcceptList > >
CAcceptListIterator< META::LIST< AcceptType, NextAcceptList > >	Using a META::LIST<> as second argument of VCreator or VObject::AcceptableInputTypes
CAcceptListIterator< META::NIL >	Using a META::NIL as second argument of VCreator or VObject::AcceptableInputTypes rejects all input objects
CAcceptListIterator< void >	Using void as second argument of VCreator or VObject::AcceptableInputTypes rejects all input objects
CAccessMemory	RAII access to writeable mapped memory
CAccessMemory< const T >	RAII access to read-only mapped memory
CAgeable	Base class for objects which change from time to time
CAnemone	Abstract object for elementary render objects
CSpecializedTentacle	Base class for Tentacles that are specialized for a specific purpose
CTentacle	Base class for components that need to be attached to an Anemone to make it visible
CActivator	Helper class for Tentacles, allows exception-save enabling and disabling of Tentacles
CTentacleIterator	Tentacle iterator base class
CAnemoneBasicCreator	Internal intermediate class bundling some caching functionality on AnemoneCreators
CAnemoneCreator	The Anemone Cache, called the Seagrass, is based on Anemone objects
CAnemoneCreatorBase	The Anemone Cache, called the Seagrass, is based on Anemone objects
CAnemoneCreatorContext	Convenience class to pair a render context and an AnemoneCreator
CAnemoneNutrition
CApplicationIterator
CApplicationProperties	Application properties
CApplicationQuitter	Registerable objects to be called by some plugin when the application is supposed to quit soon, to be used to flush caches and close files in a clean way yet before any plugins are unloaded
CAtlas
CBaseCursor3D
CCursorState
CBokeh	Implementation of a RenderCategory::CAMERA_LENS_OBJECT
CMyState
CBoundingBall	Bounding container implemented by a ball
CBoundingBox	A coordinate-parallel bounding box in three dimensions
CBrush	A data-driven description of a Brush to select points from a set of points, providing an list of indices
CMetric	For analytical shapes of a brush, allows to model spheres, ellipsoids, ellipses, cylinders..
CBufferArray	Base class for OpenGL buffer objects, which are the building blocks of Vertex Buffer Objects
CError	Exception class that might happen during loading of buffer arrays
CInconsistency	Exception class thrown when an array of incompatible number of elements is going to be added to a given VBO object
CMapMemory	API For glMapBuffer
CBufferID	Base class for OpenGL buffer id's
CCallbackInputNotifier	A value notification class that awaits value changes for a specific type and forwards the event to the member function of a given object
CCallbackMutableInputNotifier	A value notification class that awaits value changes for a specific type and forwards the event to the member function of a given object
CCatchStatus	A convenience class that can be added as base class to any VObject
CCategorizedRenderObjects
CChunkBase	Base class for chunks of managed memory (any type possible)
CClippingPlanes	VRenderObjects that want to support clipping planes may derive from this class, must call initializeAnemone() in their own respective code and insert the setClipDistances() code into their vertex or geometry shader code
CColorArray	Base class for OpenGL buffer arrays related to colors
CColorizer	A vish object component (aka vish skale) that references some colormap and takes care of its parameter handling
CColormap	Abstract base class for colormaps, which are transfer functions from a floating point value into RGBA values
CColormapReference	Helper class for attaching colormaps to MemCore::Intercubes
CCommandLineParser	Basic parser for options and arguments
CCompareSlotsByName
CComputationDispatcher
CComputeShader
CCoral	A base class for vish objects that provides Colormaps
CCreateVertexArray
CCreateVertexArray_nD
CCreateVertexArray_nD< Type, ArrayType, 0 >
CCreationInfo
CCreatorCreator
CCrossSectionCam
CCursor3D
CCursor3DProperties	Description of parameters for drawing a 3D cursor shape within a shader
CDefaultAnemoneInitializer
CDefaultTypedSlotSaveProperty	A type trait class defining a the default property of certain types used in input slots, telling if the value of these types should be saved when the status of an object is saved
CDeferredRenderObject	Base class for objects that make use of deferred rendering
CDeferredRenderer	This class is an abstract interface for setting up a Framebuffer and rendering it
CMyState
Cdeque	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CDisplayList
CDisplayListCreator
CDisplayListTentacle
CDrawArrays	An Vertex Buffer Object renderer that implements the glDrawArrays function
CElementBuffer
CEnableTexture
CEnum	Enumeration type
CExpectation	Define that we are expecting a certain number of bytes from an VSocketAction::Receiver object
CFlagList	A set of strings associated with a boolean, good to store true/false properties for each string
CFloatOrigin	By default, the Camera in Vish is NOT translated to the location of the specified observer, but it resides at location (0,0,0)
CFog	Provides a fragment shader function of type:
CFragmentShader	An OpenGL fragment shader
CFramebuffer	Class interface to the OpenGL Framebuffer API
CBind	Exception-safe framebuffer binding with framebuffer stack support
CGeometryShader	An OpenGL geometry shader
CVerticesIn	Enum member N tells how many vertices are available per call of the GeometryShader
CGetMessage
CGimpIcon	A map of ref pointers to input objects
CGLBindableBaseBuffer
CGLBindableBuffer
CGLBuffer	Implements functionality related to an OpenGL buffer object
CGLBuffer_with_bind
CGLCache	The GLCache is a mapping from certain keys to an OpenGL DisplayList object
CGLCacheCreator
CGLCacheError
CGLCacheFactory	The 3rd level of the OpenGL Cache, retrieving actual GL objects such as VBO's or TextureCreators
CKeyMap
CGLCacheFactoryPtr	A convenience class which is basically a reference to a GLCacheFactory and forwards all its member properties to this pointer
CAssignator	Proxy class for creating GL Objects
CConstAssignator	Proxy class for constant access to GL Cache objects
CGLCacheInterfaceNotFound	Exception that is thrown if the type is not found on GLCache access
CGLColormap	A colormap can be used in two ways: as 1D texture, or as colortable
CGLContextChecker	This is a convenience class to check if an OpenGL context is currently active and available
CContextAvailable
CGLDebug
CGLError	Exception class for errors during rendering
Cglew	Interfacing the glew library
CInfo
CGlewContext
CHandle
CGLFontManager
CGLFontManagerCreator
CGLImageTileProcessor	An interceptor class for rendering, allows to process pixels before they are saved to disk
CGLInvalidOperation
CGLMapMemory
CGLMultisampleTexture2D	A multisampling texture, to be used with framebuffer rendering and shaders
CGlossyLines	A helper class to draw lines with a shiny, glossy texture
CGlossyTexture	A one-dimensional texture that simulates a glossy shade
CParameters	A bunch of parameters that allow control of the gloss
CRender	An exception-safe way to call the beginRender() and endRender() routines of the GlossyTexture
CGLOutOfMemory
CGLPainter	RenderBasin Painter Object implementing a call to OpenGL's glDrawArrays()
CGLPixelBuffer	PBOs allow to perform asynchronous pixel data transfers
CGLProgram	An OpenGL shading program
CCannotAssignUniform	Exception class if a uniform variable in a shader could not be assigned
CError	Local error class to serve as base class for all exceptions that are thrown by GLProgram operations
CLinkerError	Exception that happens when there was a problem with linking compiled shader programs
CNoSuchAttribute	Exception thrown when a vertex attribute was not found
CNoSuchUniform	Exception thrown when a uniform variable was not found
CNotSupportedCall	Exception class if a GL call is not supported
CUninitializedTexture	Exception thrown if a texture is supposed to be used that has not been initialized
CGLRenderAble	Abstract base class for objects that can be rendered via OpenGL
CGLRenderer	A renderer class that captures OpenGL renderings from a viewer object into some offline buffer, using FrameBuffer objects with multisampling
CGLShaderUniformFunctor	A functor class for applying operators to uniform shader variables that are assigned directly from a Vish slot
CGLSL_View.CameraSettings
CGLSL_View.FrustumCornerPoints
CGLSL_View.Viewport
CGLState
CGLTexture
CGLTexture1D	Shortcut class name for one-dimensional textures
CGLTexture2D	Two-dimensional textures loaded from a dataset
CGLTexture2DBase	Shortcut class name for two-dimensional textures
CGLTexture3D	Shortcut class name for three-dimensional textures
CGenerator
CGLTextureBase	Base class for OpenGL Texture ID's
CGLTextureID	Better base class for OpenGL Texture ID's
CGLTextureTentacle
CGLType
CGLUniformBuffer
CHotKey	Base class for Vish Objects that act on a single, configurable hotkey in the viewer
CKey	Convenience class to handle additional hotkeys
CHTMLInputCreator
CHTTPServer	Define that we are expecting a certain number of bytes from an VSocketAction::Receiver object
CAcceptConnections	Callback action that is invoked when a new client connection to the server port
CClient	Network Client Callback: action performed when an HTTP request has been accepted and is sent to the server
CHybridScene	An internal class to categorize render objects and iterate over them according to their properties
CIdentifierIterator
CIdentifierWithUrl
CImageTile	A tile as part of an image
CSize	Local size class, used for tiles
CImageTileProcessor	Interface class for processing color data acquired by rendering
CIndexBuffer	OpenGL Index Buffers for specific data types
CElementPainter
CIndexBufferObject	Base class for index buffer objects
Cinfo	Input type to display some information about an object
CInputNotifier	A value notification class that awaits value changes for a specific type and forwards the event to the member function of a given object
CInteractive	Base class for Vish Objects that allow interaction with an input device such as the mouse or keyboard in the 3D Viewer (or any other input device providing a VInteractionEvent )
CInteractor	An interaction element to steer the behavior of the viewer in a GUI
CIntercube	A container that holds many Interfaces
Cinterfacemap
CInterface	Interface template
CKBuffer	Abstract class implementing a K-Buffer
CKeyStringNotFound
CLabel
CLabelSet	A mapping from integer values to Labels, i.e
CLayeredMultiViews	Handling multiple views in multiple layers in multiple viewports
CLayers
CLayeredRenderResult
ClessValueSetPtr	Key comparison functor, a Strict Weak Ordering whose argument type is a ValueSet; it returns true if its first argument is less than its second argument, and false otherwise
CLineDescriptionTentacle
CLineGeometryProgram
CLineGlowShadowProgram
CLinePointProgram
CLineProgram	Base class for shader programs enhancing the display of lines
CLineStippleProgram
Clist	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CListID
CList
CLoadViaScriptlet
Cmap	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CMapMemory	Base class for memory mapping
CMatrixOrArray
CMemberID
CMessageRetriever
CMetaGLViewerCreator	Implementation of a viewer creator using an existing viewer class that can be called with a ViewerCreatorEnvironment as parameter
CMetaGLViewerCreatorBase	Abstract plankton class for objects creating OpenGL-enabled viewer windows
CMetaViewer	Base class for object handling one or more viewers, i.e
CMetaViewerCreatorBase	Abstract plankton class for objects creating viewer windows
CMetaViewerCreatorEnvironment	Abstract class describing the environment when creating viewer windows
CModelViewMatrix	A helper class for exception-safe pushing and popping of the OpenGL model view matrix
CMovieRecorder	Base class for Movie recorder classes
CMSDeferredObjectDisplay	Base class for displaying the rendering output of other objects via multisampled deferred rendering
CMSDeferredRenderObject	Base class for objects that use multisampled deferred rendering
CMultiSampleDeferredRenderer	A deferred render object which allocates a multisampling depth and color texture which can be used in an implementation of renderFramebuffer() as textures:
Cmultimap	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CMultipleStringSelection	A multilist container ..
CMultiRange
Cmultiset	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CMultiviewOVR
CMultiviewCapability	Check whether the OVR Multiview and other multiview-related extensions are available
CMultiviewRenderable	Base class for objects that can render to multiple views at once, such as needed for single-pass stereo rendering
CMutableInputNotifier	A value notification class that awaits value changes for a specific type and forwards the event to the member function of a given object
CmyVStreamCreator
CNamedRenderExceptions	A named list of render exceptions
CNetworkObjectHtml
CNotifiedValueIterator
CObjectQuality	Classification for the quality of objects that may be provided by some Creator
CObjectSelection	A general-purpose class to select a set of Vish objects and order them by priority
COfflineRenderResult
Cpair	STL class
CPBO
CPickList	The result of a pick action
CPixelBuffer	Class to receive pixel colors and depth information
CPixelZoom	Pixel zoom parameters
CPrintCreatorIterator
CPrintIterator
CProceduralVertexAttribute
CProfiler	Profiling Support
CInfo	Source code information
CProgrammable	A helper class to create a shader program from either intrinsic code, or external files, as given under the specified name in Programmable::CompileShader()
CShaderPrefix
CShaderSegment
CProgrammableGeometry	A helper class to create a OpenGL geometry shader programs
CProjectionParameters	Projection parameters for rendering
CRange	A range of double values, to be used to map certain values from one range to another
CReferenceBase	Base class for objects which do reference counting
CRemoteViewer
CAcceptConnections	Callback action that is invoked when a new client connection to the server port
CCommunicator	Network Communicator Callback: action performed The receive() callback function is responsible for parsing the HTTP request and invoke appropriate actions
CFrameData
CRemoteVish
CAcceptConnections	Callback action that is invoked when a new client connection to the server port
CCommunicator	Network Communicator Callback: action performed The receive() callback function is responsible for parsing the data stream and invoke appropriate actions
CMyActionNotifier
Crender_lambda_traits
Crender_lambda_traits< Ret(Class::*)(Arg1, Arg2) const >
CRenderAble	Abstract base class for objects that can be rendered
CRenderTime	Render this object (calling safe_render() ) including timing measurements
CSensorView	Extended information as provided by a sensor on the screen such as the mouse cursor
CSubContext
CTransparencyHandler	Transparency handlers are special objects that handle other transparent objects
CRenderBasin	Base class for abstract render operations
CBuffer	Encapsulation of buffer objects
CComputationDispatcher	Base class for compute shader executions
CFloatedOrigin	Support for FloatingOrigin (class FloatOrigin )
CIllumination	A render tentacle that activates all light sources that are defined through shader code
CPainter	Base class for paint operations
CProgram	Base class for abstract shader/render programs
CParameters	Program parameters that need to be set before linking shader stages
CParameters.Geometry
CParameters.Geometry.Output
CRangedPainter	Intermediate class for painters that may cover just a subset of the entire domain
CRenderFlag	Base class for render flags
CRenderParameter	Base class for render parameters, which are Anemone::Tentacle instances that implement an updateValue() function via a provided functor to be invoked by Anemone::updateValues()
CContextUpdater	Helper class for automatic updates of render parameters from input slots using a context-aware modifier member functor
CContextValue	Helper class for automatic updates of render parameters from constant values that are modified via context-relative object member functions
CFunctionalUpdaterWithContext	Update a shader value of type ShaderType from a Slot of type SlotType using a function that takes a VRenderContext and the SlotValue as arguments
CTypedUpdater	Helper class for automatic updates of render parameters from input slots
CTypedUpdater< Type, void >
CUpdater	Helper class for automatic updates of render parameters
CRenderTimer	Base class for render timers
CShaderProgram	Helper struct for alternative call to createProgram() with better uniqueness of arguments
CStorageBufferTentacle	Storage buffer objects
CTextureStorageFormat	Enum for the storage type of the texture, which will affect memory utilization on the GPU
CTextureTentacle	Base class for textures, child classes are implemented by Renderers
CTypedRenderParameter	Helper class for implementations of render parameters that operate on one specific type
CUniformParameter	Base class for uniform variables in programs
CVertexAttribute	A Vertex Attribute is a set of data which sits available on each vertex of some rendering
CRenderCategoryConstraint
CRenderException	Exception class for errors during rendering
CRenderNamespace	Enums used for rendering
CBlendFactor
CGLSLSection	Helper class to automatically insert BEGIN and END comments when procedurally creating GLSL code
CLighting	A set of light sources
CLightSource	Base class for light sources in shaders: A light source provides a light function, defined in glsl, and a set of parameters that are used by this light function
CProgramVariables	A collection of variables that are parameters to shaders, also known as uniforms in GLSL
CRenderSlice
CRequestExecutor
CMaxRequestExecutor
Crgba_float_t
CSampledSize	Size class for two-dimensional images with multisampling
CScriptletCreator
CSeagrass	The Anemone Cache, called the Seagrass, is based on Anemone objects
CStorageBufferStatistics
CSecondaryColorArray	OpenGl buffer array base class to provide secondary colors
CSensorArea	Extended information as provided by a sensor on the screen such as the mouse cursor
Cset	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CShader	Base class for OpenGL shaders
CError	Error class for Shader-related problems, for instance compilation errors
CShaderConditionals	Base class to ease setting a VSlot as shader defines
CShaderInjector
CShaderInjectorBase
CShaderLightSource	Base class for light sources that are defined via shader functions with constant shader code, i.e
CLightState
CMyLightSource
CSize	Size class for two-dimensional images
CMinus
CSlotEvaluator
CSlotEvaluator< 1, SlotList... >
CSlottify	Utility class for dealing with conversions from VObject and its Slots to strings and vice versa
CCollectionOfLines	A collection of lines, such as parsed from an input string or file
CGetObjectInfo	Callback object for parsing object slot information
CObjectsWithSlots	A set of lines with object name prefixed
CSlotCollection	A set of lines with only slot information, but no containing objects
CSlotInfo	Information describing a specific Slot
CSpaceNavigation
CSSBOManager
CStatusIndicator	Base class for convenient messing around with the status to be displayed for a certain object
CStereoDraw	Base class for render objects to implement a stereo render function that draws to the left and right eye directly as enabled by
CStorageBufferID
CStorageBufferTentacle	Storage buffer objects
CStorageFlags	Encapsulation of https://registry.khronos.org/OpenGL-Refpages/gl4/html/glBufferStorage.xhtml
CStreamString
Cinput_string
Cstring	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CStringSelection	A list of strings with one of them selected
CStrongPtr	A reference counting pointer class which keeps objects alive as long as strong pointers to these objects exist
CCall
CCall< StrongPtr< ReturnType, typename ReturnType::reference_domain_t > >
CTask
CTexCoordArray	Base class to store buffer arrays for texture coordinates
CTEXTURE
CTextureBase	Base class for Texture objects, supports cache management
CGenerator
CTextureBuffer	It's a texture that knows about a buffer array
CTextureCreator	A handler for texture creation and release
CTextureID
CTileRenderResult
CTimeDependent	Base class (vish scale) for time-dependent objects Synopsis: Derive the VObject from this base class to get a time parameter that is consistent with other usages
CTouchable	Abstract base class for objects that can be touched
CTouchList	Abstract base class for objects that can be touched
CTransformOperator	Implements an operation that affects a 3D rendering, in whatever way
CFunctor
CTransform	An exception-safe helper class to invoke the transformation functor
CTypedBufferArray
CTypedBufferArrayBase
CTypedColorArray	OpenGl buffer array to provide colors
CTypedNormalArray	Note: stuff has always 3 components
CTypedPBO
CTypedSecondaryColorArray	OpenGl buffer array to provide secondary colors
CTypedSlot	An input slot for VObjects, bound to a specific type
CSlotCreator	The associated Slot Creator
CTypedSlot< bool[]>
CTypedSlotCreator	A registry for the runtime-creation of typed slots, allowing creation of type-specific VObject input parameters without knowing their types explicitly
CTypedTexCoordArray	An OpenGL buffer array to store texture coordinates
CTypedTextureBuffer
CTypedUniformBuffer
CTypedValueCreator	Implementation of value creators
CTypedVectorUniformBuffer
CTypedVertexArray	Base class for OpenGL buffer array objects operating on vertices (points), independent from a specific type
CTypedVertexAttribArray	OpenGL buffer array for arbitrary vertex attributes
CTypedVertexBufferArray
CTypeNotFound	Exception that is thrown if the type is not found on GLCache access
CTypeSpecificGLCacheFactory	This is semantically a
CKeyMap
CTypeSpecificGLCacheFactoryPtr	This is semantically
CUndoStack	Helper class to provide two input actions for undo/redo operations
CUniformBuffer
CUniformBufferRegistry
CUniformVertexAttribute
CUniqueQueue
CURenderException	Exception class for user-thrown errors during rendering
CUserRenderException
CVAbstractValue	Implementation of a VISH type via procedural referencing instead of instantiation
CVAbstractValueParameter	Making parameters for abstract values
CVAcceptInfo	An intermediate class that holds information about what kind of input objects a certain VObject accepts
CVAcception	Accept information for a given VObject
CVAcceptList	A list of accept informations
CVAcceptListTracer
CVAction	An action object that allows to schedule objects for request execution, i.e
CVActionNotifier	Notifier object for actions
CCreationSource	An optional property of the VObjectCreation()'s CreationContext telling why the object was created, meaning: which slot requested the creation of this object
CProgress	Helper class for following the progress of some slow activity
CWarnInfo
CValueAction	Route a notification event to an object's member function
CValueActionBase	An abstract Value notifier that re-routes valueChanged events to virtual actions
CValueCache	Cache values of VSlots in an Interface and allow checking if these values have changed
CValueCacheable	Base class for caching values of VSlots relative to an Intercube
CValueMap	List of the components of a compound type
Citerator	Functor base class for iteration over the components
CVParList
CValueNotifier	Base class for objects which are informed when a value is changed
CValueNotifierList	A node which serves to identify multiple instances of input alternatives for a certain value
CList
CValuePool	A ValuePool is the home of local values of certain input objects
Citerator	An iterator to traverse the existing value pools
CVarMap_t
CValuePoolCreator
CValuePoolProvider	Procedural interface for requesting a ValuePool
CValuePoolReferer	Abstract base class for objects that may provide objects that provide an active value pool (two-fold indirection)
CValueSet	A set of values
CValueSetNotFound
CValueShadowIterator	Iterator class for values stored in multiple ValuePools (also called "shadows" of a variable)
CVBO	A vertex buffer object, encompassing many vertex buffer arrays and a rendering routine with pre- and post execution code
CError
CRenderer	The rendering operation is formulated via a Renderer object that is supposed to implement OpenGL calls
CVBOCreator	Creator for VBO objects
CVCamera	The Camera object for OpenGL operations in VISH
CVCameraBase	Base class for camera objects
CVCameraLens	Implementation of a RenderCategory::CAMERA_LENS_OBJECT
CVCameraSet	A list of renderable objects, sorted in layers
CVChart	Specify a coordinate system
CVChartDependent
CVChartList	Specify a coordinate system
CVChartSelector
CVComponentValue
CVConnectable	Intermediate class managing connections between objects
CVConnectionTypeColors	A helper class that serves to associate types with color values, that are stored a text
CVConnectionValidator	A base class for objects that want to be informed if the connectivity if an object's data flow graph has changed
CVConnectionValidatorList	A base class for objects that inform VConnectionValidator about their validity
CVContext	A Context is always local and unique for each call
CAddendum	Container for additional data specific for this Context
CRealTime
CTimeInterface
CVCotask	Base class for VObjects (to be used via multiple inheritance) to ease asynchroneous computations in a thread
CVCreationPreferences	A certain object (especcially input types) might have multiple implementations by the GUI or alternative input mechanism
CConstIterator
CIterator	Iterator class
CVCreator	Given some VObject, this is the accompanying Creator object that may be used to create VObject's on request
CVCreatorCategory
CIterator	Iterator base class for the VCreatorCategory::iterate() function
CVCreatorMap
CVCreatorProperties	A set of properties for a VCreator , VCreatorProperty
CVCreatorProperty	A set of property elements for VCreator objects
CVCreatorPropertyBase	Base class for VCreator property elements
CVCreatorPropertyElements
CVDataFlowGraph	Request structure
CCmpObjectPtrs
CEdge	Information per edge
Cvector	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CVEnumSelection	Container to hold a selection of strings with one of them selected
CVEnvironmentRenderObject	Base class for VObjects that may do some rendering
CVertexArrayCreator
CVertexArrayCreator< VGL_NAMED_VERTEX_ATTRIB >
CVertexArrayCreator< VGL_TEX0_COORDINATES >
CVertexArrayCreator< VGL_TEX1_COORDINATES >
CVertexArrayCreator< VGL_VERTEX_COLORS >
CVertexArrayCreator< VGL_VERTEX_COORDINATES >
CVertexArrayCreator< VGL_VERTEX_NORMALS >
CVertexArrayCreator< VGL_VERTEX_SECONDARY_COLORS >
CVertexArrayObject	Limitations of using OpenGL fences for VAO and buffer upload readiness
CVertexAttribArray	Base class for arbitrary vertex attribute arrays
CVERTEXBUFFER
CVertexBuffer	Explanation of buffer residency and upload strategy on drivers where persistent/coherent mappings are backed by host-visible system memory
CVertexShader	An OpenGL vertex shader
CVFilter	Implements a data filter, or computational object in general
CVFindLongestObjectInputName	Class to find the longest input (parameter) name
CVFrameBuffer	Encapsulation of a framebuffer, which is used to collect image rendering results
CException
CGrab	Callback class for grabbing frames
CException
CLayer
CMovieManager	A movie manager is base class for frame grabbers to manage rendering frame sequence
CMetaInfo	Meta information available per frame
COffScreenRenderRequest
COutputFormat	Base class for image frame sequences
COutputFormatProvider	Creator object for output formats
CRenderer	Base class for a renderer that is able to provide some pixel data
CLayeredRenderResultWithError
CRenderError
CVGlobals	Global Datastructures
CModuleInfo	Information about plugins
CModuleRegistry_t	Registry for all plugins
CVGLRenderContext	A special vish context that is passed to VGLRenderObjects when rendering
CVGLRenderObject	Base class for objects that implement a drawing routine using OpenGL
CVGLShaderPlatformDefines	An interface to the Seagrass
CVGraph	Required operations:
CView	Defining the view in a rendering scene via the projection parameters and the rotation / translation due to camera settings, as given by a VCamera
CViewer	A viewer is a Vish object that takes a VSceneLayers as input (a selection of Vish objects which can render something) and provides a FrameBuffer as output
CFrameCompletion	Callback objects to interface with frame completion during rendering
CFrameGrabber
CViewerState	Class describing the state of a Viewer , to be communicated via a PolyOutput from each Viewer object to a MetaViewer object that bundles many Viewers
CViewportGeometry	The properties of the viewport
CVInput	Implementation of input objects
CVInputBase	Base class for objects providing an input of any kind
CVInputClass
CVInputClassRecognition	By default, all slots are class zero
CVInputCreator	Template class for convenient definition of creators of objects providing a multiple input types
CVInputCreatorBase	Base class for objects that may create objects that serve as input facilities
CVInputCreatorIterator	Abstract base class for iterators of input objects
CVInputRegistry	Templated convenience class that encompassess all VInput registry functions that are associated with a certain type
CVInputValue	A VInput that actually stores its type here
CVInputValueTrait
CVInputValueTrait< bool[]>
CVInputValueTrait< Eagle::FixedArray< double, 2 > >
CVInputValueTrait< Eagle::FixedArray< double, 4 > >
CVInputValueTrait< Eagle::FixedArray< int, 3 > >
CVInputValueTrait< Eagle::metric33 >
CVInputValueTrait< Eagle::PhysicalSpace::bivector >
CVInputValueTrait< Eagle::PhysicalSpace::point >
CVInputValueTrait< Eagle::PhysicalSpace::rotor >
CVInputValueTrait< Eagle::PhysicalSpace::tvector >
CVInputValueTrait< Enum >	Type trait for Enum types as input objects
CVInputValueTrait< ImageTile >
CVInputValueTrait< info >
CVInputValueTrait< MemCore::RefPtr< Type > >
CVInputValueTrait< MetaViewerInputType >
CVInputValueTrait< Options >
CVInputValueTrait< Plane >
CVInputValueTrait< rgba_float_t >
CVInputValueTrait< std::array< Type, 1 > >
CVInputValueTrait< string >
CVInputValueTrait< TransformOperator >
CVInputValueTrait< VCamera >
CVInputValueTrait< VCameraSetPtr >
CVInputValueTrait< VChart >
CVInputValueTrait< VFrameBuffer >
CVInputValueTrait< VGraph >
CVInputValueTrait< VImageTileProcessor >
CVInputValueTrait< VInteractionEvent >
CVInputValueTrait< VMultiPointerDevice >
CVInputValueTrait< VObjectStatus >
CVInputValueTrait< VRenderAble >
CVInputValueTrait< VScalarFunctor >
CVInputValueTrait< VSceneLayers >	Type trait to allow using VSceneLayers as inputs for Vish objects
CVInputValueTrait< VSocketAction >
CVInputValueTrait< VThreadManager >
CVInputValueTrait< VTime >
CVInputValueTrait< VTypeTemplate >
CVInteractionEvent	Communication type for mouse and keyboard interactions
CGrabReason
CInteractionGrabber	The interaction grabber property of a VInteractionEvent contains a list of objects that are allowed to retrieve these events
CVishSaver	A saver functor
CCreator
CCreatorBase
CCreatorCreator
CVLensBase	Optional Base class for Lens objects with support for stereo and multiview projections
CVLightSource	Base class for render objects implementing a light source
CVLogger	Log messages, usually for analysing the program's internal flow for debugging purposes
CContext	Set logging context with auto-cleanup
CIndent	A class for setting a temporary increment of the indentation of logging text; it allows to indent logged text automatically during the lifetime of the Indent object
CState	Describes a thread-local state of the logging process
CVLogMessager
CVLogStreamCreator
CVManagedDomainObject	Domain-specific object creation database
CInit
CVManagedObject	Common class for all objects that may be created through the database
CModuleIterator	Abstract iterator class
CVRemoveItem	Callback object when unloading a module
CVManagedObjectBase	Virtual base class for manageable objects
CVManagedObjectIterator	Abstract iterator class for iterating over a Domain of objects
CVModule
CVModules	Namespace-like class for handling plugins
CIterator
CVMultiPointerDevice
CPoint
CVNutrition	Base class for objects that provide data processing on a file basis, such as converting file formats
COutputScript
CVObject	Generic base class for all VObjects
CExecutionStatus	Exception class that might be thrown by update() and is handled in the data flow traversal
COutputObjectIterator	Iterator callback object for searching and finding output objects
CVObjectAge	Internal class used to store various ages of objects
CVObjectException	Base class for exceptions that refer to VObjects
CVObjectInfo	Additional information that can be attached to some object status, such as extended log messages or warnings
CVObjectIsOutOfMemory	Base class for out-of-memory exceptions that occur in a VObject's update() function
CVObjectIterator	Iterator functor to be used for iterating over the parents of a certain VObject
CVObjectStatus	Description of the status of an object, primarily to be used within a GUI display
CVObjectUserInfo
CVOperatorCache	The Operator Cache is used to memorize the result of some update() operation, and to provide it to other routines knowing the same value pool context
CCache	A Cache object, that assigns an OperatorCache with each VObject
CVOutput	Output properties of an object
CVOutputAssignmentContext	An internal type to pair VOutput's and ValuePool references
CVOutputIterator	The callback class for iterating over the output objects (i.e
CVParameter	A VParameter enables VObjects to retrieve certain values
CVParameterConnectionConstraint	Abstract base class to allow adding constraints on parameter connectibility
CVParameterObjectCreator	Base class for using a component of an object as parameter
CVPipeline	Convenient template to define VCreator objects with inputs and outputs
CVPipeline< AcceptList< InputTypes >, FunctionObject, OutputType >
CVPipeline< AcceptList< InputTypes >, FunctionObject, void >
CVPipeline< InputType, FunctionObject, void >	Reduction of the VPipeline to no output type, which constitutes a Sink
CVPipeline< void, FunctionObject, OutputType >	Reduction of the VPipeline to no input type, which constitutes a Source
CVPipelineCreator	A VPipeline that gets the input/output type definition from the specified FunctionObject
CVPointer	A convenience template class to use weak pointers on objects that are not yet defined, but known to be derived from class VManagedObjectBase
CVPolyOutput	An output that adds itself as input slot to all existing objects of a given type
CVProxyObject
CVRenderAble	A reference to a RenderAble object
CVRenderContext	Base class for objects that may display something
CDepthMode	Support for depth modes as discussed in: https://stannum.io/blog/0UZsbE
CFont	Base class for fonts
CType	Bits describing the properties of a font
CJitter	A structure to define a little offset from the main camera settings
CModelViewMatrixState	Abstract base class for a status that preserves the current model view matrix
CVRenderContextBasin	Base class for render activities that allows to create various buffer objects via the RenderBasin and provides an evaluation context, yet without explicit render-specific functionality
CVRenderInterruptor
CVRenderObject	Base class for objects that implement a drawing routine
CVRenderOptionUpdater	When dealing with Render Anemones, it is frequent that the Anemone does not need to be re-created with each change of inputs
CVRenderPrecision	Constraints for rendering, sustained across display contexts
CVRequest	Request structure
CID	An identification object to trace identity of requests
CExecutionLevel
CIncomplete	Exception class indicating that some request could not be completed
CVSaveable	Base class for objects that can be saved to some URL
CSaveIterator	Accompanying iterator class
CVScalarFunctor	Implements a function that yields a scalar value, given some floating point input
CFunctor
CVScene	A scene is a class to render a collection of objects
CVSceneObjects	A list of renderable objects, sorted in layers
CVScheduler	Scheduler for VISH Objects
CVScriptable	Base class for objects that may be accessed via a script interface
Citerator	Local iterator to allow traversal of all functors
CMap
CVScriptAction	Invoking class member functions through the VScript API
CVScriptActions
CVScriptFunctor	Implementation of a function that may be called through a script interface
CVScriptLoader
CVScriptParameters	A set of named function call arguments
Citerator
CMap
CVScriptParser
CVScriptTypedValue	A textual encoding of a certain value, together with optional comment and default value
CVScriptValue	A polymorphic value of a function call argument or function return value
Citerator
CMap
CVSimpleStreamObject
CVSink	Implements a data sink
CVSink< FunctionObject, void >
CVSkale	Helper class for VObject components (so-called Vish Skales)
CVSlot	Intermediate class for storing (named) references to parameters
CEmpty	Internal type for computational constructor
CVSlotChangeInfo	Vish I/O data structure to communicate a set of Slots
CVSlotContainer	Intermediate class managing VSlots
CDeferred	Internal helper class used for the construction of VOutput objects
Cin	Input types
Cin< bool[], ExpertLevel, void >
Cin< bool[], VSlotContainer::InvalidExpertLevel, void >
Cin< Type, ExpertLevel, void >
Cin< Type, VSlotContainer::InvalidExpertLevel, void >
Cinout	Input types that are also visible as outputs, i.e
Cinout< Type, void >
Cout	Output types
Cout< Type, void >
CVInputSet
CVSlotGlobals	Internal helper class
CVSlotIterator	The callback class for iterating over the input objects (i.e
CVSlotSet
CVSocketAction	Abstract interface class that is to be implemented by some application
CConnector	Functor object for callbacks when new clients connect to a server
CReceiver	Functor object for callbacks when data are received on a socket
CVSocketActionCreator
CVSource	Implements a data source
CVStateCreator	This is an experimental class to easy creation of context-relative object states
CMyState
CVStateCreatorBase	Base class for objects carrying context-specific states
CState	A class for storing context-dependent information
CStateMap
CVStereoLens	Stereo lens implementation using asymmetric frustum rendering
CVStream	Network connection routines
CAborted
CClosed
CError
CException
CTryAgain
CTryAgainOnWrite
CURL
CVStreamLogger
CLogger
CVStreamObject
CVTask	A functor object that runs in a separate thread, if fired from a ThreadManager
CVTaskMessage	Base class for messages sent from one thread to another one
CVTextRenderProperties
CVThreadCreator	Creation interface providing an actual implementation of Threads
CVThreadManager	Managing Threads - the code to be executed in another thread is provided in functor objects derived from VTask
CVTime	An input type for steering time-dependent objects
CVTraceRequestID	Trace the ID of an request
CVTransformable
CVTypedInputValue	Convenience class for input values that only want to check for their specific type as input, child classes merely need to override the changed() virtual function
CVTypedValueBase	Base class for values with type
CVTypeTemplate
CVUndoAction
CVUndoStack
CVUrlSystemHandler
CVValue	A typed value with storage within the class
CVValue< VSocketAction >	The actual information that is stored for a socket connection within a VObject
CVValue< VThreadManager >	VObject-local management of threads
CIterator
CVValueBase	Abstract base class for values which are used as input types, e.g
CVValueCompareTrait	Compares two values numerically to identify if they have changed
CVValueCompareTrait< Brush >
CVValueCompareTrait< Cursor3DProperties >
CVValueCompareTrait< Plane >
CVValueCompareTrait< RefPtr< TypedChunk< Type > > >
CVValueCompareTrait< View >
CVValueCompareTrait< VThreadManager >
CVValueCopyTrait	Type trait class that tells how to create a new value, given an existing one
CVValueCopyTrait< Action >
CVValueCopyTrait< Eagle::MultiRange< T > >
CVValueCopyTrait< RefPtr< Fog > >
CVValueCopyTrait< RefPtr< Type > >	Copy type trait for referenced types: create a new instance of the referred-to object
CVValueCopyTrait< RefPtr< TypedChunk< T > > >	Copy operation is per reference, not per value!
CVValueCopyTrait< VBoundingBox >
CVValueCopyTrait< VColormap >
CVValueCreator
CVValueParameter	Shortcut convenience class for VParameters that refer to a VValue<> storage of the actual parameter
CVValueParameter< Action >	Specialization of the VValueParmeter over actions such that at construction their age is always infinitely old, thus avoiding to trigger an update right after construction, which is usually undesirable
CVValueParameter< VSocketAction >	A VParameter that handles socket connections
CVValueParameter< VThreadManager >	A VParameter that handles threads
CVValueTrait	Type trait for VValues that specify how to convert a certain value from and to text
CVValueTrait< Action >
CVValueTrait< bool >
CVValueTrait< bool[]>
CVValueTrait< BoundingBall >
CVValueTrait< Brush >
CVValueTrait< char >
CVValueTrait< Cursor3DProperties >
CVValueTrait< double >
CVValueTrait< Eagle::FixedArray< double, 2 > >
CVValueTrait< Eagle::FixedArray< double, 4 > >
CVValueTrait< Eagle::FixedArray< int, 3 > >
CVValueTrait< Eagle::metric33 >
CVValueTrait< Eagle::MultiRange< T > >	Conveniently import eagle's multirange
CVValueTrait< Eagle::PhysicalSpace::bivector >
CVValueTrait< Eagle::PhysicalSpace::point >
CVValueTrait< Eagle::PhysicalSpace::rotor >
CVValueTrait< Eagle::PhysicalSpace::tvector >
CVValueTrait< Enum >	Type trait for Enum types as VObject communicators
CVValueTrait< float >
CVValueTrait< ImageTile >
CVValueTrait< info >
CVValueTrait< int16_t >
CVValueTrait< int32_t >
CVValueTrait< int64_t >
CVValueTrait< Label >
CVValueTrait< LabelSet >
CVValueTrait< MemCore::RefPtr< Fog, ShaderInjectorBase > >
CVValueTrait< MetaViewerInputType >
CVValueTrait< Options >
CVValueTrait< Plane >
CVValueTrait< PointDataChunk >
CVValueTrait< Range >
CVValueTrait< RefPtr< TypedChunk< double > > >
CVValueTrait< RefPtr< TypedChunk< float > > >
CVValueTrait< RefPtr< TypedChunk< int16_t > > >
CVValueTrait< RefPtr< TypedChunk< int32_t > > >
CVValueTrait< RefPtr< TypedChunk< int64_t > > >
CVValueTrait< rgba_float_t >	Value trait for colors
CVValueTrait< std::tuple< A, B > >
CVValueTrait< string >	VValue Specialization for strings: trivial
CVValueTrait< string1 >
CVValueTrait< TransformOperator >	Value trait to allow TransformOperators as object glue
CVValueTrait< uint32_t >
CVValueTrait< VBoundingBox >	The string I/O interface for bounding boxes
CVValueTrait< VCamera >
CVValueTrait< VCameraSetPtr >
CVValueTrait< VChart >
CVValueTrait< VChartList >
CVValueTrait< VColormap >
CVValueTrait< VFrameBuffer >
CVValueTrait< VGraph >
CVValueTrait< View >
CVValueTrait< ViewerState >	Type trait for ViewerStates, to be used for TypedSlot<ViewerState> instances
CVValueTrait< VImageTileProcessor >
CVValueTrait< VInteractionEvent >
CVValueTrait< VMultipleStringList >
CVValueTrait< VMultiPointerDevice >
CVValueTrait< VObjectRef >
CVValueTrait< VObjectStatus >
CVValueTrait< VRenderAble >
CVValueTrait< VScalarFunctor >
CVValueTrait< VSceneLayers >	Type trait to allow using VSceneLayers as type to be communicated across Vish objects
CVValueTrait< VSlotChangeInfo >
CVValueTrait< VSlotContainerRef >
CVValueTrait< VSocketAction >
CVValueTrait< VStringList >
CVValueTrait< VThreadManager >
CVValueTrait< VTime >
CVValueTrait< VTypeTemplate >
CVValueTraitSeparator
CVValueTraitSeparator< std::tuple< A, B > >
CVValueTypename
CWeakPtr	A pointer class which behaves like native C++ pointers, but knows about the lifetime of the referenced objects
CWebGLProgram
CWebGLRenderContext	Context for rendering into a WebGL stream
CWebGLVertexAttribute
CWebGLViewer
CWebVish
CYYSTYPE
NY
CA
CB
CA
CApprove
CApproveCommunicator
CB
CBase
CBatVishParser
CCampathSaver
CChild
CClientAcceptsImageServer
CClientAcceptsServer
CClientGreeter
CConsoleProgress
CData
CDependentObject
CFlexLexer
CFloatsToPoint2D
CGeoCameraLens	The purpose of the CameraLens module is to set the Perspective Matrix for OpenGL
CGetInput
CGetData
CglFormat	Convenience interface to OpenGL texture formats
CglFormat< 1 >
CglFormat< 2 >
CglFormat< 3 >
CglFormat< 4 >
CglFormat< GL::R, char, 8, float >
CglFormat< GL::R, char, 8, signedfloat >
CglFormat< GL::R, float, 16 >
CglFormat< GL::R, float, 32 >
CglFormat< GL::R, short, 16, float >
CglFormat< GL::R, short, 16, signedfloat >
CglFormat< GL::R, signed, 16 >
CglFormat< GL::R, signed, 32 >
CglFormat< GL::R, signed, 8 >
CglFormat< GL::R, unsigned, 16 >
CglFormat< GL::R, unsigned, 32 >
CglFormat< GL::R, unsigned, 8 >
CglFormat< GL::RG, char, 8, float >
CglFormat< GL::RG, char, 8, signedfloat >
CglFormat< GL::RG, float, 16 >
CglFormat< GL::RG, float, 32 >
CglFormat< GL::RG, short, 16, float >
CglFormat< GL::RG, short, 16, signedfloat >
CglFormat< GL::RG, signed, 16 >
CglFormat< GL::RG, signed, 32 >
CglFormat< GL::RG, signed, 8 >
CglFormat< GL::RG, unsigned, 16 >
CglFormat< GL::RG, unsigned, 32 >
CglFormat< GL::RG, unsigned, 8 >
CglFormat< GL::RGB, char, 8, float >
CglFormat< GL::RGB, char, 8, signedfloat >
CglFormat< GL::RGB, float, 16 >
CglFormat< GL::RGB, float, 32 >
CglFormat< GL::RGB, int, 10, float >
CglFormat< GL::RGB, int, 12, float >
CglFormat< GL::RGB, int, 4, float >
CglFormat< GL::RGB, int, 5, float >
CglFormat< GL::RGB, int, 8, float >
CglFormat< GL::RGB, short, 16, float >
CglFormat< GL::RGB, short, 16, signedfloat >
CglFormat< GL::RGB, signed, 16 >
CglFormat< GL::RGB, signed, 16, signedfloat >
CglFormat< GL::RGB, signed, 32 >
CglFormat< GL::RGB, signed, 8 >
CglFormat< GL::RGB, unsigned, 16 >
CglFormat< GL::RGB, unsigned, 32 >
CglFormat< GL::RGB, unsigned, 8 >
CglFormatProperties
CglFormatProperties< glFormat< N, NumericType, Bits, float > >
CglFormatProperties< glFormat< N, NumericType, Bits, signed > >
CglFormatProperties< glFormat< N, NumericType, Bits, signedfloat > >
CglFormatProperties< glFormat< N, NumericType, Bits, unsigned > >
CglFormatSize
CglFormatSize< glFormat< N, NumericType, Bits, TextureType > >
CglMemSize
CglMemSize< 0 >
CglMemSize< 1 >
CglMemSize< 2 >
CglMemSize< 3 >
CglMemSize< 4 >
CglMemSize< GL_ALPHA >
CglMemSize< GL_ALPHA12 >
CglMemSize< GL_ALPHA16 >
CglMemSize< GL_ALPHA16F_ARB >
CglMemSize< GL_ALPHA32F_ARB >
CglMemSize< GL_ALPHA4 >
CglMemSize< GL_ALPHA8 >
CglMemSize< GL_BGRA >
CglMemSize< GL_COMPRESSED_ALPHA >
CglMemSize< GL_COMPRESSED_INTENSITY >
CglMemSize< GL_COMPRESSED_LUMINANCE >
CglMemSize< GL_COMPRESSED_LUMINANCE_ALPHA >
CglMemSize< GL_COMPRESSED_RGB >
CglMemSize< GL_COMPRESSED_RGBA >
CglMemSize< GL_INTENSITY >
CglMemSize< GL_INTENSITY12 >
CglMemSize< GL_INTENSITY16 >
CglMemSize< GL_INTENSITY16F_ARB >
CglMemSize< GL_INTENSITY32F_ARB >
CglMemSize< GL_INTENSITY4 >
CglMemSize< GL_INTENSITY8 >
CglMemSize< GL_LUMINANCE >
CglMemSize< GL_LUMINANCE12 >
CglMemSize< GL_LUMINANCE12_ALPHA12 >
CglMemSize< GL_LUMINANCE12_ALPHA4 >
CglMemSize< GL_LUMINANCE16 >
CglMemSize< GL_LUMINANCE16_ALPHA16 >
CglMemSize< GL_LUMINANCE16F_ARB >
CglMemSize< GL_LUMINANCE32F_ARB >
CglMemSize< GL_LUMINANCE4 >
CglMemSize< GL_LUMINANCE4_ALPHA4 >
CglMemSize< GL_LUMINANCE6_ALPHA2 >
CglMemSize< GL_LUMINANCE8 >
CglMemSize< GL_LUMINANCE8_ALPHA8 >
CglMemSize< GL_LUMINANCE_ALPHA >
CglMemSize< GL_LUMINANCE_ALPHA16F_ARB >
CglMemSize< GL_LUMINANCE_ALPHA32F_ARB >
CglMemSize< GL_R16F >
CglMemSize< GL_R16I >
CglMemSize< GL_R16UI >
CglMemSize< GL_R32F >
CglMemSize< GL_R32I >
CglMemSize< GL_R32UI >
CglMemSize< GL_R3_G3_B2 >
CglMemSize< GL_R8I >
CglMemSize< GL_R8UI >
CglMemSize< GL_RED >
CglMemSize< GL_RG16F >
CglMemSize< GL_RG16I >
CglMemSize< GL_RG16UI >
CglMemSize< GL_RG32F >
CglMemSize< GL_RG32I >
CglMemSize< GL_RG32UI >
CglMemSize< GL_RG8I >
CglMemSize< GL_RG8UI >
CglMemSize< GL_RGB >
CglMemSize< GL_RGB10 >
CglMemSize< GL_RGB10_A2 >
CglMemSize< GL_RGB12 >
CglMemSize< GL_RGB16 >
CglMemSize< GL_RGB16F >
CglMemSize< GL_RGB16I >
CglMemSize< GL_RGB16UI >
CglMemSize< GL_RGB32F >
CglMemSize< GL_RGB32I >
CglMemSize< GL_RGB32UI >
CglMemSize< GL_RGB4 >
CglMemSize< GL_RGB5 >
CglMemSize< GL_RGB5_A1 >
CglMemSize< GL_RGB8 >
CglMemSize< GL_RGB8I >
CglMemSize< GL_RGB8UI >
CglMemSize< GL_RGBA >
CglMemSize< GL_RGBA12 >
CglMemSize< GL_RGBA16 >
CglMemSize< GL_RGBA16F >
CglMemSize< GL_RGBA16I >
CglMemSize< GL_RGBA16UI >
CglMemSize< GL_RGBA2 >
CglMemSize< GL_RGBA32F >
CglMemSize< GL_RGBA32I >
CglMemSize< GL_RGBA32UI >
CglMemSize< GL_RGBA4 >
CglMemSize< GL_RGBA8 >
CglMemSize< GL_RGBA8I >
CglMemSize< GL_RGBA8UI >
CglMemSize< GL_UNSIGNED_INT_10F_11F_11F_REV >
CglType	Type traits for native types to GL properties
CglType< Eagle::bivector3 >
CglType< Eagle::Column< N, T > >
CglType< Eagle::DomainVector< Eagle::Vector< ValueType, Dims >, ColorSpace > >
CglType< Eagle::FixedArray< T, N > >
CglType< Eagle::point3 >
CglType< Eagle::rgba_float_t >
CglType< Eagle::tvector3 >
CglType< Eagle::Vec3Packed >
CglType< Eagle::Vector< T, N > >
CglType< GLdouble >
CglType< GLfloat >
CglType< GLint >
CglType< GLshort >
CglType< GLuint >
CglType< GLushort >
CglType< rgba_half_t >
CglType< signed char >
CglType< T[N]>
CglType< unsigned char >
CInt
CInteractionInput
CJPEG_ERROR
Clist	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CLocalDataThingy
CMatrix	Simple matrix class for performing fast operations on matrices of sizes known at compile-time
CMyAnemoneInitializer
CMyFunctor
CmyInterface
CMyOnDemandDataCreator
CMyPreciousDataClass
CMyTentacle
COnDemandCreator
COscillator
COscillatorDiffEquation
CPendulumARK
CPendulumDiffEquation
CPendulumRK4
CPNGRetrieveImageSizedFrame
CReference
Csignedfloat	Indicates that the texture type is in range [-1,+1]
CSoSurfaceHeightfieldTEST	Inventor node to display something
CStatusNotifier
Cstring	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
Cvector	STL class
Cconst_iterator	STL iterator class
Cconst_reverse_iterator	STL iterator class
Citerator	STL iterator class
Creverse_iterator	STL iterator class
CVInitialization	Initialization: Each Plugin should (MacOS: Must) contain a function
CVishControl
CObjectIterator
CObjectValues
CParameterIterator
CParValues
CValueIterator
CVISH
CVishControlCreator
CVishScriptSaver
CVltstr
CVMap
CVWebControl
CObjectIterator
CObjectList
CObjectValues
CParameterIterator
CParValues
CValueIterator
CVWebControlCreator
CWebFileRenderer
CWritePng
CX
Cexec
CXBase
CY
Cyy_buffer_state
Cyy_trans_info
Cyyalloc
CyyFlexLexer
CYYLTYPE
CYYSTYPE
CYYSTYPE.bivec
CYYSTYPE.point
CYYSTYPE.rotor
CYYSTYPE.vec
CZ
CZptr