System.h

/***************************************************************************
 *   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                                      *
 *                                                                         *
 ***************************************************************************/

#ifndef OPENCAL_SYSTEM_H
#define OPENCAL_SYSTEM_H

// Includes
#include <OpenCAL/global.h>

#include <vector>
using std::vector;


namespace OpenCAL
{
    // Forward declarations
    class Object;
    class Actor;
    class Agent;
    class Renderer;
    class Picker;

    class OPENCAL_API System
    {
    private:
        bool m_destructing; 

    protected:
        // Typedefs
        typedef vector<Object *> ObjectList;
        typedef vector<Actor *> ActorList;
        typedef vector<Agent *> AgentList;
        typedef vector<System *> SystemList;

        // Member variables
        ObjectList m_objects;
        ActorList m_actors;
        AgentList m_agents;
        SystemList m_systems;

        System *m_parent;
        bool m_initialized, m_draw;
        bool m_enabled;

        float m_accuracyHint;

        Object *m_selectedObject;
        Renderer *m_renderer;
        Picker *m_picker;

    public:
        // Destructor
        virtual ~System();

        // Get functions
        Object *getObject(unsigned int i) { return m_objects[i]; }
        Actor *getActor(unsigned int i) { return m_actors[i]; }
        Agent *getAgent(unsigned int i) { return m_agents[i]; }
        System *getSystem(unsigned int i) { return m_systems[i]; }

        // Render functions
        void setRenderer(Renderer *renderer) { m_renderer = renderer; }
        Renderer *getRenderer() { return m_renderer; }
        virtual void render();

        // Pick functions
        void setPicker(Picker *picker) { m_picker = picker; }
        Picker *getPicker() { return m_picker; }
        virtual void renderPicking();
        virtual Object *pick(int x, int y);

        System *getParent() { return m_parent; }
        const System *getParent() const { return m_parent; }

        Object *getSelectedObject() { return m_selectedObject; }
        void selectObject(Object *object) { m_selectedObject = object; }
        void unselectObject() { m_selectedObject = 0; }

        // Information functions
        unsigned int numObjects() const { return m_objects.size(); }
        unsigned int numActors() const { return m_actors.size(); }
        unsigned int numAgents() const { return m_agents.size(); }
        unsigned int numSystems() const { return m_systems.size(); }
        unsigned int numChildren() const { return m_systems.size(); }
        bool hasParent() const { return (m_parent != 0); }

        // Enable functions
        bool isEnabled() const { return m_enabled; }
        void enable() { m_enabled = true; }
        void disable() { m_enabled = false; }
        void toggle() { m_enabled = !m_enabled; }
        void setEnabled(bool enabled) { m_enabled = enabled; }

        // Draw functions
        bool getDraw() const { return m_draw; }
        void setDraw(bool enabled = true) { m_draw = enabled; }
        void enableDraw() { m_draw = true; }
        void disableDraw() { m_draw = false; }
        void toggleDraw() { m_draw = !m_draw; }

        // General functions
        virtual bool isInitialized() const { return m_initialized; }
        virtual void initialize();

        // Step functions
        virtual void step(float deltaSeconds);
/*
#ifdef USE_OPENGL
        virtual void drawGL();
        virtual void drawPickGL();
        virtual Object *pickGL(int x, int y);
#endif // USE_OPENGL
*/

    protected:
        // Constructors
        // protected, so no instance of this base class can be made
        System(System *parent);

        // Add functions
        virtual void addObject(Object *object) { m_objects.push_back(object); }
        virtual void addActor(Actor *actor) { m_actors.push_back(actor); }
        virtual void addAgent(Agent *agent) { m_agents.push_back(agent); }
        virtual void addSystem(System *system) { m_systems.push_back(system); }

        // Delete functions
        virtual void deleteObject(Object *object);
        virtual void deleteActor(Actor *actor);
        virtual void deleteAgent(Agent *agent);
        virtual void deleteSystem(System *system);

    //private:
        // Private functions
        bool isDestructing() const { return m_destructing; }

    friend class Object;
    friend class Actor;
    friend class Agent;
    };
}

#endif // OPENCAL_SYSTEM_H

---