| Cblub::procedural::voxel::config::accessor< configType > | |
| ►Carchive_exception | |
| Cportable_binary_iarchive_exception | |
| Cportable_binary_oarchive_exception | |
| ►Carray | |
| Cblub::array< T, N > | |
| Cblub::axisAlignedBox | |
| Cblub::axisAlignedBoxTemplate< vector3Type > | |
| ►Cblub::axisAlignedBoxTemplate< vector3int32 > | |
| Cblub::axisAlignedBoxInt32 | |
| ►Cbasic_binary_iprimitive | |
| Cportable_binary_iarchive | |
| ►Cbasic_binary_oprimitive | |
| Cportable_binary_oarchive | |
| Cblub::colour | |
| ►Ccommon_iarchive | |
| Cportable_binary_iarchive | |
| ►Ccommon_oarchive | |
| Cportable_binary_oarchive | |
| ►Cblub::procedural::voxel::config | |
| Cconfig | |
| Cconfig | |
| Cconfig | |
| Cblub::octree::container< dataType > | |
| Cblub::procedural::voxel::config::container< configType > | |
| Cblub::octree::container< t_receiver > | |
| Cblub::octree::container< t_sync > | |
| ►Cblub::procedural::voxel::data | Default voxel. Contains an 8-bit interpolation value. Replace/derive it and set it tho the voxel classes by template. Watchout when you reimplement a isMax() and isMin(). voxel-container doesnt save these voxel for memory-optimisation. Only return true on isMax() / isMin() if your are able to restore the state by setMin() / setMax(). setMin() has to to have the same results like the default contructor |
| Cdata | |
| Cblub::procedural::voxel::simple::container::utils::database< configType > | |
| Cblub::dateTime | |
| Cblub::async::deadlineTimer | |
| ►Cdeque | |
| Cblub::deque< elementType > | |
| Cblub::procedural::voxel::simple::container::base< configType >::editTodo | The editTodo struct holds the edit information, for the dispatcher. A primitive buffer for the paramters delivered by editVoxel() |
| ►Cenable_shared_from_this | |
| ►Cblub::enableSharedFromThis< classType > | |
| Cblub::procedural::voxel::tile::base< classType > | The base class gets derived by every class in the namespace tile::*. Never instance this class and derived classes without a shared pointer |
| ►Cblub::enableSharedFromThis< accessor< configType > > | |
| ►Cblub::procedural::voxel::tile::base< accessor< configType > > | |
| Cblub::procedural::voxel::tile::accessor< configType > | The accessor class caches all voxel needed by tile::surface for an extremly optimized and fast calculation for the same. This class looks up all voxel needed for the modified marching cubes and if lod is enabled 6*arrays for every side of the cube (transvoxel). See http://www.terathon.com/voxels/ and http://www.terathon.com/lengyel/Lengyel-VoxelTerrain.pdf |
| ►Cblub::enableSharedFromThis< base< configType > > | |
| ►Cblub::procedural::voxel::edit::base< configType > | Base class of all edits. Has various features you may wanna overwrite. If you want to write your own edit overwrite the method calculateOneVoxel() or calculateVoxel(). For most flexibility override calculateVoxel(). Because base derives enableSharedFromThis you have to write a create method that creates a shared_ptr of the class |
| Cblub::procedural::voxel::edit::axisAlignedBox< configType > | Insertes/removes voxels that are included in an blub::axisAlignedBox. Always axis-aligned - use box if you want to rotate |
| Cblub::procedural::voxel::edit::noise< configType > | The noise class generates a random terrain using simplex noise http://en.wikipedia.org/wiki/Simplex_noise . Original code http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java |
| ►Cblub::procedural::voxel::edit::sphere< configType > | The sphere class creates an interpolated voxel-sphere |
| CcustomEdit< configType > | |
| ►Cblub::enableSharedFromThis< base< voxelType > > | |
| ►Cblub::procedural::voxel::edit::base< voxelType > | |
| Cblub::procedural::voxel::edit::box< voxelType > | Voxel-generator defined by a transform-able-box |
| Cblub::procedural::voxel::edit::mesh< voxelType > | Convertes a mesh to voxel. Fills a boost::geometry::index::rtree with the polygons. Initialization O(numTriangles). Voxel-generation O(numVoxel) |
| ►Cblub::enableSharedFromThis< container< configType > > | |
| ►Cblub::procedural::voxel::tile::base< container< configType > > | |
| Cblub::procedural::voxel::tile::container< configType > | The container class contains an array of voxel. The amount of voxel per tile is voxelLength^3. The class counts how many voxel are max and how many are min. if all voxel are min or max the class simple::container::base doesnt save them. Additionally it saves an axisAlignedBox which describes the bounds of the voxel that changed |
| ►Cblub::enableSharedFromThis< identifier > | |
| Cblub::sync::identifier | |
| ►Cblub::enableSharedFromThis< renderer< configType > > | |
| ►Cblub::procedural::voxel::tile::base< renderer< configType > > | |
| ►Cblub::procedural::voxel::tile::renderer< configType > | The renderer class contains information if a tile::surface should get rendered and how it should get rendered. Class must get derived by your render-engine. In the derived class convert the vertices/indices to your hardware/software render engine. (Most likely to a hardwarebuffer) |
| ►COgreTile< configType > | The OgreTile class converts the resulting vertices and indices of the voxel-terrain to the Ogre Hardwarebuffer. The class handles setVisible() when a tile gets cutted because it's too near or too far or a cracks has to get closed. The results of the transvoxel-algorithm for closing the cracks between the lod-tiles get set to submeshes. Every tile contains a Ogre::Mesh, a Ogre::Entity and a Ogre::SceneNode. For more information on how to use ogre3d see http://www.ogre3d.org/docs/manual/ and http://www.ogre3d.org/docs/api/1.9/ |
| CcustomOgreTile< configType > | |
| ►Cblub::enableSharedFromThis< surface< configType > > | |
| ►Cblub::procedural::voxel::tile::base< surface< configType > > | |
| ►Cblub::procedural::voxel::tile::surface< configType > | The surface class convertes a tile::accessor to an iso-surface. Call this class by one thread at a time. Uses marching cubes and transvoxel for surface-generation. http://www.terathon.com/voxels/ To understand this class and algos please read Eric Lengyel’s Dissertation: http://www.terathon.com/lengyel/Lengyel-VoxelTerrain.pdf . If you got a custom voxel, that effects the resulting surface derive this class and reimplement vertexGotCreated() and vertexGotCreatedLod(). Private methods are undocumentated because they simply implement the code described in Eric Lengyel’s Dissertation |
| CcustomSurfaceTile< configType > | |
| ►CFrameListener | |
| CHandler | Initialises Ogre3d (graphics) and OIS (input) and derives their callbacks. Class shall simplify the examples |
| Cblub::geometry< vertexType > | |
| Cblub::idCreator< idType > | |
| Cblub::intersection | |
| ►CKeyListener | |
| CHandler | Initialises Ogre3d (graphics) and OIS (input) and derives their callbacks. Class shall simplify the examples |
| ►Clist | |
| Cblub::list< T > | |
| Cblub::list< blub::blub::triangle > | |
| Cblub::list< boost::thread * > | |
| Cblub::list< editTodo > | |
| Cblub::list< vertexType > | |
| ►Cmap | |
| Cblub::map< S, T > | |
| Cblub::math | |
| ►CMouseListener | |
| CHandler | Initialises Ogre3d (graphics) and OIS (input) and derives their callbacks. Class shall simplify the examples |
| ►Cmutex | |
| Cblub::async::mutex | |
| Cblub::async::mutexLocker | |
| Cblub::serialization::nameValuePair | |
| ►Cblub::octree::container< dataType >::node | |
| Cblub::octree::container< dataType >::leaf | |
| ►Cnoncopyable | |
| ►Cblub::noncopyable | |
| ►Cblub::procedural::voxel::terrain::base< configType::t_accessor::t_simple > | |
| Cblub::procedural::voxel::terrain::accessor< configType > | The accessor class contains a custom amount of level of details of type simple::accessor |
| ►Cblub::procedural::voxel::simple::base< configType::t_accessor::t_tile > | |
| Cblub::procedural::voxel::simple::accessor< configType > | The accessor class accesses and caches voxels for the surface-calculation. It caches voxel optimized for the marching cubes algorithm. If lod is larger 0 it addionally caches voxel for the transvoxel aalgorithm |
| ►Cblub::procedural::voxel::simple::base< configType::t_container::t_tile > | |
| ►Cblub::procedural::voxel::simple::container::base< configType > | The base class is getting derived by all container classes. The class handles synchronisation and paralellisation of edits and provides several voxel-getter/setter. All methods are threadsafe, if not declared different |
| Cblub::procedural::voxel::simple::container::inMemory< configType > | The inMemory class stores all voxels in instances of tile::container and safes them in a very fast in-memory-container. Accessing a voxel-container costs O(1). The class does not save tiles that are full (container-tile returns true for isEmpty() ) or that are empty (container-tile returns true for isFull() ). Instead the class saves the state empty/full. Tiles that are full or empty dont produce a surface |
| ►Cblub::procedural::voxel::terrain::base< configType::t_renderer::t_simple > | |
| Cblub::procedural::voxel::terrain::renderer< configType > | The renderer class contains a custom count of simple::renderer for level of detail |
| ►Cblub::procedural::voxel::simple::base< configType::t_renderer::t_tile > | |
| Cblub::procedural::voxel::simple::renderer< configType > | The renderer class handles the correct rendering of a lod. Including renderdistance and enabling the submeshes for losing the cracks (transvoxel results). Takes the results and updates from the simple::surface and saves them into an octree. Casts signals on when to update an LOD |
| ►Cblub::procedural::voxel::terrain::base< configType::t_surface::t_simple > | |
| Cblub::procedural::voxel::terrain::surface< configType > | The surface class contains a custom count of simple::surface for level of detail |
| ►Cblub::procedural::voxel::simple::base< configType::t_surface::t_tile > | |
| Cblub::procedural::voxel::simple::surface< configType > | The surface class convertes accessor-tiles to surface-tiles. In between polygons get calculated by the surface-tile |
| Cblub::procedural::voxel::terrain::base< sharedPointer< procedural::voxel::tile::accessor< voxelType > > > | |
| ►Cblub::procedural::voxel::simple::base< sharedPointer< procedural::voxel::tile::accessor< voxelType > > > | |
| Cblub::sync::voxel::accessor::multipleTiles::receiver< voxelType > | |
| Cblub::procedural::voxel::edit::base< voxelType > | |
| ►Cblub::procedural::voxel::simple::base< voxelType::t_container::t_tile > | |
| ►Cblub::procedural::voxel::simple::container::base< voxelType > | |
| ►Cblub::procedural::voxel::simple::container::inMemory< voxelType > | |
| Cblub::procedural::voxel::simple::container::database< voxelType > | |
| ►Cblub::async::dispatcher | |
| Cblub::async::updater | |
| Cblub::procedural::voxel::edit::base< configType > | Base class of all edits. Has various features you may wanna overwrite. If you want to write your own edit overwrite the method calculateOneVoxel() or calculateVoxel(). For most flexibility override calculateVoxel(). Because base derives enableSharedFromThis you have to write a create method that creates a shared_ptr of the class |
| Cblub::procedural::voxel::simple::base< tileType > | The base class gets derived by every class in the namespace simple::*. It represends one level of detail. If you dont need a terrain but a voxel-surface use a class in this namespace |
| ►Cblub::procedural::voxel::terrain::base< simpleType > | The base class gets derived by every class in the namesapce terrain. It holds various level of details, always of type procedural::voxel::simple::base |
| Cblub::sync::voxel::accessor::terrain::receiver< voxelType > | |
| Cblub::vector3int32map< dataType > | |
| Cblub::vector3int32map< typename t_base::t_utilsTile > | |
| ►Cpair | |
| Cblub::pair< A, B > | |
| Cblub::plane | |
| Cblub::quaternion | |
| Cblub::ray | |
| Cblub::sync::receiver | |
| Cblub::rectangle | |
| CRegularCellData | |
| ►Cblub::procedural::voxel::config::renderer< configType > | |
| Cconfig::renderer< configType > | |
| Cconfig::renderer< configType > | |
| Cconfig::renderer< configType > | |
| Cblub::octree::search< containerType > | |
| Cblub::sync::voxel::accessor::terrain::sender< voxelType, identifierType > | |
| Cblub::sync::sender< syncType, receiverType > | |
| ►Cblub::sync::sender< vector3int32, sharedPointer< identifierType > > | |
| Cblub::sync::voxel::accessor::multipleTiles::sender< voxelType, identifierType > | |
| ►Cseverity_logger_mt | |
| Cblub::log::logger | |
| ►Cshared_mutex | |
| Cblub::async::mutexReadWrite | |
| ►Cshared_ptr | |
| Cblub::sharedPointer< T > | |
| Cblub::sharedPointer< edit::base< t_config > const > | |
| Cblub::sharedPointer< t_voxelAccessor > | |
| Cblub::sharedPointer< tileType > | |
| ►Cshared_ptr_helper | |
| Cportable_binary_iarchive | |
| ►Csignal | |
| Cblub::signal< T > | |
| Cblub::signal< void()> | |
| Cblub::signal< void(blub::real)> | |
| Cblub::signal< void(bool left)> | |
| Cblub::signal< void(OIS::KeyEvent, bool pressed)> | |
| Cblub::signal< void(real)> | |
| Cblub::signal< void(state *st)> | |
| Cblub::signal< void(t_receiver, t_sync)> | |
| Cblub::signal< void(t_receiverIdentifierPtr, t_tileDataPtr)> | |
| Cblub::sphere | |
| Cblub::state | |
| Cblub::async::strand | |
| ►Cstring | |
| Cblub::string | |
| ►Cblub::procedural::voxel::config::surface< configType > | |
| Cconfig::surface< configType > | |
| Cblub::log::system | |
| Cblub::procedural::voxel::simple::container::utils::tile< tileType > | The tile class contains a state and the data itself. For memory optimization no data gets saved if state is full or empty |
| Cblub::timer | |
| Cblub::transform | |
| CTransitionCellData | |
| Cblub::triangle | |
| Cblub::triangleVector3 | |
| ►Cunordered_map | |
| Cblub::hashMap< S, T, H, P, A > | |
| Cblub::hashMap< t_data, t_leafPtr > | |
| Cblub::hashMap< t_data, vector3int32 > | |
| Cblub::hashMap< t_receiver, t_syncList > | |
| Cblub::hashMap< t_receiver, vector3 > | |
| Cblub::hashMap< t_sync, t_receiverList > | |
| Cblub::hashMap< t_sync, vector3 > | |
| Cblub::hashMap< t_tileId, t_tileDataPtr > | |
| Cblub::hashMap< t_tileId, t_tilePtr > | |
| Cblub::hashMap< t_tileId, t_utilsTile > | |
| Cblub::hashMap< vector3int32, t_leafPtr > | |
| Cblub::hashMap< vector3int32, t_tilePtr > | |
| ►Cunordered_multimap | |
| Cblub::hashMapMulti< S, T, H, P, A > | |
| ►Cunordered_set | |
| Cblub::hashList< Key, Hash, KeyEqual, Allocator > | |
| Cblub::hashList< dataType > | |
| Cblub::hashList< t_receiverIdentifierPtr > | |
| ►Cvector | |
| Cblub::byteArray | |
| Cblub::vector< T > | |
| Cblub::vector< real > | |
| Cblub::vector< scopedPointer< t_simple > > | |
| Cblub::vector< t_data > | |
| Cblub::vector< t_multipleTilesPtr > | |
| Cblub::vector< t_tree * > | |
| Cblub::vector< t_voxel > | |
| Cblub::vector< typename t_config::t_index > | |
| Cblub::vector< typename t_config::t_vertex > | |
| Cblub::vector< uint8_t > | |
| Cblub::vector2 | |
| Cblub::vector2Template< valueType, valueDefault > | |
| Cblub::vector3 | |
| Cblub::vector3Template< valueType, valueDefault > | |
| Cblub::vector3Template< int32, 0 > | |
| ►Cblub::procedural::voxel::vertex | |
| Cvertex | |
1.8.8
