System.cpp

/***************************************************************************
 *   This file is part of OpenCAL: Open Computer Animation Library         *
 *   I created OpenCAL as my master's thesis Computer Science (multimedia) *
 *   at the tUL university in Diepenbeek, Belgium                          *
 *                                                                         *
 *   Copyright (C) 2003-2004 by Jeroen Dierckx                             *
 *   jeroen.dierckx@student.luc.ac.be                                      *
 *                                                                         *
 ***************************************************************************/

// Includes
#include "System.h"
#include <OpenCAL/Object.h>
#include <OpenCAL/Actor.h>
#include <OpenCAL/Agent.h>
#include <OpenCAL/Renderer.h>
#include <OpenCAL/Picker.h>
#include <OpenCAL/ObjectIterator.h>
using namespace OpenCAL;

#include <OpenCAL/NullParentException.h>
using Exceptions::NullParentException;

using namespace std;


// Macros
#define forAllObjects(it)\
ObjectList::iterator it;\
for(it = m_objects.begin(); it != m_objects.end(); ++it)

#define forAllActors(it)\
ActorList::iterator it;\
for(it = m_actors.begin(); it != m_actors.end(); ++it)

#define forAllAgents(it)\
AgentList::iterator it;\
for(it = m_agents.begin(); it != m_agents.end(); ++it)

#define forAllSystems(it)\
SystemList::iterator it;\
for(it = m_systems.begin(); it != m_systems.end(); ++it)


/******************************
* Constructors and destructor *
******************************/

System::System(System *parent)
: m_destructing(false), m_parent(parent), m_initialized(false),
  m_draw(true), m_enabled(true), m_accuracyHint(0.0f),
  m_selectedObject(0), m_renderer(0), m_picker(0)
{
#ifdef VERBOSE
    Debug::print("System constructor", 2);
#endif // VERBOSE

/*
    if(!parent)
        throw NullParentException(__FILE__, __LINE__);
*/

#ifdef VERBOSE
    Debug::print("Parent is given, adding to the the parent's system list...", 2);
#endif // VERBOSE

    if(parent)
        parent->addSystem(this);
}

System::~System()
{
#ifdef VERBOSE
    Debug::print("System destructor", 2);

    Debug::stream << "Cleaning up ";
    Debug::stream << m_objects.size() << " object(s), ";
    Debug::stream << m_actors.size() << " actor(s), ";
    Debug::stream << m_agents.size() << " agent(s) and ";
    Debug::stream << m_systems.size() << " subsystem(s)." << endl;
    Debug::printStream();
#endif // VERBOSE

    m_destructing = true;

    forAllSystems(system)
        delete *system; // System cannot be 0

    forAllObjects(object)
        delete *object;

    forAllActors(actor)
        delete *actor;

    forAllAgents(agent)
        delete *agent;

    if(m_parent)
        m_parent->deleteSystem(this);
}


/*******************
* Render functions *
*******************/

void System::render()
{
    if(!m_renderer)
    {
        cerr << "No renderer available!!" << endl;
        return;
    }

    if(!isInitialized())
    {
#ifdef VERBOSE
        Debug::initWarning("system");
#endif // VERBOSE
        initialize();
    }

    forAllSystems(system)
    {
        if((*system)->getDraw())
        {
            (*system)->setRenderer(m_renderer); 
            (*system)->render();
        }
    }

    forAllActors(actor)
    {
        if((*actor)->getDraw())
            (*actor)->render();
    }

    forAllObjects(object)
    {
        if((*object)->getDraw())
            (*object)->render();
    }
}


/*****************
* Pick functions *
*****************/

void System::renderPicking()
{
    unsigned int i;

    //if(!m_draw) return;

    if(!m_picker)
    {
        cerr << "No picker available!!" << endl;
        return;
    }

    if(!isInitialized())
        initialize();

    for(i = 0; i < m_systems.size(); ++i)
    {
        if(m_systems[i]->getDraw())
        {
            m_systems[i]->setPicker(m_picker);

            m_picker->pushName(i);
            m_systems[i]->renderPicking();
            m_picker->popName();
        }
    }

    m_picker->pushName(0);
    for(i = 0; i < m_objects.size(); ++i)
    {
        if(m_objects[i]->getDraw())
        {
            m_picker->loadName(i);
            m_objects[i]->renderPicking();
        }
    }
    m_picker->popName();
}

Object *System::pick(int x, int y)
{
    //if(!m_draw) return 0;

    if(!m_picker)
    {
        cerr << "No picker available!!" << endl;
        return 0;
    }

    if(!isInitialized())
        initialize();

    return m_picker->pick(this, x, y);
}


/********************
* General functions *
********************/

void System::initialize()
{
#ifdef VERBOSE
    Debug::print("System initialize", 2);
#endif // VERBOSE

    if(m_renderer)
        m_renderer->initialize();

    forAllSystems(system)
    {
        (*system)->setRenderer(m_renderer); 
        (*system)->initialize();
    }

    forAllObjects(object)
        (*object)->initialize();

    forAllActors(actor)
        (*actor)->initialize();

    forAllAgents(agent)
        (*agent)->initialize();

    m_initialized = true;
}

void System::step(float deltaSeconds)
{
#ifdef VERBOSE
    Debug::stream << "System step (" << deltaSeconds << " seconds)" << endl;
    Debug::printStream(Debug::maxLevel);
#endif // VERBOSE

    //if(!m_enabled) return;

    if(!isInitialized())
    {
#ifdef VERBOSE
        Debug::initWarning("system");
#endif // VERBOSE
        initialize();
    }

    forAllActors(actor)
    {
        if((*actor)->isEnabled())
            (*actor)->execute(deltaSeconds);
    }

    forAllSystems(system)
    {
        if((*system)->isEnabled())
            (*system)->step(deltaSeconds);
    }

    forAllAgents(agent)
    {
        if((*agent)->isEnabled())
            (*agent)->satisfy();
    }
}

