Class List

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

[detail level 12345]

▼Ncgv	Cgv namespace
►Napp
Ccanvas_overlay
►Ccolor_map_editor
Ccm_container
Ccolor_point
Clayout_attributes
Copacity_point
►Ccolor_map_legend
Clayout_attributes
►Ccolor_map_reader
Cidentifier_config
Ccolor_map_writer
►Ccolor_selector
Clayout_attributes
Cselector_handle
Cgizmo
Cnavigator
►Coverlay
Cgui_options_t
►Cperformance_monitor
Clayout_attributes
Cplane
Cthemed_canvas_overlay
Ctransformation_gizmo
►Naudio
COALContext	This class provides easy sample loading, device enumeration and error retrieval
COALListener	This class models the single OpenAL listener
COALSoundFormat	Simple descriptor for sounds that can be played back in OAL
COALSource	This class describes a sound source in the scene
►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
►Ndefines
Cstatic_assert_test
CSTATIC_ASSERTION_FAILURE
CSTATIC_ASSERTION_FAILURE< true >
►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
Cslab_render_style_gui_creator
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 > >
►Nmath
Cadjacency_list	A graph represented in an adjacency list
Cbresenham_traverser
Ccamera	Extend distorted pinhole with external calibration stored as a pose matrix
Ccontrol_point_container
Cdiag_mat	A diagonal matrix type which internally stores the elements on the main diagonal in a vector
Cdistorted_pinhole	Pinhole camera including distortion according to Brown-Conrady model
Cdistorted_pinhole_types	Common type declarations used by distorted_pinhole class that are independent of the template parameter
Cedge
Cfibo_heap	A fibonacci heap
Cfmat	Matrix of fixed size dimensions
Cfvec	A vector with zero based index
Cinterpolator
Cinterval	The interval template represents a closed interval of two numbers, i.e
Clow_tri_mat
Cmat	A matrix type (full column major storage) The matrix can be loaded directly into OpenGL without need for transposing!
Cmfunc	Interface class for multivariate function with two template arguments:
Cperm_mat	Permutation matrix type
Cpiecewise_linear_interpolator
Cpiecewise_nearest_interpolator
Cpinhole	Class to store and use a pinhole camera model without distortion but with support for skew and different focal lengths in x and y direction
Cqem	Dimension independent implementation of quadric error metrics
Cquaternion	Implements a quaternion
Crandom	High quality random number generator, which is a little bit slower than typical random number generators but with a period about 3.138 x 10^57
Cray	This class defines a template for n-dimensional rays with arbitrary data type defined by origin and direction
Cray< T, 3 >	Partial specialization of ray class for 3 dimensions
Cregister_sparse_les_factory	Helper template to register a sparse les solver
Crigid_transform	Implementation of a rigid body transformation with a quaternion and a translation vector
Csparse_les	Interface for implementations of solvers for sparse linear systems of the form A * x = b with a square matrix A
Csparse_les_factory	Factory class for sparse linear system solvers
Csparse_les_factory_impl	Implementation of factory class for sparse linear system solvers
Csparse_mat
Cstep_iterator
Cthin_hyper_plate_spline	A thin hyperplate spline which represents 3d deformations 3d extension of the thin plate spline
Cthin_plate_spline	A thin plate spline which represents 2d deformations See Fred L
Ctri_diag_mat	Tridiagonal matrix (square)
Cunion_find	A union find data structure
CUnsymmeig
Cup_tri_mat
Cv2_func	Specialization of a multivariate function to two independent variables, which only reimplements the method get_nr_independent_variables
Cv3_func	Specialization of a multivariate function to three independent variables, which only reimplements the method get_nr_independent_variables
Cvec	A column vector class
Cvertex
Cweighted_edge
►Nmedia
►Nfont	Namespace for font support
Cfont	Interface class for fonts. Construct font with the find_font function
Cfont_face	Interface class for different faces of a font, which can be constructed from a font
Cfont_server	Methods to create and search for fonts
►Nillum
Clight_source	>simple class to hold the properties of a light source
Cobj_material	>extension of a phong material with support for texture mapped color channels
Cphong_material	>simple class to hold the material properties of a phong material
Csurface_material	Simple class to hold the material properties of a phong material
Ctextured_surface_material	Simple class to hold the material properties of a phong material
►Nimage	Namespace for image processing
Cabst_image_reader	Abstract interface for image readers
Cabst_image_writer	Abstract interface for image readers
Cbmp_reader	Implements the image reader interface for bmp files
Cbmp_writer	Implements the image writer interface for bmp files
Cimage
Cimage_reader	Image reader chooses a specific reader automatically based on the extension of the given file name
Cimage_writer	Image writer chooses a specific writer automatically based on the extension of the given file name
Creader_listener	Interfaces that allows to listen to registration events
Cwriter_listener	Interfaces that allows to listen to registration events
►Nmesh
Cadaptive_skinned_mesh	Extension of dynamic_mesh that supports regression of joint locations from shaped mesh as well as pose dependent shape corrections for which the entries of the joint rotation matrices are used
Calways_valid
Cc_slice_info	Data structure for the information that is cached per volume slice by the cuberille algorithm
CCELL_ENTRY
Ccell_info	Information stored per cell
►Cconvex_polyhedron	Simple mesh templated with per vertex position and texture coordinates and per face plane
Cvertex_type	Type of a vertex
Cconvex_polyhedron_base
Ccuberille	Class used to perform the marching cubes algorithm
Cdc_slice_info	Data structure for the information that is cached per volume slice
Cdual_contouring	Class used to perform the marching cubes algorithm
►Cdynamic_mesh	The dynamic_mesh provides interpolation between several blend shapes of a mesh
Cblend_shape	Captures where and how the blandshape data is stored
Cequal
Cface_info	Simple structure to describe a face
Cgreater_equal
Cgroup_info	Simple structure to describe a group
Cline_info	Simple structure to describe a line
Cmarching_cubes	Class used to perform the marching cubes algorithm
Cmarching_cubes_base	Class used to perform the marching cubes algorithm
Cnot_max_valid
Cnot_nan_valid
Cobj_loader_generic	Implements the virtual interface of the obj_reader and stores all read information
Cobj_reader_base	Base class for obj reader with implementation that is independent of coordinate type
Cobj_reader_generic	Implements the pure reading of an obj file and calls virtual callback functions to allow a derived class to handle the read information
Csimple_mesh	Simple_mesh class is templated over the coordinate type that defaults to float
Csimple_mesh_base	Coordinate type independent base class of simple mesh data structure that handles indices and colors
Csimple_mesh_obj_reader
Cslice_info	Data structure for the information that is cached per volume slice
Cstreaming_mesh	Class used to perform the marching cubes algorithm
Cstreaming_mesh_callback_handler	Pure abstract interface to handle callbacks of a streaming mesh
►Nvideo	Namespace for image processing
Cabst_video_reader	Abstract interface for a video reader
Cabst_video_writer	Abstract interface for video writers
Cvideo_reader	Video reader chooses a specific reader automatically based on the extension of the given file name
Cvideo_reader_listener	Interfaces that allows to listen to registration events
Cvideo_writer	Image writer chooses a specific writer automatically based on the extension of the given file name
Cvideo_writer_listener	Interfaces that allows to listen to registration events
►Nvolume
Cfile_organisation_info
Coctree_file_organisation_info
Cooc_sliced_volume	Ooc_sliced_volume data structure allows random access to a volume that is stored as per slice file on disk
Cslice_file_organisation_info
Csliced_volume_info
Ctile_file_organisation_info
Cvolume
Cvolume_info
Cvoxel_file_info
Cabst_color_storage	Interface for color storage of different internal types
Calpha_model_traits
Calpha_model_traits< NO_ALPHA >
Calpha_reference	Captures reference to alpha component of color
Calpha_reference< T, NO_ALPHA >	Specialize for color types without alpha where reference is to static dummy alpha
Caxis_aligned_box	An axis aligned box, defined by to points: min and max
Ccolor	Represent a color with components of given type and color and alpha model as specified
Ccolor_base	Minimal data interface for color used to implement conversion
Ccolor_model_traits
Ccolor_model_traits< LUM >
Ccolor_one
Ccolor_one< double >
Ccolor_one< float >
Ccolor_storage	Template implementation of color storage model
Ccolor_storage_traits	Traits struct used to derive color type (need to be declared on namespace level for specialization)
Ccolor_storage_traits< color< float, RGB > >
Ccolor_storage_traits< color< float, RGB, OPACITY > >
Ccolor_storage_traits< color< unsigned char, RGB > >
Ccolor_storage_traits< color< unsigned char, RGB, OPACITY > >
Ccolored_model	Coordinate type independent base class of simple mesh data structure that handles indices and colors
Cconst_alpha_reference	Captures reference to alpha component of color
Cconst_alpha_reference< T, NO_ALPHA >	Specialize for color types without alpha where reference is to static dummy alpha
Cextinction_alpha_interface	Extinction_alpha_interface adds access function to the opacity, where write access is only granted for an OPACITY-alpha
Cextinction_alpha_interface< color< T, cm, am > >	Read only implementation of extinction alpha interface including automatic conversion
Cextinction_alpha_interface< color< T, cm, EXTINCTION > >	Read and write access implementation of extinction alpha interface
Cfourcc	Fourcc ids as used in the riff format to identify chunks
Chls_color_interface	Hls_color_interface adds access function to the H, L, and S-channels of the color, where write access is only granted for an HLS-color
Chls_color_interface< color< T, cm, am > >	Read only implementation of hls color interface including automatic conversion
Chls_color_interface< color< T, HLS, am > >	Read and write access implementation of hls color interface
Copacity_alpha_interface	Opacity_alpha_interface adds access function to the opacity, where write access is only granted for an OPACITY-alpha
Copacity_alpha_interface< color< T, cm, am > >	Read only implementation of opacity alpha interface including automatic conversion
Copacity_alpha_interface< color< T, cm, OPACITY > >	Read and write access implementation of opacity alpha interface
Cplane	A plane of arbitrary dimension stored as a homogeneous vector that defines the coefficients of the plane equation
Cray	A simple ray data structure for arbitrary dimensions
Crgb_color_interface	Rgb_color_interface adds access function to the R, G, and B-channels of the color, where write access is only granted for an RGB-color
Crgb_color_interface< color< T, cm, am > >	Read only implementation of rgb color interface including automatic conversion
Crgb_color_interface< color< T, RGB, am > >	Read and write access implementation of rgb color interface
Criff_handler	Callback handler passed to riff reader
Criff_reader	Reader class for riff files such as .ani or .avi
Csphere	A sphere data structure
Ctransparency_alpha_interface	Transparency_alpha_interface adds access function to the opacity, where write access is only granted for an OPACITY-alpha
Ctransparency_alpha_interface< color< T, cm, am > >	Read only implementation of transparency alpha interface including automatic conversion
Ctransparency_alpha_interface< color< T, cm, TRANSPARENCY > >	Read and write access implementation of transparency alpha interface
Cxyz_color_interface	Xyz_color_interface adds access function to the X, Y, and Z-channels of the color, where write access is only granted for an XYZ-color
Cxyz_color_interface< color< T, cm, am > >	Read only implementation of xyz color interface including automatic conversion
Cxyz_color_interface< color< T, XYZ, am > >	Read and write access implementation of xyz color interface
►Nos
Ccondition_mutex	A mutex that can wake up other threads by signals sent when a condition is fulfilled
Cdisplay	Display class gives access to the display modes of all available displays
Cdisplay_configuration	Display configuration combines a display mode and the position of the display on the virtual screen
Cdisplay_mode	Display mode describes a valid setting of the display parameters
Cdisplay_position	Display position gives the signed x and y coordinates on the virtual screen
Cfunction_thread
Chttp_request	Structure that contains all input and output parameters of a http request
Cmutex	A simple mutex (mutual exclusion) for solving thread synchronisation problems
Cnamed_pipe_input_thread
Cnamed_pipe_output_thread	Queued thread class that manages a named pipe
Cpipe_input_thread
Cpipe_output_thread	Queued thread class that manages a child process connecting to its input pipe
Cqueued_input_thread	Base class for system command output pipe or named pipe threads including a queue of data blocks, a vector storing smaller data packages and a separate thread
Cqueued_output_thread	Base class for system command input pipe or named pipe threads including a queue of data blocks and a separate thread
Csocket	Base class for all sockets
Csocket_client	Client socket
Csocket_server	Socket server allows to be connected to
Cthread	Thread class implementation that uses pthreads internally
Cweb_server	Simple interface for a web server
Cweb_server_provider	Interface for a html_server provider
Cweb_server_provider_registration	Template to facilitate registeration of a web server provider
Cweb_server_thread	Web server interface that runs in its own thread
►Nplot
Cattribute_source	Store source of a single plot attribute (one coordinate axis or one float attribute)
Cattribute_source_array	Struct that manages attribute sources and corresponding gpu objects per subplot
Caxis_config	Configuration information stored per domain axis
Cdomain_config
Cmapped_opacity
Cmapped_rgb
Cmapped_rgba
Cmapped_size
Cplot2d	The plot2d class draws 2d plots with potentially several sub plots of different chart types
Cplot2d_config	Extend common plot configuration with parameters specific to 2d plot
Cplot3d	The plot3d class draws 2d plots with potentially several sub plots of different plot configuration
Cplot3d_config	Extend common plot configuration with parameters specific to 2d plot
►Cplot_base	Base class for plot2d and plot3d, which can have several sub plots each
Clabel_info	Render information stored per label
Ctick_batch_info
Cplot_base_config	Plot independent configuration parameters of one sub plot in a 2d or 3d plot
Csample_access
Ctick_config	Tickmark configuration of one tickmark type
Cvecn_sample_access
►Nppp
Ccommand_info
Ccommand_token
Cexpression_processor
Cexpression_token
Cfunc_type
Cnamespace_info	For each namespace the following information is stored
Coperator_info
Cph_processor	Pre header processor parses a pre header file and converts it to a header file or uses the information from parsing to transform a template file to a header file
Cvariant
►Nreflect	In this namespace reflection of types is implemented
►Ncompatibility
Cget_member_dispatch
Cget_member_dispatch< true, T, Q >
Cset_member_dispatch
Cset_member_dispatch< true, T, Q >
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 > >
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
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
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 handles a shader program and position / color attribute
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_config	Globally unique shader config is registered by default when the cgv library is used
►Cshader_library	Shader library that handles shader loading
Cshader_info
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
Cslab_render_style
Cslab_render_style_reflect
Cslab_renderer	Renderer that supports point splatting
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
►Nsignal
Cabst_managed_list
Cbool_combiner	Base class for signals that combine the boolean result of the attached functors with boolean and/or operations
Ccallback_stream	Connect to the write signal of the callback stream in order to process all text written to the stream
Ccallback_streambuf	Simple implementation of a streambuf that sends all written text to the write signal that is referenced from the possessing stream
Cmanaged_list
►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 >
►Nctrl
Cif_	If traits selects a type from a given condition type which should be cond::true_type or cond::false_type
Cif_< false, then_type, else_type >
►Nfunc	Namespace for functions that act on types
►NMakeConst
Cmake_const_impl
Cmake_const_impl< T & >
►NPromote
Cpromotion_rank	Promote rank template defines a rank for each type which is used to automatically detect the promoted type of a pair of types
Cpromotion_rank< bool >
Cpromotion_rank< char >
Cpromotion_rank< double >
Cpromotion_rank< float >
Cpromotion_rank< int >
Cpromotion_rank< long >
Cpromotion_rank< short >
Cpromotion_rank< unsigned char >
Cpromotion_rank< unsigned int >
Cpromotion_rank< unsigned long >
Cpromotion_rank< unsigned short >
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
►Ndetail
Cdispatch_type_name
Cdispatch_type_name< T, false >
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 >
►Ntraits
Cmax	Max traits defines for each type in the static const member value, what the maximum value is
Cmax< int16_type >
Cmax< int32_type >
Cmax< int64_type >
Cmax< int8_type >
Cmax< uint16_type >
Cmax< uint32_type >
Cmax< uint64_type >
Cmax< uint8_type >
Cmax_fct	Max_fct traits provides a static function returning the maximal value of a type
Cmax_fct< double >
Cmax_fct< float >
Cmember_pointer	Traits class that allows to check for member pointer types and to query the type this_type of the class and member_type of the member
Cmember_pointer< M T::* >
Cmin	Min traits defines for each type in the static const member value, what the minimum value is
Cmin< char >
Cmin< int >
Cmin< long >
Cmin< short >
Cmin< unsigned char >
Cmin< unsigned int >
Cmin< unsigned long >
Cmin< unsigned short >
Cmin_fct	Min_fct traits provides a static function returning the minimal value of a type
Cmin_fct< double >
Cmin_fct< float >
Cone	One traits defines for each type in the static const member value, what the value of one is
Cone_fct	One_fct traits provides a static function returning the value of a type that is interpreted as one
Cone_fct< double >
Cone_fct< float >
Czero	Zero traits defines for each type in the static const member value, what the zero value is
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
►Nfile
CFileInfo
Cbig_binary_file	Class to handle files with very large sizes (>=2GB) hiding the ugly win32 api calls
Cdate
Cdate_time
Cguid	Simple struct to represent guid
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
►Nxml
CFindElementByNameVisitor	Finds a tinyxml2::XMLElement by name
▼Nfx
►Ngltf
►Ndetail
CDataContext
►CAccessor
►CSparse
CIndices
CValues
►CAnimation
►CChannel
CTarget
CSampler
CAsset
CBuffer
CBufferView
►CCamera
COrthographic
CPerspective
CDocument
CImage
Cinvalid_gltf_document
►CMaterial
CNormalTexture
COcclusionTexture
CPBRMetallicRoughness
CTexture
CMesh
CNeverEmpty
CNode
CPrimitive
CReadQuotas
CSampler
CScene
CSkin
CTexture
▼Ngamepad
Cdevice_info	Information provided per gamepad device
Cdriver_info	Information structure for drivers
Cdriver_registry	Use this template to register your own driver
Cgamepad_driver	Interface class for gamepad drivers, when implementing your driver, provide a constructor with a single options argument of type std::string
Cgamepad_state	See https://upload.wikimedia.org/wikipedia/commons/2/2c/360_controller.svg for an explanation of the positions in the state
▼Nnes
Cbasic_pipe_istream
Cbasic_pipe_ostream
▼Nstl_reader
CStlMesh	Convenience mesh class which makes accessing the stl data more easy
▼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
Ccfg_reg_type
CCondition
Cconfig_file_view
Cconfig_view
Cconfig_view< bool >
Cconfig_view< std::string >
Cenum_aware_type_name
Cenum_aware_type_name< T, true >
Cenum_config_view
Cgui_config_file_driver
Cgui_config_file_observer
Cregister_driver_and_object
Crender_config_registration
Cshader_config_registration
Ctoken
Cvr_emulated_kit
Cvr_emulator
Cvr_test
Cvr_view_interactor	Extends the stereo view interactor for vr support