| Nanonymous_namespace{clod_point_renderer.cxx} | |
| ▼Ncgv | Cgv namespace |
| ►Nbase | Base namespace holds the base hierarchy, support for plugin registration and signals |
| Cabst_property_access | |
| Caction | Used in tree traversals together with the traverser |
| Cargument_handler | Interface for objects that process unknown command line arguments |
| Cattach_slot | Interface for an attachment slot that can store a base pointer |
| Cbase | Base class for all classes that can be registered with support for dynamic properties (see also section Base Hierarchy of page Namespace cgv::base) |
| Cbase_generator | Implements a dynamic object, that can be composed of independent variables, which are handled as properties of the base_generator and published through the property interface of the base class |
| Cbase_method_action | Base class for all actions that use methods of class X |
| Ccall_reflection_handler | |
| Ccast_const_helper | |
| Ccast_const_helper< group > | |
| Ccast_const_helper< named > | |
| Ccast_const_helper< node > | |
| Ccast_const_helper_base | |
| Ccast_helper | |
| Ccast_helper< group > | |
| Ccast_helper< named > | |
| Ccast_helper< node > | |
| Ccast_helper_base | |
| Ccommand_info | Structure to store an analized command |
| Cconfig_file_driver | Abstract interface for a config file driver that handles permanent registration and gui config files |
| Cconfig_file_observer | Abstract interface for observers of config files |
| Cconsole | Interface to the console of the application with implementation of the property interface |
| Cdriver | Interfaces that add several listeners and objects |
| Cemulated_property_access | |
| Cextract_policy_struct | |
| Cextract_policy_struct< true, X > | |
| Cfactory | Interface for a factory that allows to create objects derived from cgv::base::base |
| Cfactory_impl | Implementation of factory for objects of type T using the standard constructor |
| Cfactory_impl_1 | Implementation of factory for objects of type T using a constructor with one argument of type CA |
| Cfactory_impl_2 | Implementation of factory for objects of type T using a constructor with two arguments of types CA1 and CA2 |
| Cfactory_registration | Convenience class to register a factory of the given class type |
| Cfactory_registration_1 | Convenience class to register a factory of the given class type that uses a constructor with one argument of type CA |
| Cfactory_registration_2 | Convenience class to register a factory of the given class type that uses a constructor with one argument of type CA |
| Cfind_action | Simple action implementation that adds nodes implementing X to a results vector |
| Cgroup | Node with children |
| Cmatched_method_action | Complete implementation of method actions that call a begin and end method when entering and leaving a node |
| Cmethod_action | Base class for all method actions that take a single argument of type T1 in their signature |
| Cmethod_action_2 | Base class for all method actions that take a single argument of type T1 in their signature |
| Cnamed | Base class for all gui types |
| Cno_handler | |
| Cnode | Keeps a pointer to its parent |
| Cobject_collection | |
| Cobject_constructor | Abstract base class of helpers to perform delayed registration and creation of objects in case that the registration is currently disabled |
| Cobject_constructor_impl | |
| Cobject_constructor_impl_1 | |
| Cobject_constructor_impl_2 | |
| Cobject_registration | Convenience class to register an object of the given class type |
| Cobject_registration_1 | Convenience class to register an object of the given class type with one constructor argument |
| Cobject_registration_2 | Convenience class to register an object of the given class type with two constructor arguments |
| Cproperty_access | |
| Cproperty_access< bool > | |
| Cproperty_access< cgv::type::int16_type > | |
| Cproperty_access< cgv::type::int32_type > | |
| Cproperty_access< cgv::type::int64_type > | |
| Cproperty_access< cgv::type::int8_type > | |
| Cproperty_access< cgv::type::uint16_type > | |
| Cproperty_access< cgv::type::uint32_type > | |
| Cproperty_access< cgv::type::uint64_type > | |
| Cproperty_access< cgv::type::uint8_type > | |
| Cproperty_access< double > | |
| Cproperty_access< float > | |
| Cproperty_access< std::string > | |
| Cproperty_declaration_reflection_handler | |
| Cregistration_info | |
| Cregistration_listener | Interfaces that allows to listen to registration events |
| Cregistration_order_definition | Helper class whose constructor calls the define_registration_order() function |
| Cregistration_order_info | |
| Cresource_file_info | Information registered with each resource file |
| Cresource_file_registration | Convenience class to register a resource file |
| Cresource_string_registration | Convenience class to register a resource string |
| Cserver | Interfaces that add provides very basic functionality |
| Csingle_method_action | Complete implementation of method actions that only call one method when entering a node |
| Csingle_method_action_2 | Complete implementation of method actions that only call one method when entering a node |
| Cstandard_type_property_access | |
| Ctest | Structure used to register a test function |
| Ctest_registration | Declare an instance of test_registration as static variable in order to register a test function in a test plugin |
| Ctraverse_callback_handler | Interface of a handler for traverse callbacks |
| Ctraverse_policy | Nodes should inherit from this policy class to allow selective tree traversals |
| Ctraverser | Class used to traverse a tree structure |
| Cuse_handler | |
| Cuser_feedback | Function pointers implementing user feedback functionality of find_or_download_data_file() function |
| ►Ndata | Namespace for data management components |
| Cascii_read_reflection_handler | Read from ascii file |
| Cascii_reflection_handler | Read from ascii file |
| Cascii_write_reflection_handler | Read from ascii file |
| Cbinary_read_reflection_handler | Read from ascii file |
| Cbinary_reflection_handler | Reflect to and from binary file |
| Cbinary_write_reflection_handler | Read from ascii file |
| Ccomponent_format | Component format inherits the information of a packing_info and adds information on the component type, which components are present in the data and in which order they appear |
| Cconst_data_view | The const_data_view has the functionality of the data_view but uses a const pointer and therefore does not allow to manage the pointer nor to set the data |
| ►Cdata_format | A data_format describes a multidimensional data block of data entries |
| Cdimension_info | |
| Cdata_view | Data view gives access to a data array of one, two, three or four dimensions |
| Cdata_view_base | Base class of both implementations of the data view managing the component format, the dimension of the view and the step sizes |
| Cdata_view_impl | Template class implementing the part of the view that depends on whether the pointer is const or not and manages the data pointer itself |
| ►Cdynamic_priority_queue | IndexHeap is a heap that allows changing of the elements |
| Cextended_element | Store per element, whether it is empty and a link to the next empty element or to the heap location |
| Cgrid | |
| Cimage_view | |
| Cinterval_map | Extension of a standard map container that allows easy retreival of lower and upper bounds given a key |
| Cio_reflection_handler | Common base for all io reflection handlers |
| Coptional | A simple and naiive implementation of an optional value |
| Cpacking_info | Packing_info class stores information about packed integers structures |
| ►Cquadtree | |
| Cnode | |
| Cpoint_provider | |
| Cref_arr | |
| Cref_counted | If you derive your class from this class, a ref_ptr will do reference counting in the inhereted ref_count member |
| Cref_ptr | Reference counted pointer, which can work together with types that are derived from ref_counted, in which case the reference count of ref_counted is used |
| ►Cref_ptr_impl | |
| Ccounter_type | Struct to store the pointer with a count |
| Cref_ptr_impl< T, true > | |
| Cref_ptr_tag | Struct used to make ref pointers to ref_counted friends of ref_counted |
| Cunion_find | |
| Ng2d | Forward declaration to give generic renderer access to protected members |
| ►Ngui | Namespace that holds the abstract gui interface |
| Cabst_control | gui and type independent base class of all controls |
| Cabst_control_provider | type independent base class of control provider interface |
| Cabst_view | Type independent &base class of all views |
| Canimation | |
| Canimation_manager | |
| Capplication | Application class is only a container for static methods that give access to the windows of the application |
| Carrow_render_style_gui_creator | |
| Cbase_provider | |
| ►Cbase_provider_generator | |
| Cgui_definition | Each gui definition consists of the textual definition as well as an options string |
| Cbox_render_style_gui_creator | |
| Cbox_wire_render_style_gui_creator | |
| Cbutton | gui independent button class that provides a click signal |
| Cbutton_mapping | |
| Cchoice_event | Class to represent choice events that include focus change and selection change events |
| Cclod_point_render_style_gui_creator | |
| Ccommand_info | |
| Ccone_render_style_gui_creator | |
| Ccontrol | |
| Ccontrol_provider | |
| Cdialog | Use this class to construct and execute a modal dialog |
| Cdirectory_helper | A convenience class that provides a directory input gui control |
| Cellipsoid_render_style_gui_creator | |
| Cevent | |
| Cevent_handler | Interface for all classes that want to receive events |
| Cfile_helper | A convenience class that provides a file input gui control |
| Cgamepad_key_event | Gamepad key events use the key codes defined in gamepad::GamepadKeys |
| Cgamepad_server | |
| Cgamepad_stick_event | Gamepad extension of stick events |
| Cgamepad_throttle_event | Gamepad extension of throttle events |
| Cgeometric_blend_animation | |
| Cgroup_render_style_gui_creator | |
| Cgui_creator | Interface for gui creators |
| Cgui_creator_registration | Helper template for registration of gui creators |
| Cgui_driver | Abstract base class for gui drivers |
| Cgui_group | gui independent group class which is a container for gui elements |
| Chelp_menu_entry | Derive from this class to provide a menu entry that can open a seperate window showing help information |
| Chelp_menu_entry_registration | Convenience class to register a factory of the given class type that must be derived from cgv::gui::help_menu_entry |
| Chelp_message | |
| Ckey_control | |
| Ckey_control< bool > | |
| Ckey_event | Class to represent all possible keyboard events with the EID_KEY |
| Clayout | |
| Clayout_dir_spacing | |
| Clayout_inline | |
| Clayout_spacings | |
| Clayout_table | |
| Clayout_table_cell | |
| Cline_render_style_gui_creator | |
| Clinear_blend_animation | |
| Cmenu_provider | Derive from this class to provide a gui to the current viewer |
| Cmonitor_description | Monitor description |
| Cmouse_event | Class to represent all possible mouse events with the EID_MOUSE |
| Cnormal_render_style_gui_creator | |
| Cpoint_render_style_gui_creator | |
| Cpose_event | Class to represent all pose events from tracking systems with the EID_POSE |
| Cpriority | |
| Cproperty_string | A convenience class for compiling strings of delimited key-value pairs useful for defining GUI control options |
| Cprovider | Derive from this class to provide a gui to the current viewer |
| Crectangle_render_style_gui_creator | |
| Cresizable | |
| Crotation_animation | |
| Cshortcut | Shortcut class encapsulates a key with modifiers |
| Cslerp_animation | |
| Csphere_render_style_gui_creator | |
| Cspline_tube_render_style_gui_creator | |
| Cstick_event | Class to represent stick events with the EID_STICK |
| Csubprovider | Derive from this class to use a provider from another viewer |
| Csurface_render_style_gui_creator | |
| Csurfel_render_style_gui_creator | |
| Ctext_editor | Abstract base class for text editors |
| Ctext_editor_callback_handler | Implement this interface to interact with the text editor |
| Ctext_style | Description of a text style |
| Ctheme_info | |
| Ctheme_observer | |
| Cthrottle_event | Class to represent events that inform on a change in a one axis controller with the EID_THROTTLE |
| Ctrigger | Trigger provides callbacks after a programmable time delay |
| Ctrigger_server | |
| Cvalue_animation | |
| Cview | Class for gui elements that view values of the type specified in the template argument |
| Cvolume_render_style_gui_creator | |
| Cvr_calibration | Vr key events use the key codes defined in vr::VRKeys |
| Cvr_event_extension | Interface common to vr events |
| Cvr_key_event | Vr key events use the key codes defined in vr::VRKeys |
| Cvr_pose_event | Vr extension of pose events |
| Cvr_server | Server for vr events |
| Cvr_stick_event | Vr extension of stick event |
| Cvr_throttle_event | Vr extension of throttle event |
| Cwindow | gui independent window class |
| Cwith_index_struct | Helper struct to support value references as well as value references with index |
| Cwith_index_traits | |
| Cwith_index_traits< with_index_struct< T > > | |
| ►Nreflect | In this namespace reflection of types is implemented |
| Cabst_enum_reflection_traits | Type independent functionality for all enum fallback implementations |
| Cabst_reflection_traits | Abstract interface for type reflection with basic type management and optional string conversion |
| Cdebug_reflection_handler | Debug reflection handler generates a string in the member output that contains a complete description of the reflected instance |
| ►Cdetail | |
| Creflect_base_dispatch | |
| Creflect_base_dispatch< true, B > | |
| Creflect_const_array_dispatch | |
| Creflect_const_array_dispatch< true, T, n > | |
| ►Creflect_member_impl | |
| Creflect_impl | |
| Creflect_impl< true, RT > | |
| Creflect_member_impl< T, RTK_SELF_REFLECT > | |
| Creflect_member_impl< T, RTK_STD_TYPE > | |
| Creflect_method_impl | |
| Creflect_method_impl< M, void > | |
| Creflect_vector_dispatch | |
| Creflect_vector_dispatch< true, T > | |
| Cenum_reflection_traits | This type specific reflection traits class is used by the reflect_enum function to reflect enum types |
| Cextern_reflection_traits | This reflection traits implementation is used for external self_reflect implementations of instances of type T where the external implementation is a self_reflect function in type D |
| Cextern_reflection_traits_impl | This reflection traits implementation is used by the reflect_string function |
| Cextern_string_reflection_traits | This reflection traits implementation is used for external self_reflect implementations together with string interface of instances of type T where the external implementation is a self_reflect function in type D |
| ►Cfind_reflection_handler | The cgv::reflect::find_reflection_hander steers traversal to a specific member and calls the virtual function process_member() that can be overloaded by derived classes such as cgv::reflect::get_reflection_handler |
| Cgroup_info | |
| Cget_reflection_handler | Access to a member variable of an instance |
| Cmethod_interface | Abstract interface to call a method of a given instance |
| Cmethod_interface_impl | Forward declaration of method_interface_impl which is implemented in <cgv/reflect/method_interface_impl.ph>, include the generated header <cgv/reflect/method_interface_impl.h> |
| Cmethod_parameter_traits_helper | |
| Cmethod_parameter_traits_helper< i, i, M > | |
| ►Creflection_handler | Self reflection handler is passed to the virtual self_reflect() method of cgv::base::base |
| Cnesting_info | For each nesting during traversal a nesting info is pushed back to the end of the nesting info stack |
| Creflection_traits | Default implementation of the reflection traits providing type specific interface |
| Creflection_traits_impl | Implementation of the reflection traits providing type specific interface for variable base class |
| Creflection_traits_impl< T, B, true > | Implementation variant for abstract base classes |
| Creflection_traits_info | Reflection_traits_info defines compile time information about reflection_traits for a given type T |
| Creflection_traits_info_self | |
| Creflection_traits_info_self< true, T > | |
| Creflection_traits_info_std | |
| Creflection_traits_info_std< true, T > | |
| Creflection_traits_string_impl | This template allows to distinguish between traits with and without string conversions |
| Creflection_traits_string_impl< true, T, B > | This is the implementation with string conversions |
| Cself_reflection_tag | Derive from this class to announce implementation of the method self_reflect |
| Cset_reflection_handler | |
| ►Nrender | Namespace for api independent GPU programming |
| ►Nanonymous_namespace{clod_point_renderer.cxx} | |
| CDrawParameters | |
| ►Ngl | Namespace for opengl specific GPU programming |
| Cformat_callback_handler | |
| Cgl_context | Implementation of the context API for the OpenGL API excluding methods for font selection, redraw and initiation of render passes |
| Cgl_cursor | Windows only implementation of functionality to create and draw an RGBA texture representing standard mouse cursor icons |
| Cgl_depth_peeler | OpenGL helper class to simplify depth peeling |
| Cgl_implicit_surface_drawable_base | Drawable that visualizes implicit surfaces by contouring them with marching cubes or dual contouring |
| Cgl_performance_monitor | |
| Cgl_time_query | OpenGL helper class to perform time measurements |
| Cgl_traits | Traits structure that maps a fundamental type to the Type enum |
| Cgl_traits< char > | |
| Cgl_traits< double > | |
| Cgl_traits< float > | |
| Cgl_traits< int > | |
| Cgl_traits< short > | |
| Cgl_traits< unsigned char > | |
| Cgl_traits< unsigned int > | |
| Cgl_traits< unsigned short > | |
| Cgl_transparent_renderer | OpenGL helper class to simplify transparent rendering |
| Cimage_drawable | Base class of drawables that show static or animated images |
| Cmesh_drawable | Simple implementation of a drawable for a polygonal mesh with support for materials |
| Ca_buffer | This class provides a_buffer functionality |
| Carray_descriptor_traits | |
| Carray_descriptor_traits< cgv::math::vec< T > > | |
| Carray_descriptor_traits< std::vector< T > > | |
| Carray_descriptor_traits< T[N] > | |
| Carrow_render_data | |
| Carrow_render_style | Style of a point |
| Carrow_render_style_reflect | |
| Carrow_renderer | Renderer that supports point splatting |
| Cattribute_array | |
| Cattribute_array_binding | Attribute_array_binding allows to define vertex attributes (i.e |
| Cattribute_array_binding_base | Base class for attribute_array_bindings |
| Cattribute_array_manager | Attribute array manager used to upload arrays to gpu |
| Cbox_render_data | Render data for box geometry with support for the box_renderer |
| Cbox_render_data_base | A base class for storing render data usable with the box_renderer and box_wire_renderer |
| Cbox_render_style | Boxes use surface render styles |
| Cbox_render_style_reflect | |
| Cbox_renderer | Renderer that supports point splatting |
| Cbox_wire_render_data | Render data for box geometry with support for the box_wire_renderer |
| Cbox_wire_render_style | Box wires extend line render styles |
| Cbox_wire_render_style_reflect | |
| Cbox_wire_renderer | Renderer that supports point splatting |
| Ccallback_drawable | As a drawable can manage only a single context, this callback drawable is a work around for the case when a drawable should draw in several contexts (i.e |
| Cclipped_view | Extends the view class with information on z clipping planes and scene extent and supports clipping plane computation from scene extent |
| Cclod_point_buffer_manager | |
| Cclod_point_render_style | Render style for sphere rendere |
| Cclod_point_render_style_reflect | |
| ►Cclod_point_renderer | |
| CPoint | |
| Ccolor_map | |
| Ccone_render_data | Render data for cone geometry with support for the cone_renderer |
| Ccone_render_style | |
| Ccone_render_style_reflect | |
| Ccone_renderer | Renderer that supports raycasting of cones |
| ►Ccontext | Base class for all drawables, which is independent of the used rendering API |
| CBlendState | Represents a blend state used to configure fragment blending |
| CBufferMask | Represents a buffer mask used to mask depth and color buffer outputs |
| CDepthTestState | Represents a depth test state used to configure depth testing |
| Clight_source_status | Status information of light sources |
| Crender_info | Information necessary for a rendering pass |
| Ccontext_config | Configuration object used to define context parameters that need to be set already at creation time |
| Ccontext_factory_registration | |
| Cdevice_capabilities | |
| Cdraw_call | |
| Cdrawable | Base class for all drawables, which is independent of the used rendering API |
| Celement_descriptor_traits | |
| Celement_descriptor_traits< cgv::math::fmat< T, N, M > > | |
| Celement_descriptor_traits< cgv::math::fvec< T, N > > | |
| Celement_descriptor_traits< cgv::math::mat< T > > | |
| Celement_descriptor_traits< cgv::math::quaternion< T > > | |
| Celement_descriptor_traits< cgv::math::vec< T > > | |
| Celement_descriptor_traits< cgv::media::color< T, cm, am > > | |
| Cellipsoid_render_data | Render data for ellipsoid geometry with support for the ellipsoid_renderer |
| Cellipsoid_render_style | Render style for ellipsoid rendere |
| Cellipsoid_render_style_reflect | |
| Cellipsoid_renderer | Renderer that supports splatting of ellipsoids |
| Cframe_buffer | This class encapsulate frame buffers that live on the GPU and can be used as destination for the render process |
| Cframe_buffer_base | Base interface for framebuffer |
| Cgeneric_render_data | |
| Cgeneric_renderer | |
| Cgl_color_map | |
| Cgroup_render_style | Render style used for group information |
| Cgroup_render_style_reflect | |
| Cgroup_renderer | Abstract renderer class that provides functionality for grouping primitives |
| Cline_render_data | Render data for line geometry with support for the line_renderer |
| Cline_render_style | Style of a line |
| Cline_render_style_reflect | |
| Cline_renderer | Renderer that supports point splatting |
| ►Cmanaged_frame_buffer | Class that manages a frame buffer along with its attachments |
| Cattachment | |
| ►Cmesh_render_info | Mesh_render_info structure manages vertex buffer objects for attribute and element buffers as well as an attribute array binding object |
| Cattribute_configuration | Information needed per mesh attribute to know where it is stored in vbos |
| Cvbo_configuration | Information stored per vbo |
| Cmulti_pass_drawable | Helper class to control multiple render passes in init_frame and after_finish methods of drawable |
| Cnormal_render_style | |
| Cnormal_render_style_reflect | |
| Cnormal_renderer | Renderer that supports rendering point normals |
| Cperformance_measurement | |
| Cperformance_monitor | This class allows to monitor the performance of a set of tasks that are repeatedly executed over time |
| Cperformance_task | |
| Cpoint_render_data | Render data for point geometry with support for the point_renderer |
| Cpoint_render_style | Style of a point |
| Cpoint_render_style_reflect | |
| Cpoint_renderer | Renderer that supports point splatting |
| Cprogram_variable_info | Structure to store information on a shader program variable, i.e |
| Crectangle_render_data | Render data for rectangle geometry with support for the rectangle_renderer |
| Crectangle_render_style | Configuration of rectangle renderer |
| Crectangle_render_style_reflect | |
| Crectangle_renderer | Renderer that supports plane rendering |
| Crender_buffer | This class encapsulate render buffers that live on the GPU which must support frame buffer objects for this to work |
| Crender_buffer_base | Base interface for a render_buffer |
| Crender_component | Base interface for all render components |
| Crender_config | Configuration object used to define render view creation parameters including error handling configuration |
| Crender_data_base | A base class for storing render data and style usable with the default renderers provided in the cgv::render namespace |
| Crender_info | Mesh_render_info structure manages vertex buffer objects for attribute and element buffers as well as an attribute array binding object |
| Crender_style | Base class for all render styles |
| Crenderer | Abstract base class for all renderers that manage a render data and the rendering process |
| Cshader_code | Shader code object holds a code fragment of a geometry vertex or fragment shader and can be added to a shader program |
| Cshader_compile_options | Stores preprocessor options used for conditionally compiling shader programs |
| Cshader_config | Globally unique shader config is registered by default when the cgv library is used |
| Cshader_library | Shader library that handles shader loading and stores shaders |
| Cshader_program | Shader program combines several shader code fragments to a complete definition of the shading pipeline |
| Cshader_program_base | Base interface for shader programs |
| Csphere_render_data | Render data for sphere geometry with support for the sphere_renderer |
| Csphere_render_style | Render style for sphere rendere |
| Csphere_render_style_reflect | |
| Csphere_renderer | Renderer that supports splatting of spheres |
| Cspline_tube_render_style | |
| Cspline_tube_render_style_reflect | |
| Cspline_tube_renderer | Renderer that supports point splatting |
| Cstereo_view | Extends the clipped view with information on eye distance and parallax zero information |
| Csurface_render_style | Style of a point |
| Csurface_render_style_reflect | |
| Csurface_renderer | Base classes for renderers that support surface rendering |
| Csurfel_render_data | Render data for surfel geometry with support for the surfel_renderer |
| Csurfel_render_style | Style of a surfel |
| Csurfel_render_style_reflect | |
| Csurfel_renderer | Renderer that supports point splatting |
| Ctexture | Texture class encapsulates all functionality independent of the rendering api |
| Ctexture_base | Base interface for a texture |
| Ctextured_material | Class that extends obj_material with the management of textures |
| Ctextured_rectangle | This type provides a simple helper class to store rectangles with texture coordinates |
| Ctype_descriptor | Compact type description of data that can be sent to the context; convertible to int |
| Cvertex_attribute | |
| Cvertex_buffer | Vertex buffer is an unstructured memory block on the GPU |
| Cvertex_buffer_base | Base interface for a vertex buffer |
| Cview | Defines a symmetric view with the following quantities: |
| Cvolume_render_style | Style of a volume |
| Cvolume_renderer | Renderer that supports point splatting |
| Cwindow_transformation | Parameters necessary to define window transformation |
| ►Ntype | Namespace for compile time type information |
| ►Ncond | Namespace for conditions that act on types |
| Chas_virtual_destructor | Template condition returning, whether the passed type has a virtual destructor |
| Cis_abstract | Template condition returning, whether the first argument is a base class of the second argument |
| Cis_base_of | Template condition returning, whether the first argument is a base class of the second argument |
| Cis_const | Checks if a type has the const modifier |
| Cis_const< const T > | |
| Cis_const< T & > | |
| Cis_enum | Template condition returning, whether the given type is an enum type |
| Cis_standard_type | Template condition returning, whether the given type is a standard type (excluding void and enum types) |
| Cis_standard_type< bool > | |
| Cis_standard_type< flt32_type > | |
| Cis_standard_type< flt64_type > | |
| Cis_standard_type< int16_type > | |
| Cis_standard_type< int32_type > | |
| Cis_standard_type< int64_type > | |
| Cis_standard_type< int8_type > | |
| Cis_standard_type< std::string > | |
| Cis_standard_type< std::wstring > | |
| Cis_standard_type< uint16_type > | |
| Cis_standard_type< uint32_type > | |
| Cis_standard_type< uint64_type > | |
| Cis_standard_type< uint8_type > | |
| Cis_standard_type< wchar_type > | |
| ►Nfunc | Namespace for functions that act on types |
| Cclean | Drop const and reference modifier from type |
| Cclean_traits | Defines value, reference and pointer types for potentially const and reference types |
| Cdrop_const | Drop const template defines a type without const modifier |
| Cdrop_const< const T > | Specialize drop const type for const types |
| Cdrop_const< T & > | Specialize drop const type for reference types |
| Cdrop_pointer | Drop pointer template defines a type that drops one pointer modifier |
| Cdrop_pointer< T * > | Specialize drop pointer template for pointer types |
| Cdrop_ref | Drop ref template defines a type without reference modifier |
| Cdrop_ref< T & > | Specialize drop ref template for reference types |
| Cmake_argument | Make_argument type function converts a given type to a constant reference if it is not a non constant reference type |
| Cmake_argument< T & > | |
| Cmake_const | Drop const traits defines a type without const modifier |
| Cmake_ref | Ensure the reference modifier for a type without changing the const modifier |
| Cpromote | Determine the type that should be used to represent the result of an operator or function applies to two different types |
| Cpromote< float, int > | |
| Cpromote< float, long > | |
| Cpromote< float, unsigned int > | |
| Cpromote< float, unsigned long > | |
| Cpromote< int, float > | |
| Cpromote< long, float > | |
| Cpromote< unsigned int, float > | |
| Cpromote< unsigned long, float > | |
| Cpromote_const | Promote the const modifier from type T1 to T2 |
| Ctransfer_const | Return const S if T is const and S otherwise |
| Ctransfer_const< const T *, S * > | |
| Ctransfer_const< const T, S > | |
| ►Ninfo | Namespace for templates that provide type information |
| Cname_type_id_pair | |
| Ctype_access | Access value whos type is given by a TypeId |
| Ctype_id | Template with a static member function get_id() of type TypeId returning the TypeId of the template argument T |
| Ctype_id< bool > | |
| Ctype_id< flt32_type > | |
| Ctype_id< flt64_type > | |
| Ctype_id< int16_type > | |
| Ctype_id< int32_type > | |
| Ctype_id< int64_type > | |
| Ctype_id< int8_type > | |
| Ctype_id< std::string > | |
| Ctype_id< std::wstring > | |
| Ctype_id< uint16_type > | |
| Ctype_id< uint32_type > | |
| Ctype_id< uint64_type > | |
| Ctype_id< uint8_type > | |
| Ctype_id< void > | |
| Ctype_id< wchar_type > | |
| Ctype_name | Traits class with a static function get_name() of type const char* that returns the type name of the template argument T |
| Ctype_name< cgv::media::illum::light_source > | |
| Ctype_ptr | Template to cast a pointer into a type known at compile time and specified as TypeId |
| Ctype_ptr< TI_BOOL > | |
| Ctype_ptr< TI_FLT32 > | |
| Ctype_ptr< TI_FLT64 > | |
| Ctype_ptr< TI_INT16 > | |
| Ctype_ptr< TI_INT32 > | |
| Ctype_ptr< TI_INT64 > | |
| Ctype_ptr< TI_INT8 > | |
| Ctype_ptr< TI_STRING > | |
| Ctype_ptr< TI_UINT16 > | |
| Ctype_ptr< TI_UINT32 > | |
| Ctype_ptr< TI_UINT64 > | |
| Ctype_ptr< TI_UINT8 > | |
| Ctype_ptr< TI_WCHAR > | |
| Ctype_ptr< TI_WSTRING > | |
| Cvariant | Convenience template to access a value pointed to by a void pointer where the type of the value is given by a string as it results from cgv::type::info::type_name<T>::get_name() |
| Cvariant< bool > | |
| Cvariant< const char * > | |
| Cvariant< std::string > | |
| Cvariant< std::wstring > | |
| ►Nutils | Namespace that holds tools that dont fit any other namespace |
| Cbig_binary_file | Class to handle files with very large sizes (>=2GB) hiding the ugly win32 api calls |
| Ccount_iterator | |
| Ccount_range | |
| Cdate | |
| Cdate_time | |
| Cenumerate_iterator | |
| Cenumerate_range | |
| Cget_first | Return std::pair::first |
| Cget_first< void, void > | Return const std::pair::first& |
| Cget_second | Return std::pair::second |
| Cget_second< void, void > | Return const std::pair::second& |
| Cguid | Simple struct to represent guid |
| Cindexed_iterator | |
| Cline | Line in a text is simply represented as a token |
| Cpointer_test | |
| CProfiler | A profiler class for managing different stopwatches |
| Cprogression | Progression provides a simple possibility to show progression of process in console |
| Cstatistics | Incrementally accumulate statistical information |
| Cstopwatch | A trivial stop watch class for time measurement |
| Ctime | |
| Ctoken | Representation of a token in a text by two pointers begin and end, that point to the first character of the token and behind the last character of the token |
| Ctokenizer | Tokenizer allows to split text into tokens in a convenient way |
| Ctyped_token | Typed token also stores the type and value of a parsed token |
| ▼Nvr | Vr namespace for virtual reality support |
| Ccontroller_input_config | Configuration of a controller input axis |
| Cdriver_registry | Use this template to register your own driver |
| Cgl_vr_display | Implements offscreen rendering |
| Cvr_calibration_base | Base class with write access to driver calibration matrix |
| Cvr_camera | Interface for mono or stereo cameras in VR headsets |
| Cvr_controller_info | Information provided for controller devices |
| Cvr_controller_state | Extends the trackable state by information on the buttons, input axes and vibration strengths |
| Cvr_device_info | Information provided for any device type |
| Cvr_driver | Interface class for vr drivers |
| Cvr_hmd_info | Information provided for hmd device |
| Cvr_kit | Vr kit is composed of headset, two controllers, and two trackers, where all devices can be attached or detached |
| Cvr_kit_info | Information provided for a vr kit |
| Cvr_kit_state | Structure that stores all information describing the state of a VR kit |
| Cvr_log | Helper struct for logging vr events |
| Cvr_trackable_info | Information provided for trackable devices |
| Cvr_trackable_state | Trackable knows whether it is tracked and its 6d pose stored as 3x4 matrix in column major format |
| Cvr_tracking_reference_info | Information provided for a base station / tracking reference |
| Cvr_tracking_system_info | Information provided for tracking system |
1.9.8