source: GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoLodManager.h @ 2153

/*==========================================================================
 *      (C) 2006 Universidad Jaime I de Castellón
 *==========================================================================
 *      PROYECT:        GAME TOOLS
 *==========================================================================*/
/*      CONTENT:
 *
 *
 *      @file   GeoLodManager.h
 *==========================================================================*/

#ifndef _GEOLODMANAGER
#define _GEOLODMANAGER

#include "GeoVector3.h"
#include "GeoLodObject.h"

namespace Geometry
{
        class NodeContainer;    
        class lodobj_node_t;

        /// This class implements a LOD manager for level of detail objects such as (LodStrips and LodTree objects)
        /** This class automatically manages the level of detail of all objects added to the lod manager. 
                The key idea is to minimize the number of real changes in levels of detail because they consume 
                CPU and that can cause stalls and CPU bottlenecks in massive applications. The LodManager solves
                this issue by deciding which objects have to change the level of detail and which objects can just 
                share an already calculated one. The system also decides whether an object can chage its level of 
                detail or it is not needed because it would take not effect on the performance. This drastically 
                reduces the CPU usage. in a completely transparent way to the user. */

        class LodManager
        {       
        public:
                /// LodManager constructor
                /** Constucts a LodManager object from the following parameters:
                        - The near and far distances that define the active LOD range.
                        - The initial camera position
                        - The number of LOD slots in the snapshot list (this parameter is optional)
                */
                LodManager(Real near, Real far, const Geometry::Vector3 &campos, int numslots=10);

                /// class destructor
                ~LodManager(void);

                /// Adds a new LOD object (a LodStrips or a LodTree object)
                /** When an object is added to the system,  its level of detail is automatically managed, and the 
                        client application does not need to manually change its level of detail. 
                        The parameters needed to add an object to the system are:
                        - The class name of the object. The class name is the type of object. This is used by the system to 
                          know which objects are compatible to change the level of detail between themselves. 
                        - A reference to the LodObject itself (a LodStrips or a LodTree object).
                        - The initial position in the 3D space of the added object. */
                void AddLodObj(const std::string &name, LodObject*, const Geometry::Vector3 &);

                /// Performs all needed LOD updates
                /** This function should be called once per frame (or at some reasonable interval). 
                        Internally it performs all needed steps to change the level of detail of the objects. */
                void UpdateLOD(void);

                /// Updates the camera position
                void UpdateCamera(const Geometry::Vector3 &);

                /// Updates the position of a certain LodObject
                void UpdateLODObjectPos(LodObject*,const Geometry::Vector3 &);

                /// Set it to true to force all LOD calculations (disable the LodManager features)
                bool always_calculate_lod;

                /// if set to true, all objects will be set to their highest level of detail
                bool force_highest_lod;

        private:
                NodeContainer *lodobj_container;
                uint32 lasttime;
                bool camera_changed, node_added;
                float near_range, far_range;
                float SelectRandomDistance(void) const;
                void ChangeLOD(lodobj_node_t*,Real);
                void ReallyGoToLOD(lodobj_node_t*,Real);

                lodobj_node_t * FindMostSimilarRealLOD(const std::string &, Real desired_lod);

                void MakeDiscipleOf(lodobj_node_t *master, lodobj_node_t *disciple);
                void MakeIndependent(lodobj_node_t*);
                void RemoveDiscipleFrom(LodObject *master, LodObject *disciple);
                void UpdateDisciples(lodobj_node_t *master);
                void DeleteMeFromMyMastersDiscipleList(lodobj_node_t *);
                void ChangeMaster(lodobj_node_t *orig, lodobj_node_t *newmaster);
        };
}

#endif