Scene.cpp

#include "Scene.h"

#include "SimpleArrow.h"
#include "TerminalObject.h"


Scene::Scene ()
{
        // init members
        camera = new Camera ();
        first_object = NULL;
        first_light = NULL;
        current_light_id = GL_LIGHT0;

        // create visualization for the camera
        RawObject * arrow = new SimpleArrow (4.0f);
        arrow->SetColor (0.5f, 0.5f, 1.0f, 1.0f);
        camera_object = new TerminalObject (arrow);
}

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

void Scene::Render (int time, int culling_mode, bool level_of_detail)
{
        GraphicalObjectElem * current_object;

        glPushMatrix ();
        glLoadIdentity ();

        // set up camera
        camera->ApplyAttributes ();
        camera->ApplyPosition (time);
        camera->ComputeInverseView (time);
        
        // could be done only when attributes are applied (since the planes do not depend on position).
        camera->BuildPlanes2 ();

        // apply lights
        ApplyLights (time);

        // draw all objects that belong to the scene
        current_object = first_object;
        while (current_object != NULL)
        {
                current_object->graphical_object->Draw (time, camera, NULL, false, culling_mode, level_of_detail);
                current_object = current_object->next;
        }

        glPopMatrix ();
}

void Scene::Monitor (int time, Camera * monitor, int culling_mode, bool level_of_detail)
{
        GraphicalObjectElem * current_object;

        glPushMatrix ();
        glLoadIdentity ();

        // set up camera
        monitor->ApplyAttributes ();
        monitor->ApplyPosition (time);
        monitor->ComputeInverseView (time);

        // build planes each time anew (since they change with the position).
        camera->BuildPlanes (time);

        // apply the lights
        ApplyLights (time);

        // draw all objects that belong to the scene
        current_object = first_object;
        while (current_object != NULL)
        {
                // objects appear as if the would be rendered by the original camera
                current_object->graphical_object->Draw (time, camera, monitor, true, culling_mode, level_of_detail);
                current_object = current_object->next;
        }

        // finally, also draw the camera
        camera_object->position = camera->position;
        camera_object->Draw (time, monitor, NULL, false, C_NONE, false);        

        // and its frustum (this can done in world coordinates)
        camera->BuildPlanes (time);
        camera->DrawFrustum ();

        glPopMatrix ();
}

void Scene::CopyPosition (int time, Camera * destination)
{
        Position position;

        // copy a constant position...
        position = camera->position->GetPosition (time);
        destination->position->SetConstantPosition (position.x, position.y, position.z, position.roll, position.pitch, position.yaw);
}

void Scene::AddObject (GraphicalObject * obj)
{
        GraphicalObjectElem * current_object;

        if (first_object == NULL)
        {
                first_object = new GraphicalObjectElem;
                first_object->next = NULL;
                first_object->graphical_object = obj;
        }
        else
        {
                current_object = first_object;
                while (current_object->next != NULL) current_object = current_object->next;

                current_object->next = new GraphicalObjectElem;
                current_object->next->next = NULL;
                current_object->next->graphical_object = obj;
        }
}

void Scene::AddLight (Light * light)
{
        LightElem * current_light;
        int light_id;

        light_id = current_light_id;
        NextLightId ();
        
        if (first_light == NULL)
        {
                first_light = new LightElem;
                first_light->next = NULL;
                first_light->light = light;
        }
        else
        {
                current_light = first_light;
                while (current_light->next != NULL) current_light = current_light->next;

                current_light->next = new LightElem;
                current_light = current_light->next;
                current_light->next = NULL;
                current_light->light = light;
        }

        // Bind to OpenGL
        light->Bind (light_id);
}

void Scene::ApplyLights (int time)
{
        LightElem * current_light;

        TurnOffLights ();

        current_light = first_light;
        while (current_light != NULL)
        {
                current_light->light->Apply (time);
                current_light = current_light->next;
        }
}

void Scene::NextLightId ()
{
        // get next OpenGL id
        switch (current_light_id)
        {
                case    GL_LIGHT0:      current_light_id = GL_LIGHT1;
                                                        break;
                case    GL_LIGHT1:      current_light_id = GL_LIGHT2;
                                                        break;
                case    GL_LIGHT2:      current_light_id = GL_LIGHT3;
                                                        break;
                case    GL_LIGHT3:      current_light_id = GL_LIGHT4;
                                                        break;
                case    GL_LIGHT4:      current_light_id = GL_LIGHT5;
                                                        break;
                case    GL_LIGHT5:      current_light_id = GL_LIGHT6;
                                                        break;
                case    GL_LIGHT6:      current_light_id = GL_LIGHT7;
                                                        break;
                case    GL_LIGHT7:      current_light_id = GL_LIGHT7;
                                                        break;
        }
}

void Scene::TurnOffLights ()
{
        switch (current_light_id)
        {
                case GL_LIGHT0: glDisable (GL_LIGHT0);
                case GL_LIGHT1: glDisable (GL_LIGHT1);
                case GL_LIGHT2: glDisable (GL_LIGHT2);
                case GL_LIGHT3: glDisable (GL_LIGHT3);
                case GL_LIGHT4: glDisable (GL_LIGHT4);
                case GL_LIGHT5: glDisable (GL_LIGHT5);
                case GL_LIGHT6: glDisable (GL_LIGHT6);
                                                break;
                default:                glDisable (GL_LIGHT0);
                                                glDisable (GL_LIGHT1);
                                                glDisable (GL_LIGHT2);
                                                glDisable (GL_LIGHT3);
                                                glDisable (GL_LIGHT4);
                                                glDisable (GL_LIGHT5);
                                                glDisable (GL_LIGHT6);
                                                glDisable (GL_LIGHT7);
        }
}

void Scene::PrintToConsole ()
{
        GraphicalObjectElem * current_elem;
        double mod[16];
        double inv[16];

        printf ("----------- Scene Information --------------\n");

        current_elem = first_object;
        while (current_elem != NULL)
        {
                current_elem->graphical_object->PrintToConsole ();
                current_elem = current_elem->next;
        }

        if (camera != NULL)
        {
                glPushMatrix ();
                glLoadIdentity ();
                        camera->ApplyPosition (0);
                        glGetDoublev (GL_MODELVIEW_MATRIX, mod);
                        printf ("ModelView Matrix:\n[%g, %g, %g, %g,\n %g, %g, %g, %g,\n %g, %g, %g, %g,\n %g, %g, %g, %g]\n",
                                         mod[0], mod[4], mod[8], mod[12], 
                                         mod[1], mod[5], mod[9], mod[13],
                                         mod[2], mod[6], mod[10], mod[14],
                                         mod[3], mod[7], mod[11], mod[15]);

                        Geometry::InvertHomogenousMatrix (mod, inv);
                        printf ("Inverse Matrix:\n[%g, %g, %g, %g,\n %g, %g, %g, %g,\n %g, %g, %g, %g,\n %g, %g, %g, %g]\n",
                                         inv[0], inv[4], inv[8], inv[12], 
                                         inv[1], inv[5], inv[9], inv[13],
                                         inv[2], inv[6], inv[10], inv[14],
                                         inv[3], inv[7], inv[11], inv[15]);

                glPopMatrix ();
        }

        printf ("-------- End Of Scene Information ----------\n");
}

---