The Vish Visualization Shell 0.3
Vish
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234567891011]
 CMETA::__is_result_convertible< From, To >
 CMETA::_META_THIS< T >
 CEagle::PhysicalSpace::AABB_2D< point, ProjectionX, ProjectionY >Axis-aligned bounding box in 2D dimensions out of 3D, allowing for projections other than XY
 CWizt::AcceptList< AcceptType, NextAcceptList >
 CWizt::AcceptListIterator< AcceptType >Accepting arbitrary types directly as second argument of VCreator or VObject::AcceptableInputTypes
 CWizt::AcceptListIterator< AcceptList< AcceptType, NextAcceptList > >
 CWizt::AcceptListIterator< META::LIST< AcceptType, NextAcceptList > >Using a META::LIST<> as second argument of VCreator or VObject::AcceptableInputTypes
 CWizt::AcceptListIterator< META::NIL >Using a META::NIL as second argument of VCreator or VObject::AcceptableInputTypes rejects all input objects
 CWizt::AcceptListIterator< void >Using void as second argument of VCreator or VObject::AcceptableInputTypes rejects all input objects
 CWizt::AccessMemory< T >RAII access to writeable mapped memory
 CWizt::AccessMemory< const T >RAII access to read-only mapped memory
 CWizt::Anemone::Tentacle::ActivatorHelper class for Tentacles, allows exception-save enabling and disabling of Tentacles
 CMemCore::AgeableBase class for objects which change from time to time
 CWizt::AgeableBase class for objects which change from time to time
 CAnemoneCreatorBase
 CWizt::AnemoneCreatorContextConvenience class to pair a render context and an AnemoneCreator
 CEagle::AnyType
 CWizt::ApplicationIterator
 Cstd::array< T >STL class
 CMETA::ASSERT< bool >
 CEagle::Assert< bool >
 CMETA::ASSERT< true >
 CEagle::Assert< true >
 CEagle::Assertion< bool >
 CEagle::Assertion< true >
 CWizt::GLCacheFactoryPtr::AssignatorProxy class for creating GL Objects
 CEagle::Assignment< Array, i >Convenience class to allow using the comma operator for assigning a sequence of elements to a given array-like class
 CMemCore::AtomicityConfig< AtomicityConfigSelection, Bits >
 CMemCore::AtomicityConfig< AtomicityConfigSelection::CXX_ATOMIC, 32 >
 CMemCore::AtomicityConfig< AtomicityConfigSelection::CXX_ATOMIC, 64 >
 CMemCore::AtomicityConfig< AtomicityConfigSelection::GCC_ATOMIC, 32 >
 CMemCore::AtomicityCounter< Config, Bits >
 CMemCore::AttributesAttributes are a selection of named MemCore::ChunkBase objects, each of them may carry arbitrary data
 CMemCore::BaseChunk< T, Base, HasSameSize >Computing the right base class for a given element
 CMemCore::BaseChunk< T, Base, false >Determine the base class for typed chunks of base classes that have another memory layout
 CMemCore::BaseChunk< T, Base, true >Determine the base class for typed chunks of base classes that have the same memory layout
 CMemCore::BaseChunk< T, T, true >Determine the base class for typed chunks of base classes
 CMETA::BaseClass< T >A trait class for determining the base class of something
 CMETA::BaseClass< Eagle::bivector3f >
 CMETA::BaseClass< Eagle::Column< R, value > >
 CMETA::BaseClass< Eagle::DomainVector< VectorType, Domain, scalar_t > >
 CMETA::BaseClass< Eagle::Matrix< R, C, Value > >
 CMETA::BaseClass< Eagle::PhysicalSpace::bivector >
 CMETA::BaseClass< Eagle::PhysicalSpace::point >
 CMETA::BaseClass< Eagle::PhysicalSpace::vector >
 CMETA::BaseClass< Eagle::point3f >
 CMETA::BaseClass< Eagle::rgba_float_t >
 CMETA::BaseClass< Eagle::vector3f >
 CMETA::BaseClass< Eagle::Vector< T, n > >
 Cstd::basic_string< Char >STL class
 CEagle::BinaryOperatorFunctor< ResultNode, LeftNode, RightNode, Op, SubOp >
 CWizt::Framebuffer::BindException-safe framebuffer binding with framebuffer stack support
 CCoordinates::bivector
 CWizt::RenderNamespace::BlendFactor
 CWizt::BrushA data-driven description of a Brush to select points from a set of points, providing an list of indices
 CMETA::BSort< T, N >
 CMETA::BubbleSort< T, N, Comp >Todd Veldhuizen Bubblesort Metaprogram http://osl.iu.edu/~tveldhui/papers/Template-Metaprograms/meta-art.html
 CMETA::BubbleSort< T, 1, Comp >
 CMETA::BubbleSortLoop< T, I, J, Comp >
 CMETA::BubbleSortLoop< T, 0, 0, Comp >
 CWizt::BufferIDBase class for OpenGL buffer id's
 CTraum::ButcherTableau< real >Template class specifying a butcher table:
 CTraum::ButcherTableau< double >
 CMemCore::C0Standardized control characters
 CMemCore::CacheMultiQueueCache queues of different purpose
 CEagle::StrongPtr< Object, ObjectBase >::Call< ReturnType >
 CMemCore::StrongPtr< Object, ObjectBase >::Call< ReturnType >
 CWizt::StrongPtr< Object, ObjectBase >::Call< ReturnType >
 CEagle::StrongPtr< Object, ObjectBase >::Call< StrongPtr< ReturnType, typename ReturnType::reference_domain_t > >
 CMemCore::StrongPtr< Object, ObjectBase >::Call< StrongPtr< ReturnType, typename ReturnType::reference_domain_t > >
 CWizt::StrongPtr< Object, ObjectBase >::Call< StrongPtr< ReturnType, typename ReturnType::reference_domain_t > >
 CEagle::Cartesian3D
 CEagle::STA::CartesianChart4D< real >
 CWizt::CategorizedRenderObjects< TypedRenderObject >
 CMETA::ChooseWithOutPermutation< N, K >Expression template to compute the number of possible combinations when choosing K elements from a set of N without differentiating between permutations
 CMemCore::ChunkDataAddress< T >
 CMemCore::ChunkDataAddress< bool >
 CMemCore::ChunkType
 CPosixThreads::Thread::CleanUp
 CWizt::ClippingPlanesVRenderObjects 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
 CWizt::VDataFlowGraph::CmpObjectPtrs
 CWizt::ColorizerA vish object component (aka vish skale) that references some colormap and takes care of its parameter handling
 CWizt::CommandLineParserBasic parser for options and arguments
 CMETA::Comparator< T >
 CWizt::CompareSlotsByName
 CEagle::complexSTL class
 CMemCore::ConsoleC++ API for stdio's puts()
 CEagle::map< K, T >::const_iteratorSTL iterator class
 CEagle::string::const_iteratorSTL iterator class
 Clist< T >::const_iteratorSTL iterator class
 CMemCore::list< T >::const_iteratorSTL iterator class
 CMemCore::string::const_iteratorSTL iterator class
 Cstring::const_iteratorSTL iterator class
 Cvector< T >::const_iteratorSTL iterator class
 CWizt::deque< T >::const_iteratorSTL iterator class
 CWizt::list< T >::const_iteratorSTL iterator class
 CWizt::map< K, T >::const_iteratorSTL iterator class
 CWizt::multimap< K, T >::const_iteratorSTL iterator class
 CWizt::multiset< K >::const_iteratorSTL iterator class
 CWizt::set< K >::const_iteratorSTL iterator class
 CWizt::string::const_iteratorSTL iterator class
 CWizt::vector< T >::const_iteratorSTL iterator class
 CEagle::map< K, T >::const_reverse_iteratorSTL iterator class
 CEagle::string::const_reverse_iteratorSTL iterator class
 Clist< T >::const_reverse_iteratorSTL iterator class
 CMemCore::list< T >::const_reverse_iteratorSTL iterator class
 CMemCore::string::const_reverse_iteratorSTL iterator class
 Cstring::const_reverse_iteratorSTL iterator class
 Cvector< T >::const_reverse_iteratorSTL iterator class
 CWizt::deque< T >::const_reverse_iteratorSTL iterator class
 CWizt::list< T >::const_reverse_iteratorSTL iterator class
 CWizt::map< K, T >::const_reverse_iteratorSTL iterator class
 CWizt::multimap< K, T >::const_reverse_iteratorSTL iterator class
 CWizt::multiset< K >::const_reverse_iteratorSTL iterator class
 CWizt::set< K >::const_reverse_iteratorSTL iterator class
 CWizt::string::const_reverse_iteratorSTL iterator class
 CWizt::vector< T >::const_reverse_iteratorSTL iterator class
 CWizt::GLCacheFactoryPtr::ConstAssignatorProxy class for constant access to GL Cache objects
 CWizt::VCreationPreferences::ConstIterator
 CEagle::ContextA set of variable names, with indices associated to each type
 CWizt::VLogger::ContextSet logging context with auto-cleanup
 CWizt::GLContextChecker::ContextAvailable
 CEagle::ContraVariant< T >
 CEagle::ContravariantIndexingSchemeIndices are all upper indices, e.g
 CEagle::CoordinateInfo< T >
 CEagle::CoordinateInfo< void >
 CEagle::PhysicalSpace::Frustum::CornerPoints
 CMemCore::CounterBase class for thread-safe counting, comes with an exception-safe incrementing/decrementing counter class
 CEagle::CoVariant< T >
 CEagle::CovariantIndexingSchemeIndices are all lower indices, e.g
 CWizt::CreateVertexArray< ArrayType >
 CWizt::CreateVertexArray_nD< Type, ArrayType, Dims >
 CWizt::CreateVertexArray_nD< Type, ArrayType, 0 >
 CWizt::CreationInfo
 CWizt::CreatorCreator
 CCreature
 CWizt::Cursor3D
 CWizt::Cursor3DPropertiesDescription of parameters for drawing a 3D cursor shape within a shader
 CWizt::DefaultAnemoneInitializer
 CWizt::DefaultTypedSlotSaveProperty< Type >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
 CWizt::VSlotContainer::DeferredInternal helper class used for the construction of VOutput objects
 CMemCore::DeferredInitializationTrait< Object >Trait class that allows to execute some action on an object when it receives the first strong reference count in its life
 CMemCore::DeferredInitializationTrait< Cacheable >
 CMemCore::DeferredInitializationTrait< Creature >
 CMemCore::DeferredInitializationTrait< ReferenceBase< Object > >
 CMemCore::DefineTypenameBaseA typemap used for adding new type names
 Cfpng::defl_huff
 Cfpng::defl_sym_freq
 CWizt::VRenderContext::DepthModeSupport for depth modes as discussed in: https://stannum.io/blog/0UZsbE
 CWizt::deque< T >STL class
 CEagle::DerivationTrait< BinaryFunctor >Template type trait class to compute analytical derivates
 CEagle::DerivationTrait< BinaryOperatorFunctor< NodeType, NodeType, NodeType, '-'> >Computes (u-v),x which is u,x-v,x
 CEagle::DerivationTrait< BinaryOperatorFunctor< ScalarNode, ScalarNode, ScalarNode, '+'> >Computes (a+b),x which is a,x+b,y
 CEagle::DerivationTrait< BinaryOperatorFunctor< ScalarNode, ScalarNode, ScalarNode, '-'> >Computes (a-b),x which is a,x-b,y
 CEagle::DerivationTrait< BinaryOperatorFunctor< ScalarNode, ScalarNode, ScalarNode, '/'> >Computes (a/b),x which is (a,x b - a b,y) / b^2
 CEagle::DerivationTrait< LocationComponent< Component > >Computes (v[i]),x
 CEagle::DerivationTrait< ScalarCube >Computes (y^3),x which is 3 y^2 y,x
 CEagle::DerivationTrait< ScalarSquare >Computes (y^2),x which is 2 y y,x
 CEagle::DerivationTrait< UnaryMinus< NodeType > >Computes (-v),x which is -(v,x)
 CEagle::DerivationTrait< VectorSquare >Computes (v^2),x which is 2 v v,x
 CEagle::DerivationTrait< VectorWedgeVector >Computes $(u\wedge v),x$ which is $(u,x)\wedge v + u\wedge(v,x)$
 CEagle::Determinantor< R >The determinantor recursively computes the determinant of a matrix
 CEagle::Determinantor< 1 >The trivial determinant of a 1x1 matrix
 CEagle::Determinantor< 2 >The simple determinant of a 2x2 matrix
 CEagle::Determinantor< 3 >
 CEagle::Determinantor< 4 >
 CDiffEquation
 CDomain
 CMemCore::domain_cast< InterfaceDomain >
 CEagle::DomainFunctions< Domain, DomainVector >
 CEagle::DomainFunctions< Domain, Vector< ScalarType, N > >
 CEagle::DomainFunctions< Domain, VectorType >
 CEagle::DomainFunctions< RGB, DomainVector >
 CEagle::DomainFunctions< RGBA, DomainVector >
 CTraum::dop_vars< real >
 CTraum::DynamicArray< Value >A really simple array class that allows to set the size of the array at runtime (
 CMemCore::DynPtr< Object, ObjectBase >Encapsuled pointer class for pointers pointing to derived classes
 CMemCore::DynPtr< ::Data, ObjectBase >
 CMemCore::DynPtr< A, A >
 CMemCore::DynPtr< ActionReceiver, ObjectBase >
 CMemCore::DynPtr< Addendum, Addendum >
 CMemCore::DynPtr< Anemone, ObjectBase >
 CMemCore::DynPtr< ApplicationQuitter, ApplicationQuitter >
 CMemCore::DynPtr< Base, Base >
 CMemCore::DynPtr< CacheBase, CacheBase >
 CMemCore::DynPtr< CacheMap, CacheMap >
 CMemCore::DynPtr< ChunkBase, ChunkBase >
 CMemCore::DynPtr< ClassDerivedFromVManagedObjectBase, VManagedObjectBase >
 CMemCore::DynPtr< Cluster, Cluster >
 CMemCore::DynPtr< Colormap, Colormap >
 CMemCore::DynPtr< Connector, Connector >
 CMemCore::DynPtr< CrashHandler, CrashHandler >
 CMemCore::DynPtr< CreatorBase, CreatorBase >
 CMemCore::DynPtr< Creature, ObjectBase >
 CMemCore::DynPtr< Data, Data >
 CMemCore::DynPtr< DeferredRenderer, DeferredRenderer >
 CMemCore::DynPtr< DependentObject, DependentObject >
 CMemCore::DynPtr< Eagle::BoundingBall, ObjectBase >
 CMemCore::DynPtr< Eagle::CameraPath, ObjectBase >
 CMemCore::DynPtr< Eagle::KDTree< N, T >, ObjectBase >
 CMemCore::DynPtr< Eagle::Node, ObjectBase >
 CMemCore::DynPtr< Eagle::TypedNode< double >, ObjectBase >
 CMemCore::DynPtr< Eagle::TypedNode< Eagle::PhysicalSpace::bivector >, ObjectBase >
 CMemCore::DynPtr< Eagle::TypedNode< Eagle::PhysicalSpace::rotor >, ObjectBase >
 CMemCore::DynPtr< Eagle::TypedNode< point3 >, ObjectBase >
 CMemCore::DynPtr< Eagle::TypedNode< tvector3 >, ObjectBase >
 CMemCore::DynPtr< Expectation, Expectation >
 CMemCore::DynPtr< Font, Font >
 CMemCore::DynPtr< Framebuffer, Framebuffer >
 CMemCore::DynPtr< FrameCompletion, FrameCompletion >
 CMemCore::DynPtr< FrameGrabber, FrameGrabber >
 CMemCore::DynPtr< Functor, Functor >
 CMemCore::DynPtr< FunctorObject, ObjectBase >
 CMemCore::DynPtr< GetBody, ObjectBase >
 CMemCore::DynPtr< GetInput::GetData, ObjectBase >
 CMemCore::DynPtr< GLContextChecker, GLContextChecker >
 CMemCore::DynPtr< GLFontManager, GLFontManager >
 CMemCore::DynPtr< Grab, Grab >
 CMemCore::DynPtr< ID, ID >
 CMemCore::DynPtr< ImageTileProcessor, ImageTileProcessor >
 CMemCore::DynPtr< Int, Int >
 CMemCore::DynPtr< InteractionGrabber, InteractionGrabber >
 CMemCore::DynPtr< Interactor, Interactor >
 CMemCore::DynPtr< InterfaceBase, InterfaceBase >
 CMemCore::DynPtr< InterfaceIterationParameter, InterfaceIterationParameter >
 CMemCore::DynPtr< KDTree< N, T >, KDTree< N, T > >
 CMemCore::DynPtr< Left_t, ObjectBase >
 CMemCore::DynPtr< LeftNode_t, ObjectBase >
 CMemCore::DynPtr< Lexicon, Lexicon >
 CMemCore::DynPtr< LightSource, LightSource >
 CMemCore::DynPtr< LightSource, ObjectBase >
 CMemCore::DynPtr< LoaderParameters, LoaderParameters >
 CMemCore::DynPtr< LoaderRequest, LoaderRequest >
 CMemCore::DynPtr< MaxRequestExecutor, MaxRequestExecutor >
 CMemCore::DynPtr< MemCore::Cache, MemCore::CacheBase >
 CMemCore::DynPtr< MemCore::Cache, ObjectBase >
 CMemCore::DynPtr< MemCore::Cacheable, ObjectBase >
 CMemCore::DynPtr< MemCore::CacheQueue, ObjectBase >
 CMemCore::DynPtr< MemCore::Chunk< Eagle::DomainVector< Vector< color8_t, 3 >, RGB > >, ObjectBase >
 CMemCore::DynPtr< MemCore::Chunk< Eagle::DomainVector< Vector< color8_t, 4 >, RGBA > >, ObjectBase >
 CMemCore::DynPtr< MemCore::Chunk< Eagle::Vec3Packed >, ObjectBase >
 CMemCore::DynPtr< MemCore::Chunk< float >, ObjectBase >
 CMemCore::DynPtr< MemCore::Chunk< uint32_t >, ObjectBase >
 CMemCore::DynPtr< MemCore::Chunk< uint64_t >, ObjectBase >
 CMemCore::DynPtr< MemCore::ChunkBase, ObjectBase >
 CMemCore::DynPtr< MemCore::InterfaceBase, ObjectBase >
 CMemCore::DynPtr< MemCore::Lexicon, MemCore::Lexicon >
 CMemCore::DynPtr< MemCore::Provenance, MemCore::Provenance >
 CMemCore::DynPtr< MemCore::Result::Cluster, ObjectBase >
 CMemCore::DynPtr< MemCore::StringList, ObjectBase >
 CMemCore::DynPtr< MemCore::TypedChunk< Eagle::PhysicalSpace::point >, ObjectBase >
 CMemCore::DynPtr< MemCore::VerboseCatcher, MemCore::VerboseCatcher >
 CMemCore::DynPtr< Middle_t, ObjectBase >
 CMemCore::DynPtr< ModelViewMatrixState, ModelViewMatrixState >
 CMemCore::DynPtr< MovieManager, MovieManager >
 CMemCore::DynPtr< MultipleStringSelection, MultipleStringSelection >
 CMemCore::DynPtr< MultiRange< T >, MultiRange< T > >
 CMemCore::DynPtr< MyPreciousDataClass, ObjectBase >
 CMemCore::DynPtr< NamedRenderExceptions, NamedRenderExceptions >
 CMemCore::DynPtr< Node, Node >
 CMemCore::DynPtr< Notifier, Notifier >
 CMemCore::DynPtr< Object, StrongPtr< Object >::ObjectBase_t >
 CMemCore::DynPtr< ObjectBase, ObjectBase >Base class for pointers to base classes
 CMemCore::DynPtr< OcTree< T >, OcTree< T > >
 CMemCore::DynPtr< OutputFormat, OutputFormat >
 CMemCore::DynPtr< PickList, PickList >
 CMemCore::DynPtr< PixelBuffer, PixelBuffer >
 CMemCore::DynPtr< Provenance, Provenance >
 CMemCore::DynPtr< QuadTree< T >, QuadTree< T > >
 CMemCore::DynPtr< Receiver, Receiver >
 CMemCore::DynPtr< RefCountable, StrongPtr< RefCountable >::ObjectBase_t >
 CMemCore::DynPtr< ReferenceCounted, ObjectBase >
 CMemCore::DynPtr< ReferenceCounted, ReferenceCounted >
 CMemCore::DynPtr< RefType, ObjectBase >
 CMemCore::DynPtr< RemoteLens, ObjectBase >
 CMemCore::DynPtr< RemoteVish::Communicator, ObjectBase >
 CMemCore::DynPtr< Renderer, Renderer >
 CMemCore::DynPtr< Result, Result >
 CMemCore::DynPtr< Right_t, ObjectBase >
 CMemCore::DynPtr< RightNode_t, ObjectBase >
 CMemCore::DynPtr< SaveInterfaceCreatorBase, SaveInterfaceCreatorBase >
 CMemCore::DynPtr< Shader, Shader >
 CMemCore::DynPtr< ShaderInjectorBase, ShaderInjectorBase >
 CMemCore::DynPtr< SocketReceivers_t, ObjectBase >
 CMemCore::DynPtr< SocketReceivers_t, SocketReceivers_t >
 CMemCore::DynPtr< Source_t, ObjectBase >
 CMemCore::DynPtr< State, State >
 CMemCore::DynPtr< StatusNotifier, ObjectBase >
 CMemCore::DynPtr< StringList, StringList >
 CMemCore::DynPtr< Task, Task >
 CMemCore::DynPtr< Tentacle, Tentacle >
 CMemCore::DynPtr< TypedSlotCreator, TypedSlotCreator >
 CMemCore::DynPtr< TypeSpecificGLCacheFactory, TypeSpecificGLCacheFactory >
 CMemCore::DynPtr< Updater, Updater >
 CMemCore::DynPtr< VAcceptInfo, VAcceptInfo >
 CMemCore::DynPtr< VAcceptList, VAcceptList >
 CMemCore::DynPtr< VAction, VAction >
 CMemCore::DynPtr< VActionNotifier, VActionNotifier >
 CMemCore::DynPtr< Value, ObjectBase >
 CMemCore::DynPtr< ValueNotifier, ObjectBase >
 CMemCore::DynPtr< ValueNotifier, ValueNotifier >
 CMemCore::DynPtr< ValuePool, ObjectBase >
 CMemCore::DynPtr< ValuePoolCreator, ValuePoolCreator >
 CMemCore::DynPtr< ValuePoolProvider, ValuePoolProvider >
 CMemCore::DynPtr< ValueSet, ValueSet >
 CMemCore::DynPtr< VCameraSet, VCameraSet >
 CMemCore::DynPtr< VConnectionValidator, VConnectionValidator >
 CMemCore::DynPtr< VCreatorBase, ObjectBase >
 CMemCore::DynPtr< VCreatorBase, Wizt::VManagedObjectBase >
 CMemCore::DynPtr< VCreatorMap, VCreatorMap >
 CMemCore::DynPtr< VerboseCatcher, VerboseCatcher >
 CMemCore::DynPtr< VishSaver, VishSaver >
 CMemCore::DynPtr< VLogger, VLogger >
 CMemCore::DynPtr< VModule, VModule >
 CMemCore::DynPtr< VOperatorCache< OperatorData >, VOperatorCache< OperatorData > >
 CMemCore::DynPtr< VParameterConnectionConstraint, VParameterConnectionConstraint >
 CMemCore::DynPtr< VRenderInterruptor, VRenderInterruptor >
 CMemCore::DynPtr< VRenderPrecision, VRenderPrecision >
 CMemCore::DynPtr< VScriptFunctor, VScriptFunctor >
 CMemCore::DynPtr< VScriptParameters, VScriptParameters >
 CMemCore::DynPtr< VScriptTypedValue, VScriptTypedValue >
 CMemCore::DynPtr< VScriptValue, ObjectBase >
 CMemCore::DynPtr< VScriptValue, VScriptValue >
 CMemCore::DynPtr< VSlot, ObjectBase >
 CMemCore::DynPtr< VSlot, VSlot >
 CMemCore::DynPtr< VTaskMessage, VTaskMessage >
 CMemCore::DynPtr< VUndoAction, VUndoAction >
 CMemCore::DynPtr< VUrlSystemHandler, VUrlSystemHandler >
 CMemCore::DynPtr< VValueBase, ObjectBase >
 CMemCore::DynPtr< VValueCreator, VValueCreator >
 CMemCore::DynPtr< Wizt::Anemone, ObjectBase >
 CMemCore::DynPtr< Wizt::AnemoneBasicCreator, ObjectBase >
 CMemCore::DynPtr< Wizt::AnemoneCreator<>, ObjectBase >
 CMemCore::DynPtr< Wizt::AnemoneCreatorBase, ObjectBase >
 CMemCore::DynPtr< Wizt::Colormap, ObjectBase >
 CMemCore::DynPtr< Wizt::ComputeShader, ObjectBase >
 CMemCore::DynPtr< Wizt::DisplayList, ObjectBase >
 CMemCore::DynPtr< Wizt::DisplayListCreator, ObjectBase >
 CMemCore::DynPtr< Wizt::Expectation, ObjectBase >
 CMemCore::DynPtr< Wizt::FragmentShader, ObjectBase >
 CMemCore::DynPtr< Wizt::Framebuffer, ObjectBase >
 CMemCore::DynPtr< Wizt::GeometryShader, ObjectBase >
 CMemCore::DynPtr< Wizt::GLCache, ObjectBase >
 CMemCore::DynPtr< Wizt::GLMultisampleTexture2D, ObjectBase >
 CMemCore::DynPtr< Wizt::GlossyTexture, ObjectBase >
 CMemCore::DynPtr< Wizt::GLTextureTentacle, ObjectBase >
 CMemCore::DynPtr< Wizt::HTTPServer, ObjectBase >
 CMemCore::DynPtr< Wizt::HTTPServer::AcceptConnections, ObjectBase >
 CMemCore::DynPtr< Wizt::ImageTileProcessor, ObjectBase >
 CMemCore::DynPtr< Wizt::IndexBuffer, ObjectBase >
 CMemCore::DynPtr< Wizt::Interactor, ObjectBase >
 CMemCore::DynPtr< Wizt::MessageRetriever, ObjectBase >
 CMemCore::DynPtr< Wizt::NamedRenderExceptions, ObjectBase >
 CMemCore::DynPtr< Wizt::PixelBuffer, ObjectBase >
 CMemCore::DynPtr< Wizt::RemoteViewer, ObjectBase >
 CMemCore::DynPtr< Wizt::RemoteViewer::AcceptConnections, ObjectBase >
 CMemCore::DynPtr< Wizt::RemoteVish, ObjectBase >
 CMemCore::DynPtr< Wizt::RemoteVish::AcceptConnections, ObjectBase >
 CMemCore::DynPtr< Wizt::RemoteVish::MyActionNotifier, ObjectBase >
 CMemCore::DynPtr< Wizt::RenderAble, ObjectBase >
 CMemCore::DynPtr< Wizt::RenderBasin::Painter, ObjectBase >
 CMemCore::DynPtr< Wizt::RenderBasin::Program, ObjectBase >
 CMemCore::DynPtr< Wizt::RenderBasin::RenderParameter::Updater, ObjectBase >
 CMemCore::DynPtr< Wizt::RequestExecutor::MaxRequestExecutor, ObjectBase >
 CMemCore::DynPtr< Wizt::ScriptletCreator, ObjectBase >
 CMemCore::DynPtr< Wizt::Seagrass, ObjectBase >
 CMemCore::DynPtr< Wizt::ShaderLightSource, Wizt::VManagedObjectBase >
 CMemCore::DynPtr< Wizt::SSBOManager, ObjectBase >
 CMemCore::DynPtr< Wizt::Task, ObjectBase >
 CMemCore::DynPtr< Wizt::TextureBase, ObjectBase >
 CMemCore::DynPtr< Wizt::TransformOperator::Functor, ObjectBase >
 CMemCore::DynPtr< Wizt::UniformBuffer, ObjectBase >
 CMemCore::DynPtr< Wizt::VAcceptInfo, ObjectBase >
 CMemCore::DynPtr< Wizt::VAcceptList, ObjectBase >
 CMemCore::DynPtr< Wizt::ValueActionBase, ObjectBase >
 CMemCore::DynPtr< Wizt::ValueNotifier, ObjectBase >
 CMemCore::DynPtr< Wizt::ValuePool, ObjectBase >
 CMemCore::DynPtr< Wizt::ValuePoolProvider, ObjectBase >
 CMemCore::DynPtr< Wizt::ValueSet, ObjectBase >
 CMemCore::DynPtr< Wizt::VBO, ObjectBase >
 CMemCore::DynPtr< Wizt::VBO::Renderer, ObjectBase >
 CMemCore::DynPtr< Wizt::VContext::Addendum, ObjectBase >
 CMemCore::DynPtr< Wizt::VCreationPreferences, ObjectBase >
 CMemCore::DynPtr< Wizt::VertexShader, ObjectBase >
 CMemCore::DynPtr< Wizt::VFrameBuffer::Renderer, ObjectBase >
 CMemCore::DynPtr< Wizt::Viewer, ObjectBase >
 CMemCore::DynPtr< Wizt::VInputCreatorBase, ObjectBase >
 CMemCore::DynPtr< Wizt::VInteractionEvent::InteractionGrabber, ObjectBase >
 CMemCore::DynPtr< Wizt::VModule, ObjectBase >
 CMemCore::DynPtr< Wizt::VObject, ObjectBase >
 CMemCore::DynPtr< Wizt::VParameter, ObjectBase >
 CMemCore::DynPtr< Wizt::VRenderContext::Font, ObjectBase >
 CMemCore::DynPtr< Wizt::VRenderInterruptor, ObjectBase >
 CMemCore::DynPtr< Wizt::VRenderObject, ObjectBase >
 CMemCore::DynPtr< Wizt::VRenderPrecision, ObjectBase >
 CMemCore::DynPtr< Wizt::VRequest::ID, ObjectBase >
 CMemCore::DynPtr< Wizt::VScalarFunctor::Functor, ObjectBase >
 CMemCore::DynPtr< Wizt::VScriptParameters, ObjectBase >
 CMemCore::DynPtr< Wizt::VScriptValue, ObjectBase >
 CMemCore::DynPtr< Wizt::VSlot, ObjectBase >
 CMemCore::DynPtr< Wizt::VSocketAction::Receiver, ObjectBase >
 CMemCore::DynPtr< Wizt::VStreamLogger, ObjectBase >
 CMemCore::DynPtr< Wizt::VStreamLogger::Logger, ObjectBase >
 CMemCore::DynPtr< Wizt::VTypedValueBase, ObjectBase >
 CMemCore::DynPtr< Wizt::VUndoStack, ObjectBase >
 CMemCore::DynPtr< Wizt::VUrlSystemHandler, Wizt::VUrlSystemHandler >
 CMemCore::DynPtr< Wizt::VValueBase, ObjectBase >
 CMemCore::DynPtr< Wizt::VValueParameter< Wizt::VThreadManager >, ObjectBase >
 CMemCore::DynPtr< X, ObjectBase >
 CMemCore::DynPtr< XBase, XBase >
 CMemCore::DynPtr< Y::B, ObjectBase >
 CMemCore::DynPtrNotification< ObjectBase >
 CMemCore::DynPtrNotification< A >
 CWizt::VDataFlowGraph::EdgeInformation per edge
 CEagle::ElementOfFunctor< L, R >
 CWizt::VSlot::Empty< int >Internal type for computational constructor
 Cstd::enable_shared_from_this
 CWizt::EnableTexture
 Cstd::equal_to
 CPosixThreads::Thread::Error
 CEagle::EvaluatorAbstract base class providing numerical values from some context ID for the evaluation of function trees
 CTraum::AdaptiveRungeKutta< DiffEquation >::EvolutionVarsSet of variables that are updated at each integration step but keep their values from the previous step
 CTraum::Euler< DiffEquation >::EvolutionVarsSet of variables that are updated at each integration step but keep their values from the previous step
 CTraum::Rk4< DiffEquation >::EvolutionVarsSet of variables that are updated at each integration step but keep their values from the previous step
 CCreature::Exception
 Cstd::exceptionSTL class
 CX::exec< T >
 CMemCore::ExecutableInfo
 CWizt::VRequest::ID::ExecutionLevel
 CWizt::VObject::ExecutionStatusException class that might be thrown by update() and is handled in the data flow traversal
 CEagle::Eye
 CEagle::FA_CONVERT
 CMETA::Fac< N >
 CMETA::Fac< 0 >
 CMemCore::FileInfoEncapsulation for portable file times
 CMemCore::FiletimeEncapsulation for portable file times
 CEagle::Chunk< T >::Filler
 CMemCore::Chunk< T >::Filler
 CEagle::FixedArray< value, N >A FixedArray is a simple copy-by-value array providing random access to its elements
 CEagle::FixedArray< double, n >
 CEagle::FixedArray< META::PreciserType< FirstVector::value_type, SecondVector::value_type >::result, n >
 CEagle::FixedArray< real, n >
 CEagle::FixedArray< ScalarType, n >
 CEagle::FixedArray< T, n >
 CEagle::FixedArray< value, n >
 CEagle::FixedArrayFlattener< T >A template metaprogram class (type trait) to compute the flattened version of a FixedArray
 CEagle::FixedArrayFlattener< FixedArray< T, M *N > >
 CEagle::FixedArrayFlattener< FixedArray< T, N > >
 CEagle::FixedArrayType< ElementType, N >
 CEagle::FixedArrayType< ElementType, 1 >
 CFlexLexer
 CWizt::RenderBasin::FloatedOriginSupport for FloatingOrigin (class FloatOrigin )
 CMemCore::FolderClass for reading directory entries
 CMETA::FOREACH< Exec, Type, Types >
 CMETA::FOREACH< Exec, LIST< ListType > >
 CMETA::FOREACH< Exec, LIST< NIL > >
 CMETA::FOREACH< Exec, ListTypes... >
 CMETA::FOREACH< Exec, NIL >
 CMETA::FOREACH< Exec, Type >
 CMETA::ForEachType< TypeList >
 Cstd::forward_list< OmegaPtr< Object > >
 CWizt::RemoteViewer::FrameData
 CEagle::PhysicalSpace::FrustumA frustum and operations on it, as described by either a set of corner points or six planes
 CMemCore::FunctionStackProfiler
 CMemCore::FunctorAn abstract base class for scalar functions on double values
 CEagle::GE
 CWizt::TextureBase::Generator
 CEagle::GetFixedArrayType< T >A template metaprogram class to compute the an fixed array type of an homogeneous type
 CWizt::Slottify::GetObjectInfoCallback object for parsing object slot information
 CWizt::GimpIconA map of ref pointers to input objects
 CWizt::GLCacheCreator
 CWizt::GLColormapA colormap can be used in two ways: as 1D texture, or as colortable
 CWizt::GLDebug
 CWizt::glewInterfacing the glew library
 CWizt::GlewContext
 CglFormat< N, NumericType, Bits, TextureType >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< glFormatType >
 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< glFormatType >
 CglFormatSize< glFormat< N, NumericType, Bits, TextureType > >
 CglMemSize< i >
 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 >
 CMemCore::Globals
 CWizt::GlossyLinesA helper class to draw lines with a shiny, glossy texture
 CWizt::GLShaderUniformFunctorA functor class for applying operators to uniform shader variables that are assigned directly from a Vish slot
 CWizt::GLSL_View.CameraSettings
 CWizt::GLSL_View.FrustumCornerPoints
 CWizt::GLSL_View.Viewport
 CWizt::RenderNamespace::GLSLSectionHelper class to automatically insert BEGIN and END comments when procedurally creating GLSL code
 CWizt::GLState
 CWizt::GLTextureIDBetter base class for OpenGL Texture ID's
 CWizt::GLType
 CglType< Type >Type traits for native types to GL properties
 CglType< Eagle::bivector3::Base_t::Base_t::Base_t >
 CglType< Eagle::Column< N, T > >
 CglType< Eagle::DomainVector< Eagle::Vector< ValueType, Dims >, ColorSpace > >
 CglType< Eagle::FixedArray< T, N > >
 CglType< Eagle::point3::Base_t::Base_t >
 CglType< Eagle::rgba_float_t >
 CglType< Eagle::tvector3::Base_t::Base_t::Base_t >
 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 >
 CEagle::GT
 CWizt::GlewContext::Handle
 CMETA::has_concept< Class, Type, Concept, Args >Check if a class has a specified concept implemented
 CMETA::has_concept< Class, Result, Concept, Args... >
 CMETA::has_member<... >
 CMETA::has_member< Result(Args...)>Simple check if a member is implemented
 CMETA::has_member< T, Result, Name(Args...)>Check a checkable member
 CMETA::has_member< T, Type, Name >Check a checkable member
 CMETA::has_member< Type >Simple check if a member is implemented
 CMETA::has_member_template< T, T >
 Cstd::hash
 Cstd::hash< MemCore::StrongPtr< RefType, ObjectBase > >
 Cstd::hash< MemCore::TypeInfo >
 Cstd::hash< MemCore::WeakPtr< RefType, ObjectBase > >
 CEagle::HeadProperties of a camera floating around in space, or, alternatively, an eagle's eye
 CWizt::HTMLInputCreator
 CWizt::HybridSceneAn internal class to categorize render objects and iterate over them according to their properties
 CWizt::IdentifierIterator
 CWizt::IdentifierWithUrl
 CMETA::IF< condition, A, B >IF Metatemplate, used to compute a certain type based on the condition
 CMETA::IF< false, A, B >
 CWizt::ImageTileA tile as part of an image
 CWizt::VSlotContainer::in< Type, InitialExpertLevel, OperatorType >Input types
 CWizt::VRequest::IncompleteException class indicating that some request could not be completed
 CMemCore::IncrementDeadRefPtrException class for cases when an invalid (dead) ref ptr is supposed to be incremented
 CMemCore::Counter::IncrementerException-safe incrementing/decrementing of a counter
 CWizt::VLogger::IndentA 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
 CMemCore::NoVerboseStream::Indentator
 CMemCore::VerboseStream::Indentator
 CMemCore::Profiler::InfoSource code information
 CWizt::glew::Info
 CWizt::Profiler::InfoSource code information
 CWizt::infoInput type to display some information about an object
 CWizt::VManagedDomainObject< What >::Init
 CWizt::VSlotContainer::inout< Type, OperatorType >Input types that are also visible as outputs, i.e
 CWizt::StreamString::input_string
 CTraum::IntegratorBaseAbstract base class for integrators
 CTraum::IntegratorImpl< RealType >
 CMemCore::IntercubeA container that holds many Interfaces
 CWizt::IntercubeA container that holds many Interfaces
 CMemCore::IntercubeIteratorIterator object for an Intercube
 CMemCore::interface_cast< InterfaceType >Interface cast: Given an Intercube, retrive the an interface object which is stored there
 CEagle::Interpol< Value >::Interval
 CEagle::InversionOperation
 CMemCore::IOItem
 CMemCore::IOTracer
 CMemCore::IrregularityHandling irregular occurences in the program without terminating it but instead writing a logfile with extensive information and continuing program execution
 CMETA::is_callable< T, Args >Template to check whether a type T is callable like a function (functor and functions)
 CMETA::is_functor< T >Template to check whether a type T is callable like a function, i.e
 CEagle::Context::IteratorIterator functor that allows to travers over all variables of a specific type
 CMemCore::Attributes::IteratorAttribute iterator base class
 CMemCore::CacheQueue::IteratorIterator class
 CMemCore::Lexicon::Iterator
 CMemCore::SaveRegistryBase::IteratorIterator class to find all saver creators for a given object domain
 CMemCore::typemap< T >::IteratorAbstract Iterator base class for typemaps
 CWizt::VCreationPreferences::IteratorIterator class
 CWizt::VCreatorCategory::IteratorIterator base class for the VCreatorCategory::iterate() function
 CWizt::VModules::Iterator
 CWizt::VValue< VThreadManager >::Iterator
 CEagle::map< K, T >::iteratorSTL iterator class
 CEagle::string::iteratorSTL iterator class
 CEagle::ViewPoints::iterator
 Clist< T >::iteratorSTL iterator class
 CMemCore::list< T >::iteratorSTL iterator class
 CMemCore::string::iteratorSTL iterator class
 Cstring::iteratorSTL iterator class
 Cvector< T >::iteratorSTL iterator class
 CWizt::deque< T >::iteratorSTL iterator class
 CWizt::list< T >::iteratorSTL iterator class
 CWizt::map< K, T >::iteratorSTL iterator class
 CWizt::multimap< K, T >::iteratorSTL iterator class
 CWizt::multiset< K >::iteratorSTL iterator class
 CWizt::set< K >::iteratorSTL iterator class
 CWizt::string::iteratorSTL iterator class
 CWizt::ValueMap::iteratorFunctor base class for iteration over the components
 CWizt::ValuePool::iteratorAn iterator to traverse the existing value pools
 CWizt::vector< T >::iteratorSTL iterator class
 CWizt::VScriptable::iteratorLocal iterator to allow traversal of all functors
 CWizt::VScriptParameters::iterator
 CWizt::VScriptValue::iterator
 CEagle::IVec4Packed
 CWizt::VRenderContext::JitterA structure to define a little offset from the main camera settings
 CJPEG_ERROR
 CEagle::KDTreeCallBackFunctor< N, T >
 CEagle::KDTreeResult< Container >
 CEagle::KDTreeResult< std::list< T > >
 CEagle::KDTreeResult< std::map< double, T > >
 CEagle::KDTreeResult< std::multimap< double, T > >
 CEagle::KDTreeResult< std::set< T > >
 CEagle::KDTreeResult< std::vector< T > >
 CPosixThreads::Thread::Key
 CWizt::HotKey::KeyConvenience class to handle additional hotkeys
 CEagle::KeyValue< Value >Entry in interpolation table with some flags
 CWizt::Label
 CMemCore::LastKnownSourceCodeLineEntry
 CWizt::VFrameBuffer::Grab::Layer
 CWizt::LayeredMultiViewsHandling multiple views in multiple layers in multiple viewports
 CWizt::LayeredMultiViews::Layers
 CMemCore::LoaderBase::ldrparAbstract internal helper class
 CEagle::LE
 CEagle::LeibnitzRule< MultiplicationFunctor >Implements the Leibnitz rule for derivatives for binary operators o: [A o B ],x = [A,x o B + [A o B,x]
 CEagle::LeibnitzRule< BinaryOperatorFunctor< ScalarNode, ScalarNode, ScalarNode, ' *'> >
 CEagle::LeibnitzRule< ScalarTimesVector >
 CEagle::LeibnitzRule< VectorDotProduct >
 CEagle::LeibnitzRule< VectorTimesScalar >
 CWizt::lessValueSetPtrKey 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
 CWizt::LineProgramBase class for shader programs enhancing the display of lines
 CMETA::LIST< Type, NEXT, Types >Single Linked LIST Metatemplate
 CWizt::ListID::List
 Clist< T >STL class
 CMemCore::list< T >STL class
 Cstd::list< T >STL class
 CWizt::list< T >STL class
 Cstd::list< GrabReason >
 Cstd::list< RefPtr< BufferArray > >
 CWizt::ListID
 CMemCore::LoaderRegistryBase
 CEagle::LocationComponent< Component >Extracts a component of a location
 Cstd::lock_guard< T >STL class
 CEagle::LT
 CEagle::map< K, T >STL class
 Cmap
 Cstd::map< K, T >STL class
 CWizt::map< K, T >STL class
 Cstd::map< glsl, AnyUniform >
 Cstd::map< string, string >
 CWizt::BufferArray::MapMemoryAPI For glMapBuffer
 CWizt::MapMemoryBase class for memory mapping
 CWizt::MatrixOrArray
 CWizt::MemberID
 CMemCore::MemSizeConfig< bits >
 CMemCore::MemSizeConfig< 4 >
 CMemCore::MemSizeConfig< 8 >
 CMETA::META_VOID
 CEagle::MetaInfo< T >
 CWizt::VFrameBuffer::MetaInfoMeta information available per frame
 CEagle::MetaInfo< bivector3::Base_t >
 CEagle::MetaInfo< bivector3f::Base_t >
 CEagle::MetaInfo< Christoffel< N, Scalar_t > >
 CEagle::MetaInfo< Column< N, Scalar_t > >
 CEagle::MetaInfo< Coordinates< Cartesian3D, double >::bivector::Base_t >
 CEagle::MetaInfo< Coordinates< Cartesian3D, double >::covector::Base_t >
 CEagle::MetaInfo< Coordinates< Cartesian3D, double >::point::Base_t >
 CEagle::MetaInfo< Coordinates< Cartesian3D, double >::vector::Base_t >
 CEagle::MetaInfo< covector3f::Base_t >
 CEagle::MetaInfo< DomainVector< Vector< ValueType, 3 >, RGB > >
 CEagle::MetaInfo< DomainVector< Vector< ValueType, 4 >, RGBA > >
 CEagle::MetaInfo< DomainVector< VectorType, Domain, scalar_t > >
 CEagle::MetaInfo< Eagle::PhysicalSpace::bivector >
 CEagle::MetaInfo< Eagle::PhysicalSpace::rotor >
 CEagle::MetaInfo< FixedArray< T, N > >Implement the meta-information on fixed arrays
 CEagle::MetaInfo< LowerTriangular< N, Scalar_t > >
 CEagle::MetaInfo< Matrix< R, C, Value > >
 CEagle::MetaInfo< metric33::Base_t >
 CEagle::MetaInfo< point3::Base_t >
 CEagle::MetaInfo< point3f ::Base_t >
 CEagle::MetaInfo< ResultType >
 CEagle::MetaInfo< rgba_float_t::Base_t::Base_t >
 CEagle::MetaInfo< Row< N, Scalar_t > >
 CEagle::MetaInfo< trivector3::Base_t >
 CEagle::MetaInfo< tvector3::Base_t >
 CEagle::MetaInfo< vector3f::Base_t >
 CEagle::MetaInfo< Vector< T, N > >
 CEagle::MetaInfo< void >
 CEagle::MetaInfoElementIndex< T >For multidimensional types T of rank MetaInfo<T>::RANK, this class provides a mapping from index space to memory space
 CEagle::MetaInfoElementIndex< Christoffel< N, Scalar_t > >
 CEagle::MetaInfoElementIndex< LowerTriangular< N, Scalar_t > >
 CEagle::MetaInfoElementIndex< Matrix< R, C, Value > >
 CEagle::MetaInfoIO< T >Helper class which is provides some textual output for MetaInfo types
 CEagle::MetaInfoIO< MetaInfo< T > >
 CEagle::MetaInfoNonTensor< T >
 CEagle::MetaInfoNonTensor< Christoffel< N, Scalar_t > >
 CMETA::MetaTypeInfo< T >
 CMETA::MetaTypeInfo< std::array< T, N > >
 CMETA::MetaTypeInfo< std::vector< T > >
 CMETA::MetaTypeInfo< T[N]>
 CWizt::MetaViewerCreatorEnvironmentAbstract class describing the environment when creating viewer windows
 CWizt::Brush::MetricFor analytical shapes of a brush, allows to model spheres, ellipsoids, ellipses, cylinders..
 CWizt::Size::Minus
 Cqrcodegen::QrSegment::Mode
 CWizt::ModelViewMatrixA helper class for exception-safe pushing and popping of the OpenGL model view matrix
 CWizt::VGlobals::ModuleInfoInformation about plugins
 CWizt::VManagedObject::ModuleIteratorAbstract iterator class
 Cstd::multimap< K, T >STL class
 CWizt::multimap< K, T >STL class
 CMemCore::MultiPtrMapHash< Object >
 CWizt::multiset< K >STL class
 CWizt::MultiviewOVR::MultiviewCapabilityCheck whether the OVR Multiview and other multiview-related extensions are available
 CMemCore::MutableNameA class holding a string whose changes are announced to a set of listeners
 CPosixThreads::Mutex
 Cstd::mutexSTL class
 CMyAnemoneInitializer
 CMyCreatorBase
 CMETA::NIL
 CEagle::NotElementOfFunctor< L, R >
 CWizt::NotifiedValueIterator
 CMemCore::NotNullPtrA type to specify non-null pointer requirements
 CMemCore::NoVerboseRecursion
 CMemCore::NoVerboseStream
 CObject
 CWizt::ObjectQualityClassification for the quality of objects that may be provided by some Creator
 CObjectState
 CMTools::OcTreeStd
 CWizt::OfflineRenderResult
 CEagle::Operator< CompType, bop >An type-only template used as argument on computational constructors
 CEagle::OperatorBase
 COperatorData
 COscillatorDiffEquation
 CWizt::VSlotContainer::out< Type, OperatorType >Output types
 CWizt::VObject::OutputObjectIteratorIterator callback object for searching and finding output objects
 CWizt::VNutrition::OutputScript
 CTraum::AdaptiveRungeKutta< DiffEquation >::OutputVarsSet of variables that contain output information
 CTraum::Euler< DiffEquation >::OutputVarsSet of variables that contain output information
 CTraum::Rk4< DiffEquation >::OutputVarsSet of variables that contain output information
 Cstd::pair< T1, T2 >STL class
 CWizt::pair< T1, T2 >STL class
 CWizt::GlossyTexture::ParametersA bunch of parameters that allow control of the gloss
 CWizt::RenderBasin::Program::ParametersProgram parameters that need to be set before linking shader stages
 CWizt::RenderBasin::Program::Parameters.Geometry
 CWizt::RenderBasin::Program::Parameters.Geometry.Output
 CVishControl::ParValues
 CVWebControl::ParValues
 CWizt::PBO
 CPendulumDiffEquation
 CWizt::PixelZoomPixel zoom parameters
 CEagle::PhysicalSpace::PlaneNormal form of a plane
 CEagle::PhysicalSpace::Frustum::Planes
 Cfpng::png_chunk_prefix
 Cfpng::png_iend
 Cfpng::png_ihdr
 CWizt::VMultiPointerDevice::Point
 CCoordinates::point
 CMETA::Pow< N, M, C >
 CMETA::Pow< N, M, 1 >
 CMETA::PreciserType< A, B >
 CMETA::Precision< Type >
 CMETA::Precision< char >
 CMETA::Precision< ddouble >
 CMETA::Precision< double >
 CMETA::Precision< float >
 CMETA::Precision< int >
 CMETA::Precision< long >
 CMETA::Precision< long double >
 CMETA::Precision< qdouble >
 CMETA::Precision< short >
 CMemCore::PreDestructionTrait< Object >Trait class that allows to execute some action on an object when it is going to be deleted
 CMemCore::PreDestructionTrait< Cacheable >
 CWizt::ProgrammableA helper class to create a shader program from either intrinsic code, or external files, as given under the specified name in Programmable::CompileShader()
 CWizt::VActionNotifier::ProgressHelper class for following the progress of some slow activity
 CWizt::ProjectionParametersProjection parameters for rendering
 Cqrcodegen::QrCode
 Cqrcodegen::QrSegment
 CReadonlySingleFileLoader
 CWizt::VContext::RealTime
 Cstd::recursive_mutexSTL class
 CRef
 CMemCore::Globals::RefCounterCheck
 CReference
 CMemCore::ReferenceBase< Object >Base class for objects which do reference counting
 CReferenceBase
 CWizt::ReferenceBase< Object >Base class for objects which do reference counting
 CMemCore::ReferenceBase< A >
 CMemCore::ReferenceBase< Addendum >
 CMemCore::ReferenceBase< ApplicationQuitter >
 CMemCore::ReferenceBase< Base >
 CMemCore::ReferenceBase< Cacheable >
 CMemCore::ReferenceBase< CacheBase >
 CMemCore::ReferenceBase< CacheMap >
 CMemCore::ReferenceBase< ChunkBase >
 CMemCore::ReferenceBase< Cluster >
 CMemCore::ReferenceBase< Colormap >
 CMemCore::ReferenceBase< Connector >
 CMemCore::ReferenceBase< CrashHandler >
 CMemCore::ReferenceBase< CreatorBase >
 CMemCore::ReferenceBase< Data >
 CMemCore::ReferenceBase< DeferredRenderer >
 CMemCore::ReferenceBase< DependentObject >
 CMemCore::ReferenceBase< Expectation >
 CMemCore::ReferenceBase< Font >
 CMemCore::ReferenceBase< Framebuffer >
 CMemCore::ReferenceBase< FrameCompletion >
 CMemCore::ReferenceBase< FrameGrabber >
 CMemCore::ReferenceBase< Functor >
 CMemCore::ReferenceBase< GLContextChecker >
 CMemCore::ReferenceBase< GLFontManager >
 CMemCore::ReferenceBase< Grab >
 CMemCore::ReferenceBase< ID >
 CMemCore::ReferenceBase< ImageTileProcessor >
 CMemCore::ReferenceBase< Int >
 CMemCore::ReferenceBase< InteractionGrabber >
 CMemCore::ReferenceBase< Interactor >
 CMemCore::ReferenceBase< InterfaceBase >
 CMemCore::ReferenceBase< InterfaceIterationParameter >
 CMemCore::ReferenceBase< KDTree< N, T > >
 CMemCore::ReferenceBase< Lexicon >
 CMemCore::ReferenceBase< LightSource >
 CMemCore::ReferenceBase< LoaderBase >
 CMemCore::ReferenceBase< LoaderParameters >
 CMemCore::ReferenceBase< LoaderRequest >
 CMemCore::ReferenceBase< MaxRequestExecutor >
 CMemCore::ReferenceBase< ModelViewMatrixState >
 CMemCore::ReferenceBase< MovieManager >
 CMemCore::ReferenceBase< MultipleStringSelection >
 CMemCore::ReferenceBase< MultiRange< T > >
 CMemCore::ReferenceBase< NamedRenderExceptions >
 CMemCore::ReferenceBase< Node >
 CMemCore::ReferenceBase< Notifier >
 CMemCore::ReferenceBase< OcTree< T > >
 CMemCore::ReferenceBase< OutputFormat >
 CMemCore::ReferenceBase< PickList >
 CMemCore::ReferenceBase< PixelBuffer >
 CMemCore::ReferenceBase< Provenance >
 CMemCore::ReferenceBase< QuadTree< T > >
 CMemCore::ReferenceBase< Receiver >
 CMemCore::ReferenceBase< ReferenceCounted >
 CMemCore::ReferenceBase< Renderer >
 CMemCore::ReferenceBase< Result >
 CMemCore::ReferenceBase< SaveInterfaceCreatorBase >
 CMemCore::ReferenceBase< Seagrass >
 CMemCore::ReferenceBase< Shader >
 CMemCore::ReferenceBase< ShaderInjectorBase >
 CMemCore::ReferenceBase< State >
 CMemCore::ReferenceBase< StringList >
 CMemCore::ReferenceBase< Task >
 CMemCore::ReferenceBase< Tentacle >
 CMemCore::ReferenceBase< TypedSlotCreator >
 CMemCore::ReferenceBase< TypeSpecificGLCacheFactory >
 CMemCore::ReferenceBase< Updater >
 CMemCore::ReferenceBase< VAcceptInfo >
 CMemCore::ReferenceBase< VAcceptList >
 CMemCore::ReferenceBase< VAction >
 CMemCore::ReferenceBase< VActionNotifier >
 CMemCore::ReferenceBase< ValueNotifier >
 CMemCore::ReferenceBase< ValueNotifierList >
 CMemCore::ReferenceBase< ValuePool >
 CMemCore::ReferenceBase< ValuePoolCreator >
 CMemCore::ReferenceBase< ValuePoolProvider >
 CMemCore::ReferenceBase< ValueSet >
 CMemCore::ReferenceBase< VCameraSet >
 CMemCore::ReferenceBase< VConnectionValidator >
 CMemCore::ReferenceBase< VCreatorMap >
 CMemCore::ReferenceBase< VerboseCatcher >
 CMemCore::ReferenceBase< VishSaver >
 CMemCore::ReferenceBase< VLogger >
 CMemCore::ReferenceBase< VManagedObjectBase >
 CMemCore::ReferenceBase< VModule >
 CMemCore::ReferenceBase< VOperatorCache< OperatorData > >
 CMemCore::ReferenceBase< VParameterConnectionConstraint >
 CMemCore::ReferenceBase< VRenderInterruptor >
 CMemCore::ReferenceBase< VRenderPrecision >
 CMemCore::ReferenceBase< VScriptFunctor >
 CMemCore::ReferenceBase< VScriptParameters >
 CMemCore::ReferenceBase< VScriptTypedValue >
 CMemCore::ReferenceBase< VScriptValue >
 CMemCore::ReferenceBase< VSlot >
 CMemCore::ReferenceBase< VTaskMessage >
 CMemCore::ReferenceBase< VUndoAction >
 CMemCore::ReferenceBase< VUrlSystemHandler >
 CMemCore::ReferenceBase< VValueBase >
 CMemCore::ReferenceBase< VValueCreator >
 CMemCore::ReferenceBase< XBase >
 CMemCore::ReferenceCountBase class for thread-safe reference counting
 CMemCore::Referer< Object >
 CMemCore::RefPtrTypeTrait< RefType, RefTypeBase >Default type trait for the RefPtr pointer -> operator
 CWizt::GlossyTexture::RenderAn exception-safe way to call the beginRender() and endRender() routines of the GlossyTexture
 CWizt::render_lambda_traits< T >
 CWizt::render_lambda_traits< Ret(Class::*)(Arg1, Arg2) const >
 CWizt::RenderCategoryConstraint
 CWizt::VFrameBuffer::RenderError
 CWizt::RenderNamespaceEnums used for rendering
 CWizt::RenderAble::RenderTimeRender this object (calling safe_render() ) including timing measurements
 CHTTP::RequestHttp://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
 CWizt::RequestExecutor
 CMemCore::ReserveOnlyHelper class as pseudo-argument for Chunk<> creators
 CBaseChunk::result
 CBaseChunk::result
 CBaseChunk::result
 CBaseChunk::result
 CBaseChunk::result
 CBaseChunk::result
 CBaseChunk::result
 CBaseChunk::result
 CBaseChunk::result
 CBaseChunk::result
 CMemCore::result< T >
 CResultNode
 CBinaryFunctor::ResultNode_t
 CFunctor::ResultNode_t
 CMultiplicationFunctor::ResultNode_t
 CTernaryFunctor::ResultNode_t
 CEagle::map< K, T >::reverse_iteratorSTL iterator class
 CEagle::string::reverse_iteratorSTL iterator class
 Clist< T >::reverse_iteratorSTL iterator class
 CMemCore::list< T >::reverse_iteratorSTL iterator class
 CMemCore::string::reverse_iteratorSTL iterator class
 Cstring::reverse_iteratorSTL iterator class
 Cvector< T >::reverse_iteratorSTL iterator class
 CWizt::deque< T >::reverse_iteratorSTL iterator class
 CWizt::list< T >::reverse_iteratorSTL iterator class
 CWizt::map< K, T >::reverse_iteratorSTL iterator class
 CWizt::multimap< K, T >::reverse_iteratorSTL iterator class
 CWizt::multiset< K >::reverse_iteratorSTL iterator class
 CWizt::set< K >::reverse_iteratorSTL iterator class
 CWizt::string::reverse_iteratorSTL iterator class
 CWizt::vector< T >::reverse_iteratorSTL iterator class
 CEagle::RGB
 CMemCore::SarahConnor< ReferenceCounted >
 CMemCore::SaveParameters::SaveError
 CWizt::VSaveable::SaveIteratorAccompanying iterator class
 CMemCore::SaveRegistryBase
 CEagle::ScalarCubeCompute $x^3$
 CEagle::ScalarPlusBivectorA node operator implementing creation of rotor from scalar and bivector
 CEagle::ScalarSquare
 CEagle::ScalarTimesVectorA node implementing scalar times vector multiplication
 CScalarType
 CTraum::SecondOrderDiffEquationIP853< IntegratorType >
 CTraum::SecondOrderIntegrator853< Real >
 CMemCore::Globals::SectionProperties
 CMemCore::SelfInitializeInternal class used as an argument for a computational destructor
 CWizt::SensorArea< Extent >Extended information as provided by a sensor on the screen such as the mouse cursor
 CWizt::SensorArea< 1 >
 Cstd::set< K >STL class
 CWizt::set< K >STL class
 CWizt::ShaderConditionalsBase class to ease setting a VSlot as shader defines
 CWizt::Programmable::ShaderPrefix
 CWizt::RenderBasin::ShaderProgramHelper struct for alternative call to createProgram() with better uniqueness of arguments
 CWizt::Programmable::ShaderSegment
 CMemCore::shared_mutex
 CsignedfloatIndicates that the texture type is in range [-1,+1]
 CMemCore::simplestring
 CWizt::ImageTile::SizeLocal size class, used for tiles
 CWizt::SizeSize class for two-dimensional images
 CWizt::SlotEvaluator< I, SlotList >
 CWizt::SlotEvaluator< 1, SlotList... >
 CWizt::Slottify::SlotInfoInformation describing a specific Slot
 CWizt::SlottifyUtility class for dealing with conversions from VObject and its Slots to strings and vice versa
 CMemCore::SocketErrorException class for socket failures
 CSoShape
 CWizt::SpaceNavigation
 CEagle::PhysicalSpace::Span< N >
 CMemCore::Span< T, Extent >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
 CEagle::PhysicalSpace::Span< 1 >A one-dimensional span, also a known as a Ray
 CEagle::PhysicalSpace::Span< 2 >A two-dimensional span, also a known as the parametric form of a plane
 CEagle::PhysicalSpace::Span< 3 >
 CMemCore::Span< T, dynamic_extent >Specialization of a span for the case of runtime-defined lengths
 CMemCore::SpeakPtr
 CEagle::Spherical3D
 CEagle::STA::SphericalChart4D
 CMemCore::AssertionCallback::StackFrame
 CMemCore::StackTrace
 CState
 CVLightSource::State
 CWizt::VLogger::StateDescribes a thread-local state of the logging process
 CTraum::dop853< DiffEquation >::statistic_vars
 CTraum::AdaptiveRungeKutta< DiffEquation >::StatisticVars
 CTraum::Euler< DiffEquation >::StatisticVars
 CTraum::Rk4< DiffEquation >::StatisticVars
 CWizt::StatusIndicatorBase class for convenient messing around with the status to be displayed for a certain object
 CWizt::Seagrass::StorageBufferStatistics
 CWizt::StorageFlagsEncapsulation of https://registry.khronos.org/OpenGL-Refpages/gl4/html/glBufferStorage.xhtml
 CMemCore::StreamSaver
 CWizt::StreamString
 CEagle::SubMatrix< R, C, Matrix >SubMatrix is a Matrix with row R and column C deleted
 CEagle::SubMatrix< N, N, Quadratic >
 CEagle::Vector< T, n >::subvector< size, offset >Access part of the vector as a vector of smaller size
 CEagle::SumDerivation< SummationFunctor >Implements the derivation of a sum [A + B ],x = A,x + B,x
 CEagle::SumDerivation< BinaryOperatorFunctor< NodeType, NodeType, NodeType, '+'> >
 CEagle::SumDerivation< ScalarPlusBivector >
 CMETA::Swap< T, I, J, Comp >
 CMETA::SymmetricChooseWithOutPermutation< N >Expression template to compute the combinatoric formula used for the number of elements of a supersymmetric cubical: (2n-1)!
 CT
 CEagle::TensorBaseTensor experiments
 CWizt::Anemone::TentacleIteratorTentacle iterator base class
 CMemCore::Terminator< ReferenceCounted >
 CWizt::TEXTURE
 CWizt::RenderBasin::TextureStorageFormatEnum for the storage type of the texture, which will affect memory utilization on the GPU
 CPosixThreads::Thread
 CMemCore::ThreadPoolA pool of threads, to be used in conjunction with async()
 CMemCore::TimerA class to hide system dependent methods to count seconds
 CWizt::TouchableAbstract base class for objects that can be touched
 CWizt::TransformOperator::TransformAn exception-safe helper class to invoke the transformation functor
 CWizt::TransformOperatorImplements an operation that affects a 3D rendering, in whatever way
 CWizt::RenderAble::TransparencyHandlerTransparency handlers are special objects that handle other transparent objects
 CEagle::TransposeOperation
 CEagle::TriangleStripClass to compute a contiguous triangle strip for a two-dimensional set of points
 CWizt::VRenderContext::Font::TypeBits describing the properties of a font
 CMemCore::type< T >
 CMETA::TypeDescriptorFor native and array types
 CEagle::TypeIndexingScheme< T >
 CMemCore::TypeInfoHelper class for mapping C++ data types to objects
 CEagle::UIVec4Packed
 CEagle::UnaryMinus< NodeType >
 CWizt::UndoStackHelper class to provide two input actions for undo/redo operations
 CWizt::UniformBufferRegistry
 CWizt::UniqueQueue< T >
 CEagle::UnitHttp://en.wikipedia.org/wiki/Fundamental_unit In the SI system there are 7 fundamental units: kilogram, meter, candela, second, ampere, kelvin, and mole
 Cstd::unordered_map< K, T >STL class
 CWizt::VStream::URL
 CWizt::VAcceptionAccept information for a given VObject
 CWizt::VAcceptListTracer
 CWizt::ValueCacheableBase class for caching values of VSlots relative to an Intercube
 CWizt::ValueMapList of the components of a compound type
 CWizt::ValuePoolRefererAbstract base class for objects that may provide objects that provide an active value pool (two-fold indirection)
 CWizt::ValueShadowIteratorIterator class for values stored in multiple ValuePools (also called "shadows" of a variable)
 CWizt::VCameraThe Camera object for OpenGL operations in VISH
 CWizt::VChartListSpecify a coordinate system
 CWizt::VConnectionTypeColorsA helper class that serves to associate types with color values, that are stored a text
 CWizt::VConnectionValidatorListA base class for objects that inform VConnectionValidator about their validity
 CWizt::VCotaskBase class for VObjects (to be used via multiple inheritance) to ease asynchroneous computations in a thread
 CVCreatorBase
 CWizt::VCreatorCategory
 CWizt::VCreatorPropertyElements
 CEagle::Vec3Pack32bitGeneric unpacking from 32-bit integer with bits per channel given explicitly
 CEagle::Vec3Pack64bitGeneric unpacking from 64-bit integer with bits per channel given explicitly
 CEagle::Vec3Pack_10_11_11
 CEagle::Vec3Packed
 CEagle::Vec3Packed.packed
 CCoordinates::vector
 Cstd::vector< T >STL class
 Cvector< T >STL class
 CWizt::vector< T >STL class
 CEagle::VectorDotProductDot product between tangential vectors
 CEagle::VectorizationTrait< value >A trait class to specify which vectorizations are possible
 CEagle::VectorSquareComputes v^2 for vector v
 CEagle::VectorTimesScalarA node implementing vector times scalar multiplication
 CVectorType
 CEagle::VectorWedgeVectorA node operator implementing creation of a bivector from two vectors
 CMemCore::Globals::VerboseFiles
 CMemCore::VerboseRecursion
 CMemCore::VerboseStreamThe class provides verbose printing of messages
 CWizt::VertexArrayCreator< int >
 CWizt::VertexArrayCreator< VGL_NAMED_VERTEX_ATTRIB >
 CWizt::VertexArrayCreator< VGL_TEX0_COORDINATES >
 CWizt::VertexArrayCreator< VGL_TEX1_COORDINATES >
 CWizt::VertexArrayCreator< VGL_VERTEX_COLORS >
 CWizt::VertexArrayCreator< VGL_VERTEX_COORDINATES >
 CWizt::VertexArrayCreator< VGL_VERTEX_NORMALS >
 CWizt::VertexArrayCreator< VGL_VERTEX_SECONDARY_COLORS >
 CWizt::VertexArrayObjectLimitations of using OpenGL fences for VAO and buffer upload readiness
 CWizt::VERTEXBUFFER
 CWizt::GeometryShader::VerticesIn< InputType >Enum member N tells how many vertices are available per call of the GeometryShader
 CWizt::VFrameBufferEncapsulation of a framebuffer, which is used to collect image rendering results
 CWizt::VGlobalsGlobal Datastructures
 CWizt::VGraphRequired operations:
 CWizt::ViewerStateClass describing the state of a Viewer , to be communicated via a PolyOutput from each Viewer object to a MetaViewer object that bundles many Viewers
 CEagle::PhysicalSpace::ViewportA helper class describing an axis-aligned rectangle
 CWizt::ViewportGeometryThe properties of the viewport
 CVInitializationInitialization: Each Plugin should (MacOS: Must) contain a function
 CWizt::VInputClassRecognitionBy default, all slots are class zero
 CWizt::VInputCreatorIteratorAbstract base class for iterators of input objects
 CWizt::VInputRegistry< InputType >Templated convenience class that encompassess all VInput registry functions that are associated with a certain type
 CWizt::VInputValueTrait< Type >
 CWizt::VInputValueTrait< Eagle::FixedArray< double, 2 > >
 CWizt::VInputValueTrait< Eagle::FixedArray< double, 4 > >
 CWizt::VInputValueTrait< Eagle::FixedArray< int, 3 > >
 CWizt::VInputValueTrait< Eagle::metric33 >
 CWizt::VInputValueTrait< Eagle::PhysicalSpace::bivector >
 CWizt::VInputValueTrait< Eagle::PhysicalSpace::point >
 CWizt::VInputValueTrait< Eagle::PhysicalSpace::rotor >
 CWizt::VInputValueTrait< Eagle::PhysicalSpace::tvector >
 CWizt::VInputValueTrait< Enum >Type trait for Enum types as input objects
 CWizt::VInputValueTrait< ImageTile >
 CWizt::VInputValueTrait< info >
 CWizt::VInputValueTrait< MemCore::RefPtr< Type > >
 CWizt::VInputValueTrait< MetaViewerInputType >
 CWizt::VInputValueTrait< Options >
 CWizt::VInputValueTrait< Plane >
 CWizt::VInputValueTrait< rgba_float_t >
 CWizt::VInputValueTrait< std::array< Type, 1 > >
 CWizt::VInputValueTrait< string >
 CWizt::VInputValueTrait< TransformOperator >
 CWizt::VInputValueTrait< VCamera >
 CWizt::VInputValueTrait< VCameraSetPtr >
 CWizt::VInputValueTrait< VChart >
 CWizt::VInputValueTrait< VFrameBuffer >
 CWizt::VInputValueTrait< VGraph >
 CWizt::VInputValueTrait< VImageTileProcessor >
 CWizt::VInputValueTrait< VInteractionEvent >
 CWizt::VInputValueTrait< VMultiPointerDevice >
 CWizt::VInputValueTrait< VObjectStatus >
 CWizt::VInputValueTrait< VRenderAble >
 CWizt::VInputValueTrait< VScalarFunctor >
 CWizt::VInputValueTrait< VSceneLayers >Type trait to allow using VSceneLayers as inputs for Vish objects
 CWizt::VInputValueTrait< VSocketAction >
 CWizt::VInputValueTrait< VThreadManager >
 CWizt::VInputValueTrait< VTime >
 CWizt::VInputValueTrait< VTypeTemplate >
 CWizt::VInteractionEventCommunication type for mouse and keyboard interactions
 CTraum::VirtualSecondOrderDiffEquation< real >Implementation of a differential equation of 2nd order for the dop853 solver
 CWizt::VLogMessager
 CVltstr
 CWizt::VManagedObjectIteratorAbstract iterator class for iterating over a Domain of objects
 CWizt::VModulesNamespace-like class for handling plugins
 CWizt::VMultiPointerDevice
 CWizt::VObjectAgeInternal class used to store various ages of objects
 CWizt::VObjectExceptionBase class for exceptions that refer to VObjects
 CWizt::VObjectIteratorIterator functor to be used for iterating over the parents of a certain VObject
 CWizt::VObjectStatusDescription of the status of an object, primarily to be used within a GUI display
 CWizt::VOutputIteratorThe callback class for iterating over the output objects (i.e
 CEagle::ViewPoints::VPData
 CWizt::VManagedObject::VRemoveItemCallback object when unloading a module
 CWizt::VRenderAbleA reference to a RenderAble object
 CWizt::VSaveableBase class for objects that can be saved to some URL
 CWizt::VScalarFunctorImplements a function that yields a scalar value, given some floating point input
 CWizt::VSceneObjectsA list of renderable objects, sorted in layers
 CWizt::VSchedulerScheduler for VISH Objects
 CWizt::VScriptableBase class for objects that may be accessed via a script interface
 CWizt::VScriptActions
 CWizt::VSlotChangeInfoVish I/O data structure to communicate a set of Slots
 CWizt::VSlotGlobalsInternal helper class
 CWizt::VSlotIteratorThe callback class for iterating over the input objects (i.e
 CWizt::VSocketActionAbstract interface class that is to be implemented by some application
 CWizt::VStreamNetwork connection routines
 CVStreamCreator
 CWizt::VTextRenderProperties
 CWizt::VThreadManagerManaging Threads - the code to be executed in another thread is provided in functor objects derived from VTask
 CWizt::VTimeAn input type for steering time-dependent objects
 CWizt::VTraceRequestIDTrace the ID of an request
 CWizt::VTransformable
 CWizt::VTypeTemplate
 CWizt::VValueCompareTrait< Type >Compares two values numerically to identify if they have changed
 CWizt::VValueCompareTrait< Brush >
 CWizt::VValueCompareTrait< Cursor3DProperties >
 CWizt::VValueCompareTrait< Plane >
 CWizt::VValueCompareTrait< RefPtr< TypedChunk< Type > > >
 CWizt::VValueCompareTrait< View >
 CWizt::VValueCompareTrait< VThreadManager >
 CWizt::VValueCopyTrait< Type >Type trait class that tells how to create a new value, given an existing one
 CWizt::VValueCopyTrait< Action >
 CWizt::VValueCopyTrait< Eagle::MultiRange< T > >
 CWizt::VValueCopyTrait< RefPtr< Fog > >
 CWizt::VValueCopyTrait< RefPtr< Type > >Copy type trait for referenced types: create a new instance of the referred-to object
 CWizt::VValueCopyTrait< RefPtr< TypedChunk< T > > >Copy operation is per reference, not per value!
 CWizt::VValueCopyTrait< VBoundingBox >
 CWizt::VValueCopyTrait< VColormap >
 CWizt::VValueTrait< Type >Type trait for VValues that specify how to convert a certain value from and to text
 CWizt::VValueTrait< Action >
 CWizt::VValueTrait< bool >
 CWizt::VValueTrait< BoundingBall >
 CWizt::VValueTrait< Brush >
 CWizt::VValueTrait< char >
 CWizt::VValueTrait< Cursor3DProperties >
 CWizt::VValueTrait< double >
 CWizt::VValueTrait< Eagle::FixedArray< double, 2 > >
 CWizt::VValueTrait< Eagle::FixedArray< double, 4 > >
 CWizt::VValueTrait< Eagle::FixedArray< int, 3 > >
 CWizt::VValueTrait< Eagle::metric33 >
 CWizt::VValueTrait< Eagle::MultiRange< T > >Conveniently import eagle's multirange
 CWizt::VValueTrait< Eagle::PhysicalSpace::bivector >
 CWizt::VValueTrait< Eagle::PhysicalSpace::point >
 CWizt::VValueTrait< Eagle::PhysicalSpace::rotor >
 CWizt::VValueTrait< Eagle::PhysicalSpace::tvector >
 CWizt::VValueTrait< Enum >Type trait for Enum types as VObject communicators
 CWizt::VValueTrait< float >
 CWizt::VValueTrait< ImageTile >
 CWizt::VValueTrait< info >
 CWizt::VValueTrait< int16_t >
 CWizt::VValueTrait< int32_t >
 CWizt::VValueTrait< int64_t >
 CWizt::VValueTrait< Label >
 CWizt::VValueTrait< LabelSet >
 CWizt::VValueTrait< MemCore::RefPtr< Fog, ShaderInjectorBase > >
 CWizt::VValueTrait< MetaViewerInputType >
 CWizt::VValueTrait< Options >
 CWizt::VValueTrait< Plane >
 CWizt::VValueTrait< PointDataChunk >
 CWizt::VValueTrait< Range >
 CWizt::VValueTrait< RefPtr< TypedChunk< double > > >
 CWizt::VValueTrait< RefPtr< TypedChunk< float > > >
 CWizt::VValueTrait< RefPtr< TypedChunk< int16_t > > >
 CWizt::VValueTrait< RefPtr< TypedChunk< int32_t > > >
 CWizt::VValueTrait< RefPtr< TypedChunk< int64_t > > >
 CWizt::VValueTrait< rgba_float_t >Value trait for colors
 CWizt::VValueTrait< std::tuple< A, B > >
 CWizt::VValueTrait< string >VValue Specialization for strings: trivial
 CWizt::VValueTrait< string1 >
 CWizt::VValueTrait< TransformOperator >Value trait to allow TransformOperators as object glue
 CWizt::VValueTrait< uint32_t >
 CWizt::VValueTrait< VBoundingBox >The string I/O interface for bounding boxes
 CWizt::VValueTrait< VCamera >
 CWizt::VValueTrait< VCameraSetPtr >
 CWizt::VValueTrait< VChart >
 CWizt::VValueTrait< VChartList >
 CWizt::VValueTrait< VColormap >
 CWizt::VValueTrait< VFrameBuffer >
 CWizt::VValueTrait< VGraph >
 CWizt::VValueTrait< View >
 CWizt::VValueTrait< ViewerState >Type trait for ViewerStates, to be used for TypedSlot<ViewerState> instances
 CWizt::VValueTrait< VImageTileProcessor >
 CWizt::VValueTrait< VInteractionEvent >
 CWizt::VValueTrait< VMultipleStringList >
 CWizt::VValueTrait< VMultiPointerDevice >
 CWizt::VValueTrait< VObjectRef >
 CWizt::VValueTrait< VObjectStatus >
 CWizt::VValueTrait< VRenderAble >
 CWizt::VValueTrait< VScalarFunctor >
 CWizt::VValueTrait< VSceneLayers >Type trait to allow using VSceneLayers as type to be communicated across Vish objects
 CWizt::VValueTrait< VSlotChangeInfo >
 CWizt::VValueTrait< VSlotContainerRef >
 CWizt::VValueTrait< VSocketAction >
 CWizt::VValueTrait< VStringList >
 CWizt::VValueTrait< VThreadManager >
 CWizt::VValueTrait< VTime >
 CWizt::VValueTrait< VTypeTemplate >
 CWizt::VValueTraitSeparator< X >
 CWizt::VValueTraitSeparator< std::tuple< A, B > >
 CWizt::VValueTypename< Type >
 CWizt::VActionNotifier::WarnInfo
 CMemCore::WorkerQueue< Queue >
 CWritePng
 Cyy_buffer_state
 Cyy_trans_info
 Cyyalloc
 CYYLTYPE
 CWizt::YYSTYPE
 CYYSTYPE
 CYYSTYPE.bivec
 CYYSTYPE.point
 CYYSTYPE.rotor
 CYYSTYPE.vec
 CZptr
Generated on for The Vish Visualization Shell by doxygen 1.16.1