/Users/craigcornelius/Projects/SPRING Mac Release 0.2/springCore.h

Go to the documentation of this file.

#ifndef SPRINGCORE_H
#define SPRINGCORE_H

// $Id: springCore.h,v 1.8 2006/05/24 16:52:40 sean Exp $
// $Copyright: (c)2001 National Biocomputation Center, Stanford University $

// springCore.h

// Encapsulates the global variables of the SPRING core application.
//
// Developers of specialized applications are encouraged to derive 
// subclasses of this in order to cleanly separate the general values
// from specialized instances of SPRING.

// History:
// 04-Oct-2005  cwc             Started this file for SPRING 0.1  Mostly to get 
//                                              gameBase into this version. 



// GLUI/MUI/GLUT headers
//#include <glui.h>

#include <mui.h>
#include <GLUT/glut.h>
#include "objectarray.h"
#include "object.h"
#include "sensorarray.h"
#include "markers.h"

#include "displayreplicator.h"
#include "geometryreplicator.h"


#include "rasterfont.h"
#include "camera.h"
#include "voice.h"
#include "lightarray.h"

// Defining two levels of customization of SPRING
#include "gameBase.h"


// The class that (will, in next version) be the main SPRING program.
// Global variables and main functions of the program will be in this class.

class springCore
{

public:

        // *** PUBLIC CONSTRUCTOR *** 
        
        // Constructor optionally takes global arguments 
        springCore(int argc = 0, char* argv[] = NULL);
        virtual ~springCore();


        // *** PUBLIC/GLOBAL ENUMS ***

        // Available collision detection and response algorithms 
        enum CollisionAlgorithmEnum { 
                        BOUNDING_SPHERE_CD, 
                        AABB_CD,
        };


        // *** PUBLIC/GLOBAL FUNCTIONS ***

        // Sets up values of the global variables.  May be called to reset state.
        void InitVariables(void);

        // Accessor methods for collision detection and response
        bool isCollisionsOn() { return collisionsOn; }
        void setCollisionsOn(bool on) { collisionsOn = on; }
        CollisionAlgorithmEnum getCollisionAlgorithm() { return currentCollisionAlgorithm; }
        void setCollisionAlgorithm(CollisionAlgorithmEnum collisionAlgorithm_) { newCollisionAlgorithm = collisionAlgorithm_; }

        // Accessor methods for active game
        gameBase* getActiveGame() { return activeGame; }
        void setActiveGame(gameBase* activeGame_) { activeGame = activeGame_; }

        // Accessor methods for on-screen info displays
        bool isDoInfoDisplay() { return doInfoDisplay; }
        void setDoInfoDisplay(bool doInfoDisplay_) { doInfoDisplay = doInfoDisplay_; }
        bool isDoTimeDisplay() { return doTimeDisplay; }
        void setDoTimeDisplay(bool doTimeDisplay_) { doTimeDisplay = doTimeDisplay_; }

        // Accessor methods for time spent
        double getIdleTime() { return idleTime; }
        void setIdleTime(double idleTime_) { idleTime = idleTime_; }
        double getHandleBehaviorTime() { return handleBehaviorTime; }
        void setHandleBehaviorTime(double handleBehaviorTime_) { handleBehaviorTime = handleBehaviorTime_; }
        double getUpdateLoopTime() { return updateLoopTime; }
        void setUpdateLoopTime(double updateLoopTime_) { updateLoopTime = updateLoopTime_; }
        double getCollisionDetectionTime() { return collisionDetectionTime; }
        void setCollisionDetectionTime(double collisionDetectionTime_) { collisionDetectionTime = collisionDetectionTime_; }
        double getCDResetTime() { return cdResetTime; }
        void setCDResetTime(double cdResetTime_) { cdResetTime = cdResetTime_; }
        double getCDDetectTime() { return cdDetectTime; }
        void setCDDetectTime(double cdDetectTime_) { cdDetectTime = cdDetectTime_; }
        double getCDResolveTime() { return cdResolveTime; }
        void setCDResolveTime(double cdResolveTime_) { cdResolveTime = cdResolveTime_; }
        double getGameTime() { return gameTime; }
        void setGameTime(double gameTime_) { gameTime = gameTime_; }

private:

        // *** PRIVATE VARIABLES ***

        // If collision detection is on or off
        bool collisionsOn;

        // Based on the class for games / scenarios.
        gameBase* activeGame;    // the currently active game or null for none

        // Time for one idle loop
        double idleTime;
        // Time to handle behaviors
        double handleBehaviorTime;
        // Time for loop which calls universe.update several times
        double updateLoopTime;
        // Time for collision detection
        double collisionDetectionTime;
        // Time to reset collisions OR prepare for next loop
        double cdResetTime;
        // Time to detect collisions
        double cdDetectTime;
        // Time to resolve collisions
        double cdResolveTime;
        // Time for game
        double gameTime;

public:
        // CHRIS: this "font_p" should not be in springCore at all
        //   -> objects that want to output text, just create their own font_p
        //   -> also, there should be NO global variables be public
        RasterFont* font_p;

        
        
        // CHRIS: move to private!
        
        // The collision algorithm that is currently used
        CollisionAlgorithmEnum currentCollisionAlgorithm;
        // The collision algorithm to take for the next iteration
        CollisionAlgorithmEnum newCollisionAlgorithm;

        // If tool info + status info (running OR paused) should be display on-screen
        int doInfoDisplay;
        // Displays times spent (computational) on-screen
        int doTimeDisplay;


};

#endif // SPRINGCORE_H

---