DLODObject.cpp

#include "DLODObject.h"

DLODObject::DLODObject (RawObject * raw): GraphicalObject (raw)
{
        num_levels = 0;
        AddLevel (raw, 0.0f);
}

DLODObject::~DLODObject ()
{
        // do nothing
}

void DLODObject::Draw (int time, Camera * camera, Camera * monitor, bool show_bounding_volume, int culling_mode, bool level_of_detail)
{
        Position pos, camera_pos;
        int culling_result;
        bool rotation;
        int level;

        Point origin;
        Point absolute_pos = {0.0f, 0.0f, 0.0f};
        float mod[16];
        float * inv;
        float camera_dist;

        // return if position is not defined for the current time
        if (!(position->IsDefined (time))) return;

        // retrieve positions
        pos = position->GetPosition (time);
        camera_pos = camera->position->GetPosition (time);

        // check if we have to rotate
        rotation = position->HasStaticRotation ();

        // translate and rotate according to the actual position
        ApplyTransformation (pos, rotation);

        // cull the object against the viewing frustum
        culling_result = CullObject (camera, monitor, culling_mode, show_bounding_volume);

        // determine level of detail and draw the object if not outside
        if (culling_result != C_OUTSIDE)
        {
                if (level_of_detail)
                {
                        glGetFloatv (GL_MODELVIEW_MATRIX, mod);
                        if (monitor == NULL)
                        {inv = camera->GetInverseView ();}
                        else
                        {inv = monitor->GetInverseView ();}

                        origin.x = mod[12];
                        origin.y = mod[13];
                        origin.z = mod[14];
                        Geometry::VectorMultiply (inv, origin, absolute_pos);

                        camera_dist = (camera_pos.x -  absolute_pos.x) * ( camera_pos.x -  absolute_pos.x) +
                                                  (camera_pos.y -  absolute_pos.y) * ( camera_pos.y -  absolute_pos.y) +
                                                  (camera_pos.z -  absolute_pos.z) * ( camera_pos.z -  absolute_pos.z);

                        for (level = 0; level < MAX_LEVEL; level++)
                        {
                                if (camera_dist > distances[level] && camera_dist < distances[level+1])
                                {
                                        raw_obj[level]->Draw ();
                                        break;
                                }
                        }
                }
                else
                {
                        raw_object->Draw ();
                }
        }

        // undo rotation and translation
        UndoTransformation (pos, rotation);
}

void DLODObject::AddLevel (RawObject * next_level, float distance)
{
        if (num_levels == MAX_LEVEL) 
        {printf ("Only %d levels of detail allowed per object!\n", MAX_LEVEL); return;}
        
        raw_obj[num_levels] = next_level;
        distances[num_levels] = distance * distance;
        num_levels++;
        distances[num_levels] = INFINITE;
}

DLODObject * DLODObject::GetClone ()
{
        DLODObject * clone = new DLODObject (raw_object);

        for (int index = 0; index < num_levels; index++)
        {clone->AddLevel (raw_obj[index], sqrt (distances[index]));}

        return clone;
}

void DLODObject::ComputeBoundingRadius ()
{
        bounding_radius = raw_object->GetBoundingRadius ();
}

void DLODObject::ComputeBoundingBox ()
{
        bounding_box = raw_object->GetBoundingBox ();
}

void DLODObject::PrintToConsole ()
{
        printf ("Number of Levels: %d, infinity: %g\n", num_levels, MY_INFINITY);
        for (int index = 0; index < num_levels; index++)
        {printf ("Distance: %g\n", distances[index]);}
}

---