/*
#ifdef USE_OPENGL
void System::drawGL()
{
#ifdef VERBOSE
    Debug::print("System drawGL", Debug::maxLevel);
#endif // VERBOSE

    //if(!m_draw) return;

    if(!isInitialized())
    {
#ifdef VERBOSE
        Debug::initWarning("system");
#endif // VERBOSE
        initialize();
    }

    forAllSystems(system)
    {
        if((*system)->getDraw())
            (*system)->drawGL();
    }

    forAllActors(actor)
    {
        if((*actor)->getDraw())
            (*actor)->drawGL();
    }

    forAllObjects(object)
    {
        if((*object)->getDraw())
            (*object)->drawGL();
    }
}

void System::drawPickGL()
{
    unsigned int i;

    //if(!m_draw) return;

    if(!isInitialized())
        initialize();

    for(i = 0; i < m_systems.size(); ++i)
    {
        if(m_systems[i]->getDraw())
        {
            glPushName(i);
            m_systems[i]->drawPickGL();
            glPopName();
        }
    }

    glPushName(0);
    for(i = 0; i < m_objects.size(); ++i)
    {
        if(m_objects[i]->getDraw())
        {
            glLoadName(i);
            m_objects[i]->drawGL();
        }
    }
    glPopName();
}

Object *System::pickGL(int x, int y)
{
    //if(!m_draw) return 0;

    if(!isInitialized())
        initialize();

    GLuint selectBuffer[PICKINGSIZE];
    glSelectBuffer(PICKINGSIZE, selectBuffer);

    glRenderMode(GL_SELECT);

    glInitNames();
    //glPushName(0);

    GLint viewport[4];
    glGetIntegerv(GL_VIEWPORT, viewport);

    GLdouble projection[16];
    glGetDoublev(GL_PROJECTION_MATRIX, projection);

    glMatrixMode(GL_PROJECTION);
    glPushMatrix();

    glLoadIdentity();
    gluPickMatrix((GLdouble) x, (GLdouble) (viewport[3] - y), PICKREGION, PICKREGION, viewport);
    glMultMatrixd(projection);


    // Change to modelview matrix
    glMatrixMode(GL_MODELVIEW);

    // Draw the objects
    drawPickGL();


    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glFlush();

    glMatrixMode(GL_MODELVIEW);
    GLint hits = glRenderMode(GL_RENDER);
    if(hits < 0)
        cerr << "The picking buffer has overflowed!" << endl;


    // Determine which item is picked
    GLuint depth = 0xffffffff;
    // These must be constants in MSVC6
    vector<int> systemIndices[64];
    int objectIndex[64];
    int selectedIndex = -1;
    GLuint *ptr = (GLuint *) selectBuffer;

    cout << "[Picking] " << hits << " hits" << endl;
    for(GLint i = 0; i < hits; ++i)
    {
        objectIndex[i] = -1;

        GLuint nrNames = *ptr; ++ptr;
        GLuint minZ = *ptr; ++ptr;
        GLuint maxZ = *ptr; ++ptr;

        cout << "[Picking] hit " << i;
        cout << " (minZ " << minZ << "; maxZ " << maxZ << ")";
        cout << " has " << nrNames << " names: ";

        if(minZ < depth)
        {
            depth = minZ;
            selectedIndex = i;
        }

        for(GLuint j = 0; j < nrNames; ++j)
        {
            cout << *ptr << " ";
            if(objectIndex[i] != -1)
                systemIndices[i].push_back(objectIndex[i]);
            objectIndex[i] = *ptr;
            ptr++;
        }
        cout << endl;
    }


    System *system = this;
    Object *object = 0;
    if(selectedIndex != -1)
    {
        for(unsigned int i = 0; i < systemIndices[selectedIndex].size(); ++i)
            system = system->getSystem(systemIndices[selectedIndex][i]);
        object = system->getObject(objectIndex[selectedIndex]);
    }

    m_selectedObject = object;
    return object;
}
#endif // USE_OPENGL
*/


/**********************
* Protected functions *
**********************/

void System::deleteObject(Object *object)
{
    if(m_destructing) return;

    forAllObjects(it)
        if(*it == object)
        {
            m_objects.erase(it);
            return;
        }

#ifdef VERBOSE
    Debug::print("Trying to delete an object that isn't in the list!");
#endif // VERBOSE

}


void System::deleteActor(Actor *actor)
{
    if(m_destructing) return;

    forAllActors(it)
        if(*it == actor)
        {
            m_actors.erase(it);
            return;
        }

#ifdef VERBOSE
    Debug::print("Trying to delete an actor that isn't in the list!");
#endif // VERBOSE

}

void System::deleteAgent(Agent *agent)
{
    if(m_destructing) return;

    forAllAgents(it)
        if(*it == agent)
        {
            m_agents.erase(it);
            return;
        }

#ifdef VERBOSE
    Debug::print("Trying to delete an agent that isn't in the list!");
#endif // VERBOSE

}

void System::deleteSystem(System *system)
{
    if(m_destructing) return;

    forAllSystems(it)
        if(*it == system)
        {
            m_systems.erase(it);
            return;
        }

#ifdef VERBOSE
    Debug::print("Trying to delete a system that isn't in the list!");
#endif // VERBOSE

}

---