source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoLodManager.cpp @ 1309

/*==========================================================================
 *      (C) 2006 Universitat Jaume I
 *==========================================================================
 *      PROYECT:        GAME TOOLS
 *==========================================================================
 *      CONTENT:
 *
 *
 *      @file   GeoLodManager.cpp
 *===========================================================================*/

#include "GeoLodManager.h"
#include "GeoLodObject.h"
#include <algorithm>
/*
namespace Geometry
{


        class lodobj_idpos_node_t
        {
        public:
                lodobj_idpos_node_t(LodObject *o):lodobj(o),must_recalculate_distance(true),dist2cam(0.0f){}
                LodObject *lodobj;
                float dist2cam; // used to index the lodobj in the other map
                bool operator < (const lodobj_idpos_node_t &o) const { return (lodobj->GetUniqueID()<o.lodobj->GetUniqueID()); }
        };
}*/

using namespace Geometry;

LodManager::LodManager(float near, float far, const Geometry::Vector3 &campos)
:targetFPS(30),camera_changed(true),camera_pos(campos),
 near_range(near),far_range(far)
{
        // make the lodobj_dists vector into a heap
        make_heap(lodobj_dists.begin(),lodobj_dists.end());
}

void Geometry::LodManager::AddLodObj(LodObject * o, const Geometry::Vector3 &p)
{
        float dist = CalculateDistToCamera(p);
        lodobj_dists.push_back(lodobj_dist_node_t(dist,o));
        push_heap(lodobj_dists.begin(),lodobj_dists.end());
//      lodobj_dists[dist] = lodobj_dist_node_t(o);
        UpdateLODObjectPos(o,p);
}


void Geometry::LodManager::UpdateLOD(void)
{
        if (!lodobj_dists.empty())
        {
                // update distances to the camera
                bool must_resort = false;
                for (std::vector<lodobj_dist_node_t>::iterator it=lodobj_dists.begin(); it!=lodobj_dists.end(); it++)
                {                       
                        lodobj_dist_node_t & node = *it;
                        if (camera_changed || node.must_recalculate_distance)
                        {
                                RecalculateDist(node);
                                must_resort=true;
                        }
                }
                if (must_resort)
                        sort_heap(lodobj_dists.begin(),lodobj_dists.end());

                // select a tree to change its LOD
        //      float random_dist = SelectRandomDistance();
        //      std::map<float,Geometry::lodobj_dist_node_t>::iterator nearest = lodobj_dists.upper_bound(random_dist);

                // the begining of the list is the greater element (greater dist)               
                lodobj_dist_node_t & node = lodobj_dists.front();
        }
        camera_changed=false;
}

void Geometry::LodManager::RecalculateDist(lodobj_dist_node_t & node)
{
        std::map<uint32,Vector3>::iterator posit = lodobj_pos.find(node.lodobj->GetUniqueID());
        assert(posit!=lodobj_pos.end());
        const Vector3 & pos = posit->second;

        node.dist2cam = CalculateDistToCamera(pos);
}


void Geometry::LodManager::UpdateCamera(const Geometry::Vector3 &p)
{
        camera_pos = p;
        camera_changed = true;
}

void Geometry::LodManager::UpdateLODObjectPos(LodObject *o, const Geometry::Vector3 &p)
{
        lodobj_pos[o->GetUniqueID()] = p;
}


float Geometry::LodManager::CalculateDistToCamera(const Geometry::Vector3 &p) const
{
        return camera_pos.dotProduct(p);
}

float Geometry::LodManager::SelectRandomDistance(void) const
{
        float linear_01 = (float)rand()/(float)RAND_MAX;
        float exp_01 = linear_01*linear_01;
        float real_dist = exp_01*near_range + (1.0f-exp_01)*far_range;
        return real_dist;
}