| A | |
| Wizt::VStream::Aborted | |
| Absolute | |
| orgQhull::AbsoluteSumOf | Absolute sum of the elements in a container |
| Spheres::AccelState | |
| Ligo::AccelState | |
| CameraNavigator::AccelState | |
| TangVish::AcceptConnections | Server functor: actions that are performed if a new client connects |
| Wizt::RemoteViewer::AcceptConnections | Callback action that is invoked when a new client connection to the server port |
| Wizt::RemoteVish::AcceptConnections | Callback action that is invoked when a new client connection to the server port |
| WebVish::AcceptConnections | Callback action that is invoked when a new client connection to the server port |
| Wizt::AcceptionGenerator | |
| Wizt::AcceptList | |
| Wizt::AcceptListIterator | Accepting arbitrary types directly as second argument of VCreator or VObject::AcceptableInputTypes |
| Wizt::AcceptListIterator< AcceptList< AcceptType, NextAcceptList > > | |
| Wizt::AcceptListIterator< META::LIST< AcceptType, NextAcceptList > > | Using a META::LIST<> as second argument of VCreator or VObject::AcceptableInputTypes |
| Wizt::AcceptListIterator< META::NIL > | Using a META::NIL as second argument of VCreator or VObject::AcceptableInputTypes rejects all input objects |
| Wizt::AcceptListIterator< void > | Using void as second argument of VCreator or VObject::AcceptableInputTypes rejects all input objects |
| Action | |
| Wizt::Anemone::Tentacle::Activator | Helper class for Tentacles, allows exception-save enabling and disabling of Tentacles |
| Wizt::BufferArray::Activator | Helper class for exception-safe enabling of buffer arrays |
| Wizt::VContext::Addendum | Container for additional data specific for this Context |
| MemCore::Ageable | Base class for objects which change from time to time |
| AimBot | |
| AimVish | |
| std::allocator | STL class |
| Alpha | |
| AlphaInput | |
| MemCore::AlzheimerCreator | A Creator object which forgets its data when memory is going low |
| Eagle::PhysicalSpace::AnalyticFunction | Abstract base class for analytical functions that are evaluated on a physical space |
| Eagle::AnalyticFunctionBase | Abstract base class for analytic functions, coordinate-independent |
| Wizt::Anemone | Abstract object for elementary render objects |
| Wizt::AnemoneCreator | The Anemone Cache, called the Seagrass, is based on Anemone objects |
| Wizt::AnemoneCreatorRegistry | |
| Eagle::AntiSymmetric | |
| Eagle::AnyType | |
| Approve | |
| ApproveCommunicator | |
| Arrow | |
| Eagle::Assert< true > | |
| Eagle::Assertion< true > | |
| Wizt::GLCacheFactoryPtr::Assignator | Proxy class for creating GL Objects |
| Eagle::Assignment | Convenience class to allow using the comma operator for assigning a sequence of elements to a given array-like class |
| Wizt::Atlas | |
| MemCore::Intercube::auto_cast | |
| std::auto_ptr | STL class |
| std::bad_alloc | STL class |
| std::bad_cast | STL class |
| std::bad_exception | STL class |
| std::bad_typeid | STL class |
| MemCore::BaseChunk< T, Base, false > | Determine the base class for typed chunks of base classes that have another memory layout |
| MemCore::BaseChunk< T, Base, true > | Determine the base class for typed chunks of base classes that have the same memory layout |
| MemCore::BaseChunk< T, T, true > | Determine the base class for typed chunks of base classes |
| META::BaseClass< Eagle::Column< R, value > > | |
| META::BaseClass< Eagle::Matrix< R, C, Value > > | |
| META::BaseClass< Eagle::PhysicalSpace::point > | |
| META::BaseClass< Eagle::PhysicalSpace::vector > | |
| META::BaseClass< Eagle::Vector< T, n > > | |
| std::basic_fstream | STL class |
| std::basic_ifstream | STL class |
| std::basic_ios | STL class |
| std::basic_iostream | STL class |
| std::basic_istream | STL class |
| std::basic_istringstream | STL class |
| std::basic_ofstream | STL class |
| std::basic_ostream | STL class |
| std::basic_ostringstream | STL class |
| std::basic_string | STL class |
| std::basic_stringstream | STL class |
| ComputeGridStreamLines::BBSelectorBase | |
| ComputeMultiStreamLines::BBSelectorBase | |
| ComputeGridStreamLines::BBSelectorMemoryAll | |
| ComputeMultiStreamLines::BBSelectorMemoryAll | |
| ComputeGridStreamLines::BBSelectorMemoryTree | |
| ComputeMultiStreamLines::BBSelectorMemoryTree | |
| Beta | |
| BetaInput | |
| Eagle::BinaryOperatorFunctor | |
| Eagle::BinaryOperatorNode | Template node class to perform binary operations on evaluate-able nodes |
| Wizt::Framebuffer::Bind | |
| BITMAPFILEHEADER | |
| BITMAPHEADERFILE | |
| std::bitset | STL class |
| Eagle::Coordinates::bivector | A bi-vector in geomtric algebra, which is the span of two vectors |
| Eagle::PhysicalSpace::bivector | A three-dimensional Bi-Vector which is span by two vectors to define a plane |
| Eagle::STA::CartesianChart4D::bivector | A four-dimensional Bi-Vector which is span by two vectors to define a plane |
| Eagle::BoundingBall | Bounding container implemented by a ball |
| Eagle::BoundingBox | A coordinate-parallel bounding box in three dimensions |
| BoundingBox | |
| BoxPlanarPolygon | |
| BoxTree | |
| Wizt::BufferArray | Base class for OpenGL buffer objects, which are the building blocks of Vertex Buffer Objects |
| Wizt::BufferID | Base class holding a certain number of OpenGL buffer id's |
| BundleAction | |
| Wizt::VOperatorCache::Cache | A Cache object, that assigns an OperatorCache with each VObject |
| MemCore::Cache | Main administrative Cache object container |
| MemCore::Cacheable | A domain for objects which may be cached |
| MemCore::CacheBase | Abstract base class for Cache objects |
| MemCore::CacheMap | A list of cache queues for each cacheable type |
| MemCore::CacheMultiQueue | Cache queues of different purpose |
| MemCore::CacheQueue | A root object that holds a tail of cacheable objects |
| Cal3DLoader | |
| Cal3DMeshLoader | |
| Cal3DMeshRenderer | |
| Cal3DMeshVObject | |
| Eagle::Camera | Properties of a camera floating around in space, or, alternatively, an eagle's eye |
| CameraLens | Implementation of a RenderCategory::CAMERA_LENS_OBJECT |
| CameraNavigator | Implementation of a camera which interacts with the mouse |
| Eagle::CameraPath | A camera path with movements, motions and various constraints |
| Wizt::CameraTripod | The Tripod |
| Wizt::GLProgram::CannotAssignUniform | Exception class if a uniform variable in a shader could not be assigned |
| Eagle::Cartesian3D | |
| Eagle::STA::CartesianChart4D | |
| Wizt::CatchStatus | A convenience class that can be added as base class to any VObject |
| ComputeGridStreamLines::CellTracing | |
| ComputeMultiStreamLines::CellTracing | |
| Wizt::CheckCreatorIterator | |
| Eagle::Christoffel | Christoffel symbols |
| Eagle::Coordinates::Christoffel | |
| MemCore::Chunk | A class which handles a chunk of memory |
| MemCore::ChunkBase | Base class for chunks of managed memory (any type possible) |
| MemCore::ChunkDataAddress | |
| MemCore::ChunkDataAddress< bool > | |
| PosixThreads::Thread::CleanUp | |
| TangVish::Client | Client functor: action that are performed when data are sent to the server |
| WebVish::Client | Network Client Callback: action performed when an HTTP request has been accepted and is sent to the server |
| ClientAcceptsImageServer | |
| ClientAcceptsServer | |
| ClientGreeter | |
| Wizt::VStream::Closed | |
| MemCore::Result::Cluster | |
| Cal3DMeshVObject::CMFSaver | |
| Wizt::VDataFlowGraph::CmpObjectPtrs | |
| CollectedData | |
| Wizt::Slottify::CollectionOfLines | A collection of lines, such as parsed from an input string or file |
| Color | |
| Wizt::ColorArray | Base class for OpenGL buffer arrays related to colors |
| Wizt::Colorizer | A vish object component (aka vish skale) that references some colormap and takes care of its parameter handling |
| Wizt::Colormap | Abstract base class for colormaps, which are transfer functions from a floating point value into RGBA values |
| Wizt::ColormapReference | Helper class for attaching colormaps to MemCore::Intercubes |
| Eagle::Column | A column vector |
| ColumnVector | |
| Wizt::RemoteViewer::Communicator | Network Communicator Callback: action performed The receive() callback function is responsible for parsing the HTTP request and invoke appropriate actions |
| Wizt::RemoteVish::Communicator | Network Communicator Callback: action performed The receive() callback function is responsible for parsing the data stream and invoke appropriate actions |
| Wizt::CompareSlotsByName | |
| std::complex | STL class |
| ComputeGridStreamLines | |
| ComputeMultiStreamLines | |
| ComputeStreamLines | |
| ComputeStreamSurfaces | |
| config | |
| Wizt::VSocketAction::Connector | Functor object for callbacks when new clients connect to a server |
| orgQhull::Coordinates::const_iterator | |
| orgQhull::QhullLinkedList::const_iterator | |
| orgQhull::QhullPoints::const_iterator | |
| orgQhull::QhullPointSet::const_iterator | |
| std::basic_string::const_iterator | STL iterator class |
| std::string::const_iterator | STL iterator class |
| std::wstring::const_iterator | STL iterator class |
| std::deque::const_iterator | STL iterator class |
| std::list::const_iterator | STL iterator class |
| std::multimap::const_iterator | STL iterator class |
| std::set::const_iterator | STL iterator class |
| std::vector::const_iterator | STL iterator class |
| std::map::const_iterator | STL iterator class |
| std::multiset::const_iterator | STL iterator class |
| std::basic_string::const_reverse_iterator | STL iterator class |
| std::string::const_reverse_iterator | STL iterator class |
| std::wstring::const_reverse_iterator | STL iterator class |
| std::deque::const_reverse_iterator | STL iterator class |
| std::list::const_reverse_iterator | STL iterator class |
| std::map::const_reverse_iterator | STL iterator class |
| std::multimap::const_reverse_iterator | STL iterator class |
| std::set::const_reverse_iterator | STL iterator class |
| std::multiset::const_reverse_iterator | STL iterator class |
| std::vector::const_reverse_iterator | STL iterator class |
| Eagle::ConstantNode | A node that constructs a type from a constant value |
| Eagle::ConstantVectorNode | A node that implements a constant vector value |
| Wizt::GLCacheFactoryPtr::ConstAssignator | Proxy class for constant access to GL Cache objects |
| Wizt::VCreationPreferences::ConstIterator | |
| Eagle::ConstructorNode | A node that constructs a vectorial type from three scalar values |
| Wizt::VLogger::Context | Set logging context with auto-cleanup |
| Eagle::Context | A set of variable names, with indices associated to each type |
| Eagle::ContravariantIndexingScheme | Indices are all upper indices, e.g |
| Eagle::CoordinateInfo | |
| Eagle::CoordinateInfo< void > | |
| Eagle::Coordinates | Coordinate template class |
| orgQhull::Coordinates | |
| orgQhull::CoordinatesIterator | |
| CoordInter | |
| MemCore::CopyRef | 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 |
| Wizt::Coral | A base class for vish objects that provides Colormaps |
| MemCore::Counter | Base class for thread-safe counting, comes with an exception-safe incrementing/decrementing counter class |
| Eagle::CovariantIndexingScheme | Indices are all lower indices, e.g |
| Eagle::Coordinates::covector | The dual of a vector, i.e the co-vector |
| CreateObjectHtml | Display a list of objects that can be created |
| CreateStepField | |
| CreateStepFieldUShort | |
| Wizt::CreateVertexArray | |
| Wizt::CreateVertexArray_nD | |
| Wizt::CreateVertexArray_nD< Type, ArrayType, 0 > | |
| Wizt::VActionNotifier::CreationSource | An optional property of the VObjectCreation()'s CreationContext telling why the object was created, meaning: which slot requested the creation of this object |
| MemCore::Creator | A Creator is a forwarding of some data object to its creational object |
| MemCore::CreatorBase | A Domain-related abstract base class for reference-counted objects which occupy some memory but are able to release it on demand |
| MemCore::CreatorCacheMap | A list of cache maps for each creator type |
| MemCore::Creature | An abstract base class for object creators |
| CTga | |
| CTgaHeader | |
| Wizt::Cubemap | |
| CubicSpline | |
| CViewer | |
| Data | |
| DataFilter | |
| DataSink | |
| DataSource | |
| Wizt::DefaultAnemoneInitializer | |
| Wizt::DefaultTypedSlotSaveProperty | 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 |
| Wizt::VObject::Deferred | Internal helper class used for the construction of VOutput objects |
| MemCore::DeferredInitializationTrait | Trait class that allows to execute some action on an object when it receives the first strong reference count in its life |
| MemCore::DeferredInitializationTrait< Cacheable > | |
| MemCore::DeferredInitializationTrait< Creature > | |
| MemCore::DeferredInitializationTrait< ReferenceBase< Object > > | |
| Eagle::DegeneratedMatrix | |
| std::deque | STL class |
| Eagle::DerivationTrait< BinaryOperatorFunctor< NodeType, NodeType, NodeType, '+'> > | Computes (u+v),x which is u,x+v,x |
| Eagle::DerivationTrait< BinaryOperatorFunctor< NodeType, NodeType, NodeType, '-'> > | Computes (u-v),x which is u,x-v,x |
| Eagle::DerivationTrait< BinaryOperatorFunctor< ScalarNode, ScalarNode, ScalarNode, '*'> > | Computes (ab),x which is a,x b + a b,y |
| Eagle::DerivationTrait< BinaryOperatorFunctor< ScalarNode, ScalarNode, ScalarNode, '+'> > | Computes (a+b),x which is a,x+b,y |
| Eagle::DerivationTrait< BinaryOperatorFunctor< ScalarNode, ScalarNode, ScalarNode, '-'> > | Computes (a-b),x which is a,x-b,y |
| Eagle::DerivationTrait< BinaryOperatorFunctor< ScalarNode, ScalarNode, ScalarNode, '/'> > | Computes (a/b),x which is (a,x b - a b,y) / b^2 |
| Eagle::DerivationTrait< LocationComponent< Component > > | Computes (v[i]),x |
| Eagle::DerivationTrait< ScalarCube > | Computes (y^3),x which is 3 y^2 y,x |
| Eagle::DerivationTrait< ScalarPlusBivector > | Computes (a+U),x which is a,x+U,v |
| Eagle::DerivationTrait< ScalarSquare > | Computes (y^2),x which is 2 y y,x |
| Eagle::DerivationTrait< ScalarTimesVector > | Computes (a*v),x which is a,x * v + a * v,x |
| Eagle::DerivationTrait< UnaryMinus< NodeType > > | Computes (-v),x which is -(v,x) |
| Eagle::DerivationTrait< VectorDotProduct > | Computes (uv),x which is u,x * v + u * v,x |
| Eagle::DerivationTrait< VectorSquare > | Computes (v^2),x which is 2 v v,x |
| Eagle::DerivationTrait< VectorTimesScalar > | Computes (a*v),x which is a,x * v + a * v,x |
| Eagle::DerivationTrait< VectorWedgeVector > | Computes  which is  |
| Eagle::Determinantor< 1 > | The trivial determinant of a 1x1 matrix |
| Eagle::Determinantor< 2 > | The simple determinant of a 2x2 matrix |
| Eagle::Determinantor< 3 > | |
| Eagle::Determinantor< 4 > | |
| FileSelector::DirState | |
| DisplayFunction | Example background class |
| Wizt::DisplayList | |
| Wizt::DisplayListCreator | |
| Wizt::DisplayListTentacle | |
| DMS | |
| MemCore::domain_cast | |
| std::domain_error | STL class |
| TangentialDifferentialEquationLinear::DOPVarsArray_t | |
| TangentialDifferentialEquationCubic::DOPVarsArray_t | |
| Wizt::DrawArrays | An Vertex Buffer Object renderer that implements the glDrawArrays function |
| MemCore::DynPtr | Encapsuled pointer class for pointers pointing to derived classes |
| MemCore::DynPtr< ObjectBase, ObjectBase > | Base class for pointers to base classes |
| BoxPlanarPolygon::edge | |
| Wizt::VDataFlowGraph::Edge | Information per edge |
| Eagle::ElementOfFunctor | |
| ComputeGridStreamLines::EmitterGrid | |
| IntegralLines::EmitterPoints | |
| Wizt::VSlot::Empty | Internal type for computational constructor |
| MemCore::FunctionStackProfiler::Entry | |
| Wizt::Enum | Enumeration type |
| Wizt::BufferArray::Error | Exception class that might happen during loading of buffer arrays |
| Wizt::Shader::Error | Error class for Shader-related problems, for instance compilation errors |
| Wizt::GLProgram::Error | |
| Wizt::VStream::Error | |
| PosixThreads::Thread::Error | |
| Wizt::VBO::Error | |
| Eagle::EvaluationContext | Class providing numerical values from some context ID for the evaluation of function trees |
| Eagle::Evaluator | Abstract base class providing numerical values from some context ID for the evaluation of function trees |
| Wizt::VFrameBuffer::Exception | |
| MemCore::CreatorBase::Exception | Associated Exception class |
| MemCore::Creature::Exception | Associated Exception class |
| Wizt::VFrameBuffer::Grab::Exception | |
| MemCore::Exception | Base class for exceptions |
| std::exception | STL class |
| Wizt::VStream::Exception | |
| Wizt::VRequest::ID::ExecutionLevel | |
| Wizt::VObject::ExecutionStatus | Exception class that might be thrown by update() and is handled in the data flow traversal |
| Wizt::Expectation | Define that we are expecting a certain number of bytes from an VSocketAction::Receiver object |
| Eagle::FA_CONVERT | |
| std::ios_base::failure | STL class |
| FileInfo | |
| FileSelector | |
| Vish::Filter | |
| FindSeedpoint::findDoubleData | |
| FindVolumeRender::findDoubleData | |
| FindObjectsWithTimeInput | An Iterator that is finds a VISH object that implements a value of type VTime |
| FindSeedpoint | |
| FindVolumeRender | |
| Eagle::FixedArray | A FixedArray is a simple copy-by-value array providing random access to its elements |
| Eagle::FixedArrayFlattener< FixedArray< FixedArray< T, M >, N > > | |
| Eagle::FixedArrayFlattener< FixedArray< T, N > > | |
| Eagle::FixedArrayType | |
| Eagle::FixedArrayType< ElementType, 1 > | |
| Wizt::FlagList | A set of strings associated with a boolean, good to store true/false properties for each string |
| FlexLexer | |
| FloatsToPoint2D | |
| FloatsToTVector | |
| FTLGLFontManager::Font | |
| Wizt::GLFontManager::Font | |
| CollectedData::Frag | |
| Wizt::FragmentShader | An OpenGL fragment shader |
| Wizt::Framebuffer | Class interface to the OpenGL Framebuffer API |
| Wizt::RemoteViewer::FrameData | |
| std::fstream | STL class |
| FTGLFontCreator | |
| FTLGLFontManager | |
| MemCore::FunctionStackProfiler | |
| MemCore::Functor | An abstract base class for scalar functions on double values |
| Wizt::TransformOperator::Functor | |
| Wizt::VScalarFunctor::Functor | |
| GaussField | |
| Eagle::GaussSolver | |
| Eagle::GE | |
| Wizt::GLTexture3D::Generator | |
| PNGMovie::GenMovie | Callback functor when an action is invoked |
| Wizt::VRenderContext::Geometry | |
| Wizt::GeometryShader | An OpenGL geometry shader |
| Wizt::GetMessage::GetBody | |
| GetInput::GetData | |
| Eagle::GetFixedArrayType | A template metaprogram class to compute the an fixed array type of an homogeneous type |
| GetInput | |
| Wizt::GetMessage | |
| Wizt::Slottify::GetObjectInfo | Callback object for parsing object slot information |
| Wizt::GimpIcon | A map of ref pointers to input objects |
| Wizt::GLCache | The GLCache is a mapping from certain keys to an OpenGL DisplayList object |
| Wizt::GLCacheCreator | |
| Wizt::GLCacheError | |
| Wizt::GLCacheFactory | The 3rd level of the OpenGL Cache, retrieving actual GL objects such as VBO's or TextureCreators |
| Wizt::GLCacheFactoryPtr | A convenience class which is basically a reference to a GLCacheFactory and forwards all its member properties to this pointer |
| Wizt::GLCacheInterfaceNotFound | Exception that is thrown if the type is not found on GLCache access |
| Wizt::GLColormap | A colormap can be used in two ways: as 1D texture, or as colortable |
| Wizt::GLContextChecker | This is a convenience class to check if an OpenGL context is currently active and available |
| Wizt::GLError | Exception class for errors during rendering |
| Wizt::GlewContext | |
| glfont::GLFont | |
| glfont::GLFont::GLFontChar | |
| Wizt::GLFontManager | |
| Wizt::GLFontManagerCreator | |
| glFormat< 1 > | |
| glFormat< 2 > | |
| glFormat< 3 > | |
| glFormat< 4 > | |
| GLGrid | A simple example demonstrating how to draw a Grid using the OpenGL glMap functions |
| Wizt::GLImageTileProcessor | An interceptor class for rendering, allows to process pixels before they are saved to disk |
| glMemSize< 0 > | |
| glMemSize< 1 > | |
| glMemSize< 2 > | |
| glMemSize< 3 > | |
| glMemSize< 4 > | |
| glMemSize< GL_ALPHA > | |
| glMemSize< GL_ALPHA12 > | |
| glMemSize< GL_ALPHA16 > | |
| glMemSize< GL_ALPHA16F_ARB > | |
| glMemSize< GL_ALPHA32F_ARB > | |
| glMemSize< GL_ALPHA4 > | |
| glMemSize< GL_ALPHA8 > | |
| glMemSize< GL_BGRA > | |
| glMemSize< GL_COMPRESSED_ALPHA > | |
| glMemSize< GL_COMPRESSED_INTENSITY > | |
| glMemSize< GL_COMPRESSED_LUMINANCE > | |
| glMemSize< GL_COMPRESSED_LUMINANCE_ALPHA > | |
| glMemSize< GL_COMPRESSED_RGB > | |
| glMemSize< GL_COMPRESSED_RGBA > | |
| glMemSize< GL_INTENSITY > | |
| glMemSize< GL_INTENSITY12 > | |
| glMemSize< GL_INTENSITY16 > | |
| glMemSize< GL_INTENSITY16F_ARB > | |
| glMemSize< GL_INTENSITY32F_ARB > | |
| glMemSize< GL_INTENSITY4 > | |
| glMemSize< GL_INTENSITY8 > | |
| glMemSize< GL_LUMINANCE > | |
| glMemSize< GL_LUMINANCE12 > | |
| glMemSize< GL_LUMINANCE12_ALPHA12 > | |
| glMemSize< GL_LUMINANCE12_ALPHA4 > | |
| glMemSize< GL_LUMINANCE16 > | |
| glMemSize< GL_LUMINANCE16_ALPHA16 > | |
| glMemSize< GL_LUMINANCE16F_ARB > | |
| glMemSize< GL_LUMINANCE32F_ARB > | |
| glMemSize< GL_LUMINANCE4 > | |
| glMemSize< GL_LUMINANCE4_ALPHA4 > | |
| glMemSize< GL_LUMINANCE6_ALPHA2 > | |
| glMemSize< GL_LUMINANCE8 > | |
| glMemSize< GL_LUMINANCE8_ALPHA8 > | |
| glMemSize< GL_LUMINANCE_ALPHA > | |
| glMemSize< GL_LUMINANCE_ALPHA16F_ARB > | |
| glMemSize< GL_LUMINANCE_ALPHA32F_ARB > | |
| glMemSize< GL_R3_G3_B2 > | |
| glMemSize< GL_RGB > | |
| glMemSize< GL_RGB10 > | |
| glMemSize< GL_RGB10_A2 > | |
| glMemSize< GL_RGB12 > | |
| glMemSize< GL_RGB16 > | |
| glMemSize< GL_RGB16F > | |
| glMemSize< GL_RGB32F > | |
| glMemSize< GL_RGB4 > | |
| glMemSize< GL_RGB5 > | |
| glMemSize< GL_RGB5_A1 > | |
| glMemSize< GL_RGB8 > | |
| glMemSize< GL_RGBA > | |
| glMemSize< GL_RGBA12 > | |
| glMemSize< GL_RGBA16 > | |
| glMemSize< GL_RGBA16F > | |
| glMemSize< GL_RGBA2 > | |
| glMemSize< GL_RGBA32F > | |
| glMemSize< GL_RGBA4 > | |
| glMemSize< GL_RGBA8 > | |
| Wizt::GlossyLines | A helper class to draw lines with a shiny, glossy texture |
| Wizt::GlossyTexture | A one-dimensional texture that simulates a glossy shade |
| Wizt::GLProgram | An OpenGL shading program |
| Wizt::GLRenderAble | Abstract base class for objects that can be rendered via OpenGL |
| Wizt::GLRenderer | A renderer class that captures OpenGL renderings from a viewer object into some offline buffer, using FrameBuffer objects with multisampling |
| Wizt::GLShaderUniformFunctor | A functor class for applying operators to uniform shader variables that are assigned directly from a Vish slot |
| Wizt::GLState | |
| Wizt::GLTexture | |
| Wizt::GLTexture1D | Shortcut class name for one-dimensional textures |
| Wizt::GLTexture2D | Shortcut class name for two-dimensional textures |
| Wizt::GLTexture3D | Shortcut class name for three-dimensional textures |
| Wizt::GLTextureTarget< 1 > | |
| Wizt::GLTextureTarget< 2 > | |
| Wizt::GLTextureTarget< 3 > | |
| glType< Eagle::bivector3 > | |
| glType< Eagle::Column< N, T > > | |
| glType< Eagle::FixedArray< T, N > > | |
| glType< Eagle::point3 > | |
| glType< Eagle::tvector3 > | |
| glType< Eagle::Vector< T, N > > | |
| glType< GLdouble > | |
| glType< GLfloat > | |
| glType< GLint > | |
| glType< GLshort > | |
| glType< GLuint > | |
| glType< GLushort > | |
| glType< Imf::Rgba > | |
| glType< signed char > | |
| glType< T[N]> | |
| glType< unsigned char > | |
| Wizt::GLViewer | Base class for Viewers that allow rendering via OpenGL |
| Wizt::VFrameBuffer::Grab | Callback class for grabbing frames |
| Eagle::GT | |
| Wizt::GlewContext::Handle | |
| HTTP::Header | |
| ComputeGridStreamLines::HexaHedralCellNewton | |
| ComputeMultiStreamLines::HexaHedralCellNewton | |
| ComputeGridStreamLines::HexaHedralCellXYTracing | |
| ComputeMultiStreamLines::HexaHedralCellXYTracing | |
| HMS | |
| Wizt::VRequest::ID | An identification object to trace identity of requests |
| Wizt::VCreatorBase::IdentifierIterator | |
| Wizt::IdentifierWithUrl | |
| std::ifstream | STL class |
| Image | Read_jpeg_file Reads from a jpeg file on disk specified by filename and saves into the raw_image buffer in an uncompressed format |
| Wizt::ImageTile | A tile as part of an image |
| Wizt::VFrameBuffer::ImageTileProcessor | Interface class for processing color data acquired by rendering |
| importer | |
| Wizt::VRequest::Incomplete | Exception class indicating that some request could not be completed |
| Wizt::BufferArray::Inconsistency | Exception class thrown when an array of incompatible number of elements is going to be added to a given VBO object |
| MemCore::Counter::Incrementer | Exception-safe incrementing/decrementing of a counter |
| Wizt::VLogger::Indent | 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 |
| Wizt::IndexBuffer | OpenGL Index Buffers for specific data types |
| Wizt::IndexBufferObject | Base class for index buffer objects |
| MemCore::Profiler::Info | Source code information |
| Wizt::info | Input type to display some information about an object |
| Vish::Input | An input slot for Vish Objects, bound to a specific type |
| IntegerInput | |
| Wizt::VInteractionEvent::InteractionGrabber | The interaction grabber property of a VInteractionEvent contains a list of objects that are allowed to retrieve these events |
| InteractionInput | |
| MemCore::Intercube | A container that holds many Interfaces |
| MemCore::IntercubeIterator | Iterator object for an Intercube |
| MemCore::Interface | Interface template |
| MemCore::interface_cast | Interface cast: Given an Intercube, retrive the an interface object which is stored there |
| MemCore::InterfaceBase | Base class for Interfaces |
| MemCore::InterfaceIterationParameter | |
| MemCore::Intercube::interfacemap | |
| MemCore::InterfacePtr | |
| Eagle::Interpol | Interpolation of certain values |
| InterpolationFunction | Compute Gauss Filtered Field from Field |
| Interval | |
| Eagle::Interpol::Interval | |
| std::invalid_argument | STL class |
| Eagle::InversionOperation | |
| std::ios | STL class |
| std::ios_base | STL class |
| std::istream | STL class |
| std::istringstream | STL class |
| ComputeGridStreamLines::It | |
| ComputeMultiStreamLines::It | |
| Eagle::Context::Iterator | Iterator functor that allows to travers over all variables of a specific type |
| MemCore::Lexicon::Iterator | |
| MemCore::SaveRegistryBase::Iterator | Iterator class to find all saver creators for a given object domain |
| MemCore::Profiler::Iterator | |
| MemCore::typemap::Iterator | Abstract Iterator base class for typemaps |
| Eagle::ViewPoints::iterator | |
| orgQhull::Coordinates::iterator | |
| orgQhull::QhullLinkedList::iterator | |
| orgQhull::QhullPoints::iterator | |
| orgQhull::QhullPointSet::iterator | |
| Wizt::ValuePool::iterator | An iterator to traverse the existing value pools |
| Wizt::VCreationPreferences::Iterator | Iterator class |
| Wizt::VCreatorCategory::Iterator | Iterator base class for the VCreatorCategory::iterate() function |
| std::basic_string::iterator | STL iterator class |
| std::string::iterator | STL iterator class |
| std::wstring::iterator | STL iterator class |
| std::deque::iterator | STL iterator class |
| std::list::iterator | STL iterator class |
| std::map::iterator | STL iterator class |
| std::multimap::iterator | STL iterator class |
| std::set::iterator | STL iterator class |
| std::multiset::iterator | STL iterator class |
| Wizt::VScriptValue::iterator | |
| std::vector::iterator | STL iterator class |
| Wizt::VScriptParameters::iterator | |
| Wizt::VScriptable::iterator | Local iterator to allow traversal of all functors |
| Wizt::VValue< VThreadManager >::Iterator | |
| Wizt::ValueMap::iterator | Functor base class for iteration over the components |
| Wizt::VValue< VSocketAction >::iterator | Abstract Iterator callback object |
| MemCore::CacheQueue::Iterator | Iterator class |
| Wizt::VGLRenderContext::Jitter | A structure to define a little offset from the main camera settings |
| JPEG_ERROR | |
| Wizt::KBuffer | Abstract class implementing a K-Buffer |
| Eagle::KDInterface | |
| Eagle::KDTree | A multidimensional KDTree data structure rewritten from c-code by John Tsiombikas (http://code.google.com/p/kdtree/) |
| Eagle::KDTreeCallBackFunctor | |
| Eagle::KDTreeResult< std::list< T > > | |
| Eagle::KDTreeResult< std::map< double, T > > | |
| Eagle::KDTreeResult< std::multimap< double, T > > | |
| Eagle::KDTreeResult< std::vector< T > > | |
| PosixThreads::Thread::Key | |
| Wizt::TypeSpecificGLCacheFactory::KeyMap | |
| Wizt::GLCacheFactory::KeyMap | |
| Wizt::KeyStringNotFound | |
| Eagle::KeyValue | Entry in interpolation table with some flags |
| KnottedTorus | |
| KnottedTorus::KnottedTorusState | |
| LaserRecord | |
| MemCore::LastKnownSourceCodeLineEntry | |
| Wizt::VFrameBuffer::Grab::Layer | |
| MemCore::LoaderBase::ldrpar | Abstract internal helper class |
| MemCore::Loader::ldrpar | An internal helper class, used for type-specific reduction, holds a ref ptr to the actual object to be modified during the load process |
| Eagle::LE | |
| Eagle::LeibnitzRule | Implements the Leibnitz rule for derivatives for binary operators o: [A o B ],x = [A,x o B + [A o B,x] |
| std::length_error | STL class |
| Wizt::lessValueSetPtr | 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 |
| MemCore::Lexicon | An incomplete development class for associating objects with strings, using lexical lookup and easy extraction of chapters |
| Ligo | |
| LineEmitter | |
| LineEmitterRenderer | |
| LineRenderer | |
| IntegralLines::LinesPoints | |
| Wizt::GLProgram::LinkerError | Exception that happens when there was a problem with linking compiled shader programs |
| Wizt::ValueNotifierList::List | |
| std::list | STL class |
| Wizt::ListID::List | |
| Wizt::ListID | |
| MemCore::Loader | Abstract base class for object loaders, which are used by the LoaderRegistry |
| MemCore::LoaderBase | Base class for Loaders |
| MemCore::LoaderMap | |
| MemCore::LoaderParameters | Parameters for the loading process |
| MemCore::LoaderProgress | A base class for callbacks during the load process |
| MemCore::LoaderRegistry | Database for routines that may create objects of type X |
| MemCore::LoaderRegistryBase | |
| MemCore::LoaderRequest | Control structure that describes a network connection to a certain URL |
| LocalDataThingy | |
| LocalLens | |
| Eagle::LocationComponent | Extracts a component of a location |
| MemCore::lock | An exeption safe way for locking and unlocking an mutex |
| Wizt::VStreamLogger::Logger | |
| std::logic_error | STL class |
| Eagle::LowerTriangular | A symmetric matrix stored in lower triangular form |
| Eagle::LT | |
| std::map | STL class |
| Wizt::VScriptValue::Map | |
| Wizt::VScriptParameters::Map | |
| Wizt::VScriptable::Map | |
| Wizt::BufferArray::MapMemory | API For glMapBuffer |
| Matrix | |
| Eagle::Matrix | Simple matrix class for performing fast operations on matrices of sizes known at compile-time |
| Wizt::RequestExecutor::MaxRequestExecutor | |
| MemberID | |
| MemCore::MemoryException | |
| MemCore::MemVector | A convenience class that looks like a std::vector<>, but is actually referring to a reference-counted common chunk of data |
| Wizt::MessageRetriever | |
| Wizt::MetaGLViewerCreator | Implementation of a viewer creator using an existing viewer class that can be called with a ViewerCreatorEnvironment as parameter |
| Wizt::MetaGLViewerCreatorBase | Abstract plankton class for objects creating OpenGL-enabled viewer windows |
| Wizt::VFrameBuffer::MetaInfo | Meta information available per frame |
| Eagle::MetaInfo | |
| Eagle::MetaInfo< bivector3 > | |
| Eagle::MetaInfo< Christoffel< N, Scalar_t > > | |
| Eagle::MetaInfo< Column< N, Scalar_t > > | |
| Eagle::MetaInfo< Coordinates< Cartesian3D, double >::bivector > | |
| Eagle::MetaInfo< Coordinates< Cartesian3D, double >::point > | |
| Eagle::MetaInfo< Coordinates< Cartesian3D, double >::vector > | |
| Eagle::MetaInfo< FixedArray< T, N > > | Implement the meta-information on fixed arrays |
| Eagle::MetaInfo< LowerTriangular< N, Scalar_t > > | |
| Eagle::MetaInfo< Matrix< R, C, Value > > | |
| Eagle::MetaInfo< metric33 > | |
| Eagle::MetaInfo< point3 > | |
| Eagle::MetaInfo< point3f > | |
| Eagle::MetaInfo< rgb_t > | |
| Eagle::MetaInfo< Row< N, Scalar_t > > | |
| Eagle::MetaInfo< trivector3 > | |
| Eagle::MetaInfo< tvector3 > | |
| Eagle::MetaInfo< vector3f > | |
| Eagle::MetaInfo< Vector< T, N > > | |
| Eagle::MetaInfo< void > | |
| Eagle::MetaInfoElementIndex | For multidimensional types T of rank MetaInfo<T>::RANK, this class provides a mapping from index space to memory space |
| Eagle::MetaInfoElementIndex< Christoffel< N, Scalar_t > > | |
| Eagle::MetaInfoElementIndex< LowerTriangular< N, Scalar_t > > | |
| Eagle::MetaInfoElementIndex< Matrix< R, C, Value > > | |
| Eagle::MetaInfoIO | |
| Eagle::MetaInfoIO< MetaInfo< T > > | |
| Eagle::MetaInfoNonTensor | |
| Eagle::MetaInfoNonTensor< Christoffel< N, Scalar_t > > | |
| Wizt::MetaViewer | Base class for object handling one or more viewers, i.e |
| Wizt::MetaViewerCreatorBase | Abstract plankton class for objects creating viewer windows |
| Wizt::MetaViewerCreatorEnvironment | Abstract class describing the environment when creating viewer windows |
| Eagle::Coordinates::Metric | |
| MFace | |
| MMesh | |
| MNormal | |
| ModuleInfo | |
| Wizt::VManagedObject::ModuleIterator | Abstract iterator class |
| ModuleRegistry_t | |
| Wizt::MovieRecorder | Base class for Movie recorder classes |
| PNGMovie::MovieState | |
| MUCoord | |
| std::multimap | STL class |
| MultiplyInt | |
| std::multiset | STL class |
| Eagle::MultiVector | |
| Eagle::PhysicalSpace::MultiVector | A full multivector in 3D consists of  components |
| orgQhull::MutableCoordinatesIterator | |
| MemCore::mutex | Portable intra-process mutex class for locking threads |
| PosixThreads::Mutex | |
| MVertex | |
| Wizt::RemoteVish::MyActionNotifier | |
| MyAnemoneInitializer | |
| MyContext | |
| MyFunctor | |
| MyOnDemandDataCreator | |
| MyPreciousDataClass | |
| CollectedData::mySortClass | |
| ComputeGridStreamLines::MyState | |
| ComputeMultiStreamLines::MyState | |
| ComputeStreamLines::MyState | |
| ComputeStreamSurfaces::MyState | |
| LineEmitter::MyState | |
| LineEmitterRenderer::MyState | |
| LineRenderer::MyState | |
| RenderExample::MyState | |
| ProtIntersect::MyState | |
| Wizt::VStateCreator::MyState | |
| MyTentacle | |
| Wizt::myVStreamCreator | |
| Wizt::NamedIdentifiers | A set of named identifiers |
| NetworkObjectHtml | Display existing objects and their inputs |
| Eagle::Node | Abstract base class for evaluation of arbitrary functions that have been parsed from some input |
| Eagle::KDTree::Node | |
| Wizt::GLProgram::NoSuchAttribute | Exception thrown when a vertex attribute was not found |
| Wizt::GLProgram::NoSuchUniform | Exception thrown when a uniform variable was not found |
| Eagle::NotElementOfFunctor | |
| Wizt::NotifiedValueIterator | |
| MemCore::NotNullPtr | A type to specify non-null pointer requirements |
| Wizt::GLProgram::NotSupportedCall | Exception class if a GL call is not supported |
| MemCore::NullPtr | A type indicating an invalid pointer, similar to the NULL pointer in C, but type-safe |
| Object | |
| NetworkObjectHtml::ObjectInput | |
| VWebControl::ObjectIterator | |
| VishControl::ObjectIterator | |
| VWebControl::ObjectList | |
| Wizt::ObjectQuality | Classification for the quality of objects that may be provided by some Creator |
| Wizt::ObjectSelection | A general-purpose class to select a set of Vish objects and order them by priority |
| Wizt::Slottify::ObjectsWithSlots | A set of lines with object name prefixed |
| VWebControl::ObjectValues | |
| VishControl::ObjectValues | |
| Eagle::PhysicalSpace::OddMultiVector | The combination of a vector and a trivector yields an odd multivector, which is dual to a rotor |
| std::ofstream | STL class |
| MemCore::OmegaPtr | The Omega pointer - forcibly makes an end to objects |
| OnDemandCreator | |
| Eagle::OneNode | A scalar node that always returns one |
| Eagle::Operator<'&'> | |
| Eagle::Operator<'*','~'> | Multiply with transpose |
| Eagle::Operator<'*'> | |
| Eagle::Operator<'+','='> | |
| Eagle::Operator<'+'> | |
| Eagle::Operator<'-'> | |
| Eagle::Operator<'/'> | |
| Eagle::Operator<'='> | |
| Eagle::Operator<'~'> | Transpose |
| Eagle::OperatorBase | |
| Wizt::Options | Input type for a list of flags |
| std::ostream | STL class |
| std::ostringstream | STL class |
| std::out_of_range | STL class |
| Wizt::VFrameBuffer::OutputFormat | |
| Wizt::VFrameBuffer::OutputFormatProvider | |
| Wizt::VObject::OutputObjectIterator | Iterator callback object for searching and finding output objects |
| std::overflow_error | STL class |
| Wizt::RenderBasin::Painter | Base class for paint operations |
| VWebControl::ParameterIterator | |
| VishControl::ParameterIterator | |
| Wizt::GlossyTexture::Parameters | A bunch of parameters that allow control of the gloss |
| Eagle::ParserContext | Internal class for communicating with the Bison/Yacc Parser and Flexical Stanza Generator |
| VWebControl::ParValues | |
| VishControl::ParValues | |
| ComputeGridStreamLines::PerBlockInfo | |
| ComputeMultiStreamLines::PerBlockInfo | |
| PerformaLoader | |
| PerformaSceneRenderer | |
| PerformaViewerCreator | |
| PfWidget::PfDrawCallback | |
| PfViewer | A viewer implementation that uses SGI Performer for rendering |
| PfWidget | PfWidget class |
| Wizt::Pickable | Base class for VObjects that may be pickable via OpenGL rendering |
| Wizt::VRenderContext::PickId | Information about the currently picked object |
| Wizt::VRenderContext::PixelZoom | |
| PlaneTest | |
| PNGMovie | Create a sequence of OpenPNG files |
| PNGRetrieveImageSizedFrame | |
| Eagle::Coordinates::point | |
| Eagle::PhysicalSpace::point | A point in physical 3D space |
| Eagle::PolarSpace::point | |
| Eagle::STA::CartesianChart4D::point | |
| orgQhull::PointCoordinates | |
| orgQhull::PointCoordinatesIterator | |
| Port | |
| CameraNavigator::AccelState::pos | |
| MemCore::PreDestructionTrait | Trait class that allows to execute some action on an object when it is going to be deleted |
| MemCore::PreDestructionTrait< Cacheable > | |
| orgQhull::QhullFacet::PrintCenter | |
| Wizt::PrintCreatorIterator | |
| orgQhull::QhullFacet::PrintFacet | |
| orgQhull::QhullFacetList::PrintFacetList | Operator==() does not depend on isGood() |
| orgQhull::QhullFacetList::PrintFacets | |
| orgQhull::QhullFacetSet::PrintFacetSet | Operator==() does not depend on isGood() |
| orgQhull::QhullFacet::PrintFlags | |
| orgQhull::QhullFacet::PrintHeader | |
| orgQhull::QhullHyperplane::PrintHyperplane | |
| orgQhull::QhullFacetSet::PrintIdentifiers | |
| orgQhull::QhullPointSet::PrintIdentifiers | |
| orgQhull::QhullVertexSet::PrintIdentifiers | |
| Wizt::PrintIterator | |
| orgQhull::QhullPoint::PrintPoint | |
| orgQhull::QhullPoints::PrintPoints | |
| orgQhull::QhullPointSet::PrintPointSet | |
| orgQhull::QhullRidge::PrintRidge | |
| orgQhull::QhullFacet::PrintRidges | |
| orgQhull::QhullVertex::PrintVertex | |
| orgQhull::QhullVertexSet::PrintVertexSet | |
| orgQhull::QhullFacetList::PrintVertices | |
| std::priority_queue | STL class |
| MemCore::Profiler | Profiling Support |
| Wizt::RenderBasin::Program | Base class for abstract shader/render programs |
| Wizt::Programmable | A helper class to create a shader program from either intrinsic code, or external files, as given under the specified name in Programmable::CompileShader() |
| Wizt::ProgrammableGeometry | A helper class to create a OpenGL geometry shader programs |
| Wizt::VActionNotifier::Progress | Helper class for following the progress of some slow activity |
| Wizt::Renderbuffer::Properties | Properties of a Renderbuffer object |
| ProtIntersect | |
| Eagle::Coordinates::pseudoscalar | |
| MemCore::PtrMap_t | |
| orgQhull::Qhull | |
| orgQhull::QhullError | |
| orgQhull::QhullFacet | A QhullFacet is the C++ equivalent to Qhull's facetT* |
| orgQhull::QhullFacetList | |
| orgQhull::QhullFacetSet | |
| orgQhull::QhullHyperplane | |
| orgQhull::QhullLinkedList | QhullLinkedList<T> -- A linked list modeled on QLinkedList. T is an opaque type with T(B *b), b=t.getBaseT(), t=t.next(), and t=t.prev(). The end node is a sentinel. libqhull owns the contents. QhullLinkedList does not define erase(), clear(), removeFirst(), removeLast(), pop_back(), pop_front(), fromStdList() Derived from Qt/core/tools/qlinkedlist.h and libqhull.h/FORALLfacets_() QhullLinkedList<T>::const_iterator -- STL-style iterator QhullLinkedList<T>::iterator -- STL-style iterator QhullLinkedListIterator<T> -- Java-style iterator Derived from Qt/core/tools/qiterator.h Works with Qt's foreach keyword [Qt/src/corelib/global/qglobal.h] |
| orgQhull::QhullLinkedListIterator | |
| orgQhull::QhullPoint | |
| orgQhull::QhullPoints | |
| orgQhull::QhullPointSet | |
| orgQhull::QhullPointSetIterator | |
| orgQhull::QhullPointsIterator | |
| orgQhull::QhullQh | |
| orgQhull::QhullRidge | |
| orgQhull::QhullSet | Set of pointers to baseT, T.getBaseT() |
| orgQhull::QhullSetBase | Base class for QhullSet<T> QhullSet<T> -- A read-only wrapper to Qhull's collection class, setT. QhullSet is similar to STL's <vector> and Qt's QVector. QhullSet is unrelated to STL and Qt's set and map types (e.g., QSet and QMap) For STL efficiency, QhullSet caches endPointer() T must be a pointer type A QhullSet does not own its contents -- erase(), clear(), removeFirst(), removeLast(), pop_back(), pop_front(), fromStdList() not defined Qhull's FOREACHelement_() [qset.h] is more efficient than QhullSet. It uses a NULL terminator instead of an end pointer. STL requires an end pointer. Derived from QhullLinkedList.h and Qt/core/tools/qvector.h |
| orgQhull::QhullSetIterator | |
| orgQhull::QhullStat | |
| orgQhull::QhullVertex | |
| orgQhull::QhullVertexSet | |
| Wizt::QScrollStringList | A QT widget that displays a list as well as a search input |
| Wizt::QStringInput | A QT widget that displays a list as well as a search input |
| Wizt::QTextLabel | A QT widget that displays information |
| Eagle::Quadratic | 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 |
| Spheres::Quadric | |
| Eagle::Interpol::QuarticInterval | |
| Eagle::PhysicalSpace::quaternion | |
| std::queue | STL class |
| RampTexture | |
| Wizt::Range | A range of double values, to be used to map certain values from one range to another |
| std::range_error | STL class |
| RangedFloat | Just construct a range from a min and max value |
| MemCore::RangeException | Exception class for range violations |
| RangeHUD | |
| orgQhull::RboxPoints | |
| TangentialDifferentialEquationLinear::RealArray_t | |
| TangentialDifferentialEquationCubic::RealArray_t | |
| Wizt::VContext::RealTime | |
| Wizt::VSocketAction::Receiver | Functor object for callbacks when data are received on a socket |
| MemCore::Ref | Pointer to a refcountable object which automatically initializes the pointer with constructing an object |
| MemCore::ReferenceBase | Base class for objects which do reference counting |
| MemCore::ReferenceCount | Base class for thread-safe reference counting |
| MemCore::Referer | Internal class for indirectly referencing objects, even dead ones |
| MemCore::RefPtrTypeTrait | Default type trait for the RefPtr pointer -> operator |
| Wizt::RemoteViewer | |
| Wizt::RemoteVish | |
| Wizt::GlossyTexture::Render | An exception-safe way to call the beginRender() and endRender() routines of the GlossyTexture |
| Wizt::RenderAble | Abstract base class for objects that can be rendered |
| Wizt::RenderBasin | Base class for abstract render operations |
| Wizt::Renderbuffer | Encapsulation of the OpenGL Renderbuffer API |
| Wizt::VBO::Renderer | The rendering operation is formulated via a Renderer object that is supposed to implement OpenGL calls |
| Wizt::VFrameBuffer::Renderer | Base class for a renderer that is able to provide some pixel data |
| RenderExample | |
| Wizt::RenderException | Exception class for errors during rendering |
| Wizt::RenderBasin::RenderFlag | Base class for render flags |
| Wizt::VRenderContext::RenderObjectNotifier | |
| Wizt::RenderBasin::RenderParameter | Base class for render parameters |
| HTTP::Request | 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 |
| Wizt::RequestExecutor | |
| MemCore::CreatorBase::Result | |
| MemCore::Result | |
| std::basic_string::reverse_iterator | STL iterator class |
| std::string::reverse_iterator | STL iterator class |
| std::wstring::reverse_iterator | STL iterator class |
| std::list::reverse_iterator | STL iterator class |
| std::map::reverse_iterator | STL iterator class |
| std::multimap::reverse_iterator | STL iterator class |
| std::set::reverse_iterator | STL iterator class |
| std::multiset::reverse_iterator | STL iterator class |
| std::vector::reverse_iterator | STL iterator class |
| std::deque::reverse_iterator | STL iterator class |
| RingIndex | |
| orgQhull::RoadError | |
| orgQhull::RoadLogEvent | |
| Eagle::PhysicalSpace::rotor | A rotor is the sum of scalar with a bivector |
| Eagle::Row | A row vector, |
| RowVector | |
| std::runtime_error | STL class |
| RXPDataCollector | |
| Rybber | |
| SAHooks | |
| MemCore::SaveInterfaceCreator | Abstract base class for objects that may equip a certain class object X with an interface to write this structure into a file |
| MemCore::SaveInterfaceCreatorBase | |
| Wizt::VSaveable::SaveIterator | Accompanying iterator class |
| MemCore::SaveParameters | |
| MemCore::SaveRegistry | Database for routines saving a certain class to disk |
| MemCore::SaveRegistryBase | |
| Eagle::Coordinates::scalar | |
| Eagle::ScalarCube | Compute  |
| Eagle::ScalarPlusBivector | A node operator implementing creation of rotor from scalar and bivector |
| Eagle::ScalarSquare | |
| Eagle::ScalarTimesVector | A node implementing scalar times vector multiplication |
| Wizt::Seagrass | The Anemone Cache, called the Seagrass, is based on Anemone objects |
| Wizt::SecondaryColorArray | OpenGl buffer array base class to provide secondary colors |
| MemCore::SelfInitialize | Internal class used as an argument for a computational destructor |
| std::set | STL class |
| Wizt::Shader | Base class for OpenGL shaders |
| ShadowGround | |
| shape_tree_node | |
| SHPInfo | |
| SHPObject | |
| SHPTree | |
| MemCore::simplestring | |
| Wizt::VRenderContext::Size | |
| Wizt::ImageTile::Size | Local size class, used for tiles |
| Wizt::Slottify::SlotCollection | A set of lines with only slot information, but no containing objects |
| Wizt::TypedSlot::SlotCreator | The associated Slot Creator |
| Wizt::Slottify::SlotInfo | Information describing a specific Slot |
| Wizt::Slottify | Utility class for dealing with conversions from VObject and its Slots to strings and vice versa |
| MemCore::SocketError | Exception class for socket failures |
| Wizt::VValue< VSocketAction >::SocketReceivers_t | |
| SoSurfaceHeightfieldTEST | Inventor node to display something |
| MemCore::SpeakPtr | |
| Wizt::Anemone::SpecializedTentacle | Base class for Tentacles that are specialized for a specific purpose |
| Sphere | |
| Spheres::Sphere | |
| Spheres | |
| Eagle::Spherical3D | |
| Eagle::STA::SphericalChart4D | |
| std::stack | STL class |
| MemCore::StackTrace | |
| Star | |
| StarLoader | |
| Wizt::VLogger::State | Describes a thread-local state of the logging process |
| Wizt::VStateCreatorBase::State | A class for storing context-dependent information |
| Wizt::VStateCreatorBase::StateMap | |
| Wizt::StatusIndicator | Base class for convenient messing around with the status to be displayed for a certain object |
| MemCore::StreamSaver | |
| MemCore::StreamSaverInterface | |
| std::string | STL class |
| MemCore::StringList | A list of strings |
| Wizt::StringSelection | A list of strings with one of them selected |
| std::stringstream | STL class |
| StripeBuffer | |
| Stripes | |
| MemCore::StrongPtr | A reference counting pointer class which keeps objects alive as long as strong pointers to these objects exist |
| Eagle::FixedArray::subarray | Helper class for retrieve a subset of the current array |
| Eagle::SubMatrix | SubMatrix is a Matrix with row R and column C deleted |
| Eagle::SubQuadratic | |
| Eagle::Vector::subvector | Access part of the vector as a vector of smaller size |
| Eagle::SumDerivation | Implements the derivation of a sum [A + B ],x = A,x + B,x |
| orgQhull::SumOf | Sum of the elements in a container |
| orgQhull::SumSquaresOf | Sum of squares of the elements in a container |
| tagBITMAPINFOHEADER | |
| TangentialDifferentialEquationCubic | |
| TangentialDifferentialEquationLinear | |
| TangVish | The VISH object that implements a server that listens on commands from a socket |
| TangVizTimeInput | The VISH class representing an INPUT instance for values of type "VTime" |
| TARGAHEADERFILE | |
| TargaLoader | |
| Wizt::Task | |
| Eagle::Tensor3 | |
| Wizt::Anemone::Tentacle | Base class for components that need to be attached to an Anemone to make it visible |
| Eagle::TernaryOperatorNode | Template node class to perform ternary operations on evaluate-able nodes |
| TestBox | |
| Wizt::TexCoordArray | Base class to store buffer arrays for texture coordinates |
| Wizt::TEXTURE | |
| Wizt::TextureBase | Base class for OpenGL Texture ID's |
| Wizt::TextureCreator | A handler for texture creation and release |
| Wizt::TextureID | |
| Wizt::RenderBasin::TextureStorageFormat | Enum for the storage type of the texture, which will affect memory utilization on the GPU |
| Wizt::RenderBasin::TextureTentacle | Base class for textures, child classes are implemented by Renderers |
| TGA | |
| PosixThreads::Thread | |
| Tick | |
| Wizt::TimeDependent | 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 |
| Wizt::VContext::TimeInterface | |
| MemCore::Timer | A class to hide system dependent methods to count seconds |
| Eagle::Torsion | Torsion Tensor |
| Wizt::Touchable | Abstract base class for objects that can be touched |
| Wizt::TouchList | Abstract base class for objects that can be touched |
| Wizt::TransformOperator::Transform | An exception-safe way to invoke the transformation functor |
| Wizt::TransformOperator | Implements an operation that affects a 3D rendering, in whatever way |
| Eagle::TransposeOperation | |
| Eagle::LowerTriangular::TriangularIndex | |
| Eagle::PhysicalSpace::trivector | A Tri-Vector, or oriented volume in 3D space |
| Eagle::STA::CartesianChart4D::trivector | A Tri-Vector, or oriented volume in 4D space |
| Wizt::VStream::TryAgain | |
| Wizt::VStream::TryAgainOnWrite | |
| Wizt::TypedBufferArray | |
| MemCore::TypedChunk | Class of chunks of a specific type, recursively derived from chunks on base classes of the given type |
| MemCore::TypedChunkBase | The abstract base class for chunks that have a certain type |
| Wizt::TypedColorArray | OpenGl buffer array to provide colors |
| Eagle::TypedNode | Base class for evaluation of expressions yielding a specific type, as parsed from some text |
| Wizt::TypedNormalArray | Note: stuff has always 3 components |
| Wizt::TypedSecondaryColorArray | OpenGl buffer array to provide secondary colors |
| Wizt::TypedSlot | An input slot for VObjects, bound to a specific type |
| Wizt::TypedSlotCreator | A registry for the runtime-creation of typed slots, allowing creation of type-specific VObject input parameters without knowing their types explicitly |
| Wizt::TypedTexCoordArray | An OpenGL buffer array to store texture coordinates |
| Wizt::TypedValueCreator | Implementation of value creators |
| Wizt::TypedVertexArray | Base class for OpenGL buffer array objects operating on vertices (points), independent from a specific type |
| Wizt::TypedVertexAttribArray | OpenGL buffer array for arbitrary vertex attributes |
| Eagle::TypeIndexingScheme | |
| Eagle::TypeIndexingScheme< bivector3 > | |
| Eagle::TypeIndexingScheme< metric33 > | |
| Eagle::TypeIndexingScheme< trivector3 > | |
| Eagle::TypeIndexingScheme< tvector3 > | |
| Eagle::TypeIndexingScheme< vector3f > | |
| Eagle::TypeIndexingScheme< Vector< T, N > > | |
| MemCore::TypeInfo | Helper class for mapping C++ data types to objects |
| MemCore::typemap | A class for mapping C++ types to some object |
| Wizt::TypeNotFound | Exception that is thrown if the type is not found on GLCache access |
| Wizt::TypeSpecificGLCacheFactory | This is semantically a |
| Wizt::TypeSpecificGLCacheFactoryPtr | This is semantically |
| Eagle::UnaryMinus | |
| Eagle::UnaryOperatorNode | Template node class to perform unary operations on evaluate-able nodes |
| std::underflow_error | STL class |
| Eagle::Unit | Http://en.wikipedia.org/wiki/Fundamental_unit In the SI system there are 7 fundamental units: kilogram, meter, candela, second, ampere, kelvin, and mole |
| Wizt::Updater | |
| Wizt::Updater< VObject > | |
| Wizt::URenderException | Exception class for user-thrown errors during rendering |
| Wizt::VStream::URL | |
| Wizt::VParameter::UserIterator | Iterator object that allows to inspect the objects that (might) be using the current VParameter under a given alias name |
| Wizt::UserRenderException | |
| orgQhull::UsingLibQhull | Provide qh_fprintf (Qhull.cpp) access to Qhull |
| UtilityRotor3D | Creates a rotor3D from given 3 angles (Euler-angles) |
| Wizt::VAbstractValue | Implementation of a VISH type via procedural referencing instead of instantiation |
| Wizt::VAbstractValueParameter | Making parameters for abstract values |
| Wizt::VAcceptInfo | An intermediate class that holds information about what kind of input objects a certain VObject accepts |
| Wizt::VAcception | Accept information for a given VObject |
| Wizt::VAcceptList | A list of accept informations |
| Wizt::VAcceptListTracer | |
| Wizt::VAction | An action object that allows to schedule objects for request execution, i.e |
| Wizt::VActionNotifier | Notifier object for actions |
| std::valarray | STL class |
| Wizt::ValueAction | Route a notification event to an object's member function |
| Wizt::ValueActionBase | An abstract Value notifier that re-routes valueChanged events to virtual actions |
| VWebControl::ValueIterator | |
| VishControl::ValueIterator | |
| Wizt::ValueMap | List of the components of a compound type |
| Wizt::ValueNotifier | Base class for objects which are informed when a value is changed |
| Wizt::ValueNotifierList | A node which serves to identify multiple instances of input alternatives for a certain value |
| Wizt::ValuePool | A ValuePool is the home of local values of certain input objects |
| Wizt::ValuePoolProvider | Procedural interface for requesting a ValuePool |
| Wizt::ValuePoolReferer | Abstract base class for objects that may provide objects that provide an active value pool (two-fold indirection) |
| Wizt::ValueSet | A set of values |
| Wizt::ValueSetNotFound | |
| Wizt::ValueShadowIterator | Iterator class for values stored in multiple ValuePools (also called "shadows" of a variable) |
| Eagle::Context::VariableList | |
| Eagle::VariableNode | A node that references some variable which will be set by the Context of the Evaluator |
| Wizt::ValuePool::VarMap_t | |
| Wizt::VBO | A vertex buffer object, encompassing many vertex buffer arrays and a rendering routine with pre- and post execution code |
| Wizt::VBOCreator | Creator for VBO objects |
| Wizt::VCamera | The Camera object for OpenGL operations in VISH |
| Wizt::VCameraSet | A list of renderable objects, sorted in layers |
| Wizt::VChart | Specify a coordinate system |
| Wizt::VChartDependent | |
| Wizt::VChartList | Specify a coordinate system |
| Wizt::VChartSelector | |
| Wizt::VComponentValue | Think hard whether tha VComponentValue shouldn't rather refer to VValueType<> instead of an VValue<Type>, because then we can described structures recursively as components of each other |
| Wizt::VConnectionTypeColors | A helper class that serves to associate types with color values, that are stored a text |
| Wizt::VConnectionValidator | A base class for objects that want to be informed if the connectivity if an object's data flow graph has changed |
| Wizt::VConnectionValidatorList | A base class for objects that inform VConnectionValidator about their validity |
| Wizt::VContext | A Context is always local and unique for each call |
| Wizt::VCotask | Base class for VObjects (to be used via multiple inheritance) to ease asynchroneous computations in a thread |
| Wizt::VCreationPreferences | A certain object (especcially input types) might have multiple implementations by the GUI or alternative input mechanism |
| Wizt::VCreator | Given some VObject, this is the accompanying Creator object that may be used to create VObject's on request |
| Wizt::VCreatorBase | Base class for objects that serve to create VObject's |
| Wizt::VCreatorCategory | |
| Wizt::VCreatorMap | |
| Wizt::VCreatorProperties | A set of properties for a VCreator |
| Wizt::VCreatorProperty | A set of property elements for VCreator objects |
| Wizt::VCreatorPropertyBase | Base class for VCreator property elements |
| Wizt::VCreatorPropertyElements | |
| Wizt::VDataFlowGraph | Request structure |
| Eagle::Coordinates::vector | Tangential vectors, which are column vectors |
| Eagle::Plane::vector | |
| Eagle::Vector | A Vector is an fixed-size array (see class FixedArray) with vector space operations, i.e |
| Eagle::PhysicalSpace::vector | 3-dimensional vector |
| std::vector | STL class |
| Eagle::STA::CartesianChart4D::vector | 4-dimensional vector |
| Eagle::VectorDotProduct | Dot product between tangential vectors |
| Eagle::VectorizationTrait | A trait class to specify which vectorizations are possible |
| Eagle::VectorSquare | Computes v^2 for vector v |
| VectorStats< T > | |
| Eagle::VectorTimesScalar | A node implementing vector times scalar multiplication |
| Eagle::VectorWedgeVector | A node operator implementing creation of a bivector from two vectors |
| Wizt::VEnumSelection | Container to hold a selection of strings with one of them selected |
| Wizt::VEnvironmentRenderObject | Base class for VObjects that may do some rendering |
| Wizt::VertexArrayCreator< VGL_NAMED_VERTEX_ATTRIB > | |
| Wizt::VertexArrayCreator< VGL_TEX0_COORDINATES > | |
| Wizt::VertexArrayCreator< VGL_TEX1_COORDINATES > | |
| Wizt::VertexArrayCreator< VGL_VERTEX_COORDINATES > | |
| Wizt::VertexArrayCreator< VGL_VERTEX_NORMALS > | |
| Wizt::VertexAttribArray | Base class for arbitrary vertex attribute arrays |
| Wizt::RenderBasin::VertexAttribute | A Vertex Attribute is a set of data which sits available on each vertex of some rendering |
| Wizt::VERTEXBUFFER | |
| Wizt::VertexShader | An OpenGL vertex shader |
| Wizt::GeometryShader::VerticesIn< GeometryShader::IPOINTS > | |
| Wizt::GeometryShader::VerticesIn< GeometryShader::LINES > | |
| Wizt::GeometryShader::VerticesIn< GeometryShader::LINES_ADJACENCY > | |
| Wizt::GeometryShader::VerticesIn< GeometryShader::TRIANGLES > | |
| Wizt::GeometryShader::VerticesIn< GeometryShader::TRIANGLES_ADJACENCY > | |
| Wizt::VFilter | Implements a data filter, or computational object in general |
| Wizt::VFindLongestObjectInputName | Class to find the longest input (parameter) name |
| Wizt::VFrameBuffer | Encapsulation of a framebuffer, which is used to collect image rendering results |
| Wizt::VGLRenderContext | A special vish context that is passed to VGLRenderObjects when rendering |
| Wizt::VGLRenderObject | Base class for objects that implement a drawing routine using OpenGL |
| Wizt::VGraph | Required operations: |
| Wizt::Viewer | 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 |
| Wizt::ViewerState | 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 |
| Eagle::ViewPoints | A set of priority-weighted view points, used to recommend view points for objects |
| VInitialization | Initialization: Each Plugin should (MacOS: Must) contain a function |
| Wizt::VInput | Implementation of input objects |
| Wizt::VInputBase | Base class for objects providing an input of any kind |
| Wizt::VInputCreator | Template class for convenient definition of creators of objects providing a multiple input types |
| Wizt::VInputCreatorBase | Base class for objects that may create objects that serve as input facilities |
| Wizt::VInputCreatorIterator | Abstract base class for iterators of input objects |
| Wizt::VInputRegistry | Templated convenience class that encompassess all VInput registry functions that are associated with a certain type |
| Wizt::VObject::VInputSet | |
| Wizt::VInputValue | A VInput that actually stores its type here |
| Wizt::VInputValueTrait | |
| Wizt::VInputValueTrait< Eagle::FixedArray< double, 2 > > | |
| Wizt::VInputValueTrait< Eagle::PhysicalSpace::bivector > | |
| Wizt::VInputValueTrait< Eagle::PhysicalSpace::point > | |
| Wizt::VInputValueTrait< Eagle::PhysicalSpace::rotor > | |
| Wizt::VInputValueTrait< Eagle::PhysicalSpace::tvector > | |
| Wizt::VInputValueTrait< Enum > | Type trait for Enum types as input objects |
| Wizt::VInputValueTrait< GLFontManager > | |
| Wizt::VInputValueTrait< ImageTile > | |
| Wizt::VInputValueTrait< info > | |
| Wizt::VInputValueTrait< Options > | |
| Wizt::VInputValueTrait< rgba_float_t > | |
| Wizt::VInputValueTrait< std::vector< string > > | |
| Wizt::VInputValueTrait< string > | |
| Wizt::VInputValueTrait< TransformOperator > | |
| Wizt::VInputValueTrait< VCamera > | |
| Wizt::VInputValueTrait< VCameraSetPtr > | |
| Wizt::VInputValueTrait< VChart > | |
| Wizt::VInputValueTrait< VFrameBuffer > | |
| Wizt::VInputValueTrait< VGraph > | |
| Wizt::VInputValueTrait< VImageTileProcessor > | |
| Wizt::VInputValueTrait< VInteractionEvent > | |
| Wizt::VInputValueTrait< VObjectStatus > | |
| Wizt::VInputValueTrait< VRenderAble > | |
| Wizt::VInputValueTrait< VScalarFunctor > | |
| Wizt::VInputValueTrait< VSceneLayers > | Type trait to allow using VSceneLayers as inputs for Vish objects |
| Wizt::VInputValueTrait< VThreadManager > | |
| Wizt::VInputValueTrait< VTime > | |
| Wizt::VInputValueTrait< VTypeTemplate > | |
| Wizt::VInteractionEvent | |
| VishControl::VISH | |
| VishControl | |
| VishControlCreator | |
| Wizt::VishSaver | A saver functor |
| VishScriptSaver | |
| Wizt::VLoader | Data loading: objects derived from the VLoader class are intrinsically known by the VISH system |
| Wizt::VLoaderInfo | Interface to VObjects that are created through a Loader |
| Wizt::VLoaderRef | |
| Wizt::VLogger | Log messages, usually for analysing the program's internal flow for debugging purposes |
| Wizt::VLogStreamCreator | |
| Vltstr | |
| Wizt::VManagedDomainObject | Domain-specific object creation database |
| Wizt::VManagedObject | Common class for all objects that may be created through the database |
| Wizt::VManagedObjectBase | Virtual base class for manageable objects |
| Wizt::VManagedObjectIterator | Abstract iterator class for iterating over a Domain of objects |
| VMap | |
| VModule | Aww.. |
| Wizt::VModules | |
| Wizt::VObject | Generic base class for all VObjects |
| Wizt::VObjectAge | Internal class used to store various ages of objects |
| Wizt::VObjectIterator | Iterator functor to be used for iterating over the parents of a certain VObject |
| Wizt::VObjectPtrBase | Abstract virtual base class holding pointers to VObjects |
| Wizt::VObjectStatus | Description of the status of an object, primarily to be used within a GUI display |
| Wizt::VOperatorCache | 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 |
| Wizt::VOutput | Output properties of an object |
| Wizt::VOutputAssignmentContext | An internal type to pair VOutput's and ValuePool references |
| Wizt::VOutputIterator | The callback class for iterating over the output objects (i.e |
| Wizt::VParameter | A VParameter enables VObjects to retrieve certain values |
| Wizt::VParameterConnectionConstraint | Abstract base class to allow adding constraints on parameter connectibility |
| Wizt::VParameterObjectCreator | Base class for using a component of an object as parameter |
| Wizt::ValueMap::VParList | |
| Eagle::ViewPoints::VPData | |
| PfViewer::VPfCallback | |
| Wizt::VPipeline | Convenient template to define VCreator objects with inputs and outputs |
| Wizt::VPipeline< AcceptList< InputTypes >, FunctionObject, OutputType > | |
| Wizt::VPipeline< AcceptList< InputTypes >, FunctionObject, void > | |
| Wizt::VPipeline< InputType, FunctionObject, void > | Reduction of the VPipeline to no output type, which constitutes a Sink |
| Wizt::VPipeline< void, FunctionObject, OutputType > | Reduction of the VPipeline to no input type, which constitutes a Source |
| Wizt::VPipelineCreator | A VPipeline that gets the input/output type definition from the specified FunctionObject |
| Wizt::VPointer | A convenience template class to use weak pointers on objects that are not yet defined, but known to be derived from class VManagedObjectBase |
| Wizt::VPolyOutput | An output that adds itself as input slot to all existing objects of a given type |
| Wizt::VProxyObject | |
| Wizt::VManagedObject::VRemoveItem | Callback object when unloading a module |
| Wizt::VRenderAble | A reference to a RenderAble object |
| Wizt::VRenderContext | Base class for objects that may display something |
| Wizt::VRenderObject | Base class for objects that implement a drawing routine |
| Wizt::VRenderPrecision | Constraints for rendering, sustained across display contexts |
| Wizt::VRequest | Request structure |
| Wizt::VSaveable | Base class for objects that can be saved to some URL |
| Wizt::VScalarFunctor | Implements a function that yields a scalar value, given some floating point input |
| Wizt::VScene | A scene is a class to render a collection of objects |
| Wizt::VSceneObjects | A list of renderable objects, sorted in layers |
| Wizt::VScheduler | Scheduler for VISH Objects |
| Wizt::VScriptable | Base class for objects that may be accessed via a script interface |
| Wizt::VScriptAction | Invoking class member functions through the VScript API |
| Wizt::VScriptActions | |
| Wizt::VScriptFunctor | Implementation of a function that may be called through a script interface |
| Wizt::VScriptInterface | |
| VScriptLoader | |
| Wizt::VScriptParameters | A set of named function call arguments |
| Wizt::VScriptParser | |
| Wizt::VScriptTypedValue | A textual encoding of a certain value, together with optional comment and default value |
| Wizt::VScriptValue | A polymorphic value of a function call argument or function return value |
| Wizt::VSimpleStreamObject | |
| Wizt::VSink | Implements a data sink |
| Wizt::VSkale | Helper class for VObject components (so-called Vish Skales) |
| Wizt::VSlot | Intermediate class for storing (named) references to parameters |
| Wizt::VSlotChangeInfo | Vish I/O data structure to communicate a set of Slots |
| Wizt::VSlotIterator | The callback class for iterating over the input objects (i.e |
| Wizt::VSlotSet | |
| Wizt::VSocketAction | Abstract interface class that is to be implemented by some application |
| Wizt::VSocketActionCreator | |
| Wizt::VSource | Implements a data source |
| Wizt::VStateCreator | This is an experimental class to easy creation of context-relative object states |
| Wizt::VStateCreatorBase | Base class for objects carrying context-specific states |
| Wizt::VStream | Network connection routines |
| Wizt::VStreamLogger | |
| Wizt::VStreamObject | |
| Wizt::VTask | A functor object that runs in a separate thread, if fired from a ThreadManager |
| Wizt::VTaskMessage | Base class for messages sent from one thread to another one |
| Wizt::VThreadCreator | Creation interface providing an actual implementation of Threads |
| Wizt::VThreadManager | Managing Threads - the code to be executed in another thread is provided in functor objects derived from VTask |
| Wizt::VTime | An input type for steering time-dependent objects |
| Wizt::VTraceRequestID | Trace the ID of an request |
| Wizt::VTypedValueBase | Base class for values with type |
| Wizt::VTypeTemplate | |
| Wizt::VUndoAction | |
| Wizt::VUndoStack | |
| Wizt::VUrlSystemHandler | |
| Wizt::VValue | A typed value with storage within the class |
| Wizt::VValue< GLFontManager > | |
| Wizt::VValue< VSocketAction > | The actual information that is stored for a socket connection within a VObject |
| Wizt::VValue< VThreadManager > | VObject-local management of threads |
| Wizt::VValueBase | Abstract base class for values which are used as input types, e.g |
| Wizt::VValueCopyTrait | Type trait class that tells how to create a new value, given an existing one |
| Wizt::VValueCopyTrait< Action > | |
| Wizt::VValueCopyTrait< RefPtr< Type > > | Copy type trait for referenced types: create a new instance of the referred-to object |
| Wizt::VValueCopyTrait< RefPtr< TypedChunk< T > > > | Copy operation is per reference, not per value! |
| Wizt::VValueCopyTrait< VBoundingBox > | |
| Wizt::VValueCopyTrait< VColormap > | |
| Wizt::VValueCreator | |
| Wizt::VValueParameter | Shortcut convenience class for VParameters that refer to a VValue<> storage of the actual parameter |
| Wizt::VValueParameter< GLFontManager > | |
| Wizt::VValueParameter< VSocketAction > | A VParameter that handles socket connections |
| Wizt::VValueParameter< VThreadManager > | A VParameter that handles threads |
| Wizt::VValueTrait< ::IntegralLines::EmitterPoints > | |
| Wizt::VValueTrait< ::IntegralLines::LinesPoints > | |
| Wizt::VValueTrait< Action > | |
| Wizt::VValueTrait< Alpha > | |
| Wizt::VValueTrait< Beta > | |
| Wizt::VValueTrait< bool > | |
| Wizt::VValueTrait< BoundingBall > | |
| Wizt::VValueTrait< CalCoreMeshPtr > | |
| Wizt::VValueTrait< double > | |
| Wizt::VValueTrait< Eagle::FixedArray< double, 2 > > | |
| Wizt::VValueTrait< Eagle::PhysicalSpace::bivector > | |
| Wizt::VValueTrait< Eagle::PhysicalSpace::point > | |
| Wizt::VValueTrait< Eagle::PhysicalSpace::rotor > | |
| Wizt::VValueTrait< Eagle::PhysicalSpace::tvector > | |
| Wizt::VValueTrait< Enum > | Type trait for Enum types as VObject communicators |
| Wizt::VValueTrait< float > | |
| Wizt::VValueTrait< GLFontManager > | |
| Wizt::VValueTrait< ImageTile > | |
| Wizt::VValueTrait< info > | |
| Wizt::VValueTrait< int16_t > | |
| Wizt::VValueTrait< int32_t > | |
| Wizt::VValueTrait< int64_t > | |
| Wizt::VValueTrait< MetaViewerInputType > | |
| Wizt::VValueTrait< Options > | |
| Wizt::VValueTrait< Range > | |
| Wizt::VValueTrait< RefPtr< TypedChunk< double > > > | |
| Wizt::VValueTrait< RefPtr< TypedChunk< float > > > | |
| Wizt::VValueTrait< RefPtr< TypedChunk< int16_t > > > | |
| Wizt::VValueTrait< RefPtr< TypedChunk< int32_t > > > | |
| Wizt::VValueTrait< RefPtr< TypedChunk< int64_t > > > | |
| Wizt::VValueTrait< rgba_float_t > | Value trait for colors |
| Wizt::VValueTrait< std::vector< string > > | |
| Wizt::VValueTrait< string > | VValue Specialization for strings: trivial |
| Wizt::VValueTrait< TransformOperator > | Value trait to allow TransformOperators as object glue |
| Wizt::VValueTrait< VBoundingBox > | The string I/O interface for bounding boxes |
| Wizt::VValueTrait< VCamera > | |
| Wizt::VValueTrait< VCameraSetPtr > | |
| Wizt::VValueTrait< VChart > | |
| Wizt::VValueTrait< VChartList > | |
| Wizt::VValueTrait< VColormap > | |
| Wizt::VValueTrait< VFrameBuffer > | |
| Wizt::VValueTrait< VGraph > | |
| Wizt::VValueTrait< ViewerState > | Type trait for ViewerStates, to be used for TypedSlot<ViewerState> instances |
| Wizt::VValueTrait< VImageTileProcessor > | |
| Wizt::VValueTrait< VInteractionEvent > | |
| Wizt::VValueTrait< VObjectRef > | |
| Wizt::VValueTrait< VObjectStatus > | |
| Wizt::VValueTrait< VRenderAble > | |
| Wizt::VValueTrait< VScalarFunctor > | |
| Wizt::VValueTrait< VSceneLayers > | Type trait to allow using VSceneLayers as type to be communicated across Vish objects |
| Wizt::VValueTrait< VSlotChangeInfo > | |
| Wizt::VValueTrait< VSocketAction > | |
| Wizt::VValueTrait< VStringList > | |
| Wizt::VValueTrait< VThreadManager > | |
| Wizt::VValueTrait< VTime > | |
| Wizt::VValueTrait< VTypeTemplate > | |
| VWebControl | |
| VWebControlCreator | |
| WallPaper | |
| MemCore::WeakPtr | A pointer class which behaves like native C++ pointers, but knows about the lifetime of the referenced objects |
| WebFileRenderer | |
| Wizt::WebGLProgram | |
| Wizt::WebGLRenderContext | Context for rendering into a WebGL stream |
| Wizt::WebGLVertexAttribute | |
| Wizt::WebGLViewer | |
| WebVish | |
| std::wfstream | STL class |
| std::wifstream | STL class |
| std::wios | STL class |
| std::wistream | STL class |
| std::wistringstream | STL class |
| std::wofstream | STL class |
| std::wostream | STL class |
| std::wostringstream | STL class |
| WritePng | |
| std::wstring | STL class |
| std::wstringstream | STL class |
| Cal3DMeshVObject::XMLSaver | |
| Eagle::YlmCoefficients | |
| yy_buffer_state | |
| yy_trans_info | |
| yyalloc | |
| yyFlexLexer | |
| YYLTYPE | |
| YYSTYPE | |
| Eagle::ZeroNode | A scalar node that always returns zero |
1.7.5