random_racer/src/MainApplication.h

Go to the documentation of this file.

#ifndef _RR_MAINAPPLICATION_H_
#define _RR_MAINAPPLICATION_H_

#include <vrs/sharedobj.h>

#include "vrsode/TriangleData.h"

namespace VRS
{
class BehaviorCallback;
class GlutCanvas;
class SceneThing;
class LookAt;
class Perspective;
} // namespace VRS

namespace vrsode
{
class CarSimple;
} // namespace vrsode


namespace random_racer
{

class LoaderGlue;
class ReloadPlane;
class TerrainGenerator;
class TerrainLoader;
class ThirdPersonCameraHelper;
class CenterScreenDisplay;
class Presenter;

class MainApplication : public VRS::SharedObj
{
    /*
        Scene Graph:
        canvas
        |_ scene                -- contains the real scene
        |  |_ light
        |  |_ cam               -- with m_perspective and m_lookAt
        |  |_ background        -- with cubetexture
        |  |   
        |  |_ geometryRoot
        |     |_ car...
        |     |  |_...
        |     |  |_...
        |     |
        |     |_ terrain
        |        |_...
        |
        |_ consoleThing         -- with own cam, etc. holds the console
    */

    VRS::SO<VRS::GlutCanvas>            m_canvas;
    VRS::SO<VRS::SceneThing>            m_scene, m_geometryRoot, m_skyBoxThing;
    VRS::SO<VRS::LookAt>                m_lookAt;
    VRS::SO<VRS::Perspective>           m_perspective;
    VRS::SO<VRS::Fog>                   m_fog;
    VRS::SO<VRS::BehaviorCallback>      m_keyCallBack;
    VRS::SO<Car>                        m_car[2];
    unsigned int                        m_activeCar;
    double                              m_oldFov;
    double                              m_targetFov;
    double                              m_lastFov;

    VRS::SO<ThirdPersonCameraHelper>    m_camHelper;

    VRS::SO<TerrainGenerator>           m_odeGenerator, m_vrsGenerator;
    VRS::SO<VRSTerrainLoader>           m_vrsLoader;
    VRS::SO<ODETerrainLoader>           m_odeLoader;
    VRS::SO<LoaderGlue>                 m_odeGlue, m_vrsGlue;
    VRS::SO<ReloadPlane>                m_planes[8];

    VRS::SO<ControlPointGenerator>      m_generator;

    VRS::SO<ItemDistributor>            m_itemDistributor;

    bool                                m_isFullscreen;

    static const double                 c_defaultFov;
    static const unsigned int           c_canvasWidth, c_canvasHeight;

    VRS::SO<vrsode::TriangleData>       m_triangleData;

    VRS::SO<ControlPointContainer>      m_container;

    VRS::SO<CenterScreenDisplay>        m_centerScreen;

    VRS::SO<Presenter>                  m_presenter;

    static MainApplication*             s_daMainApp;

    void keyEvent();

    void fovCommand(const std::string& newFov);

    void carResetCommand();
    
    void carPositionCommand();

    void camUpCommand(const std::string& newUpDouble);

    void camCorrectCommand(const std::string& newDouble);

    void camBackCommand(const std::string& newBackDouble);

    void camStaticCommand(const std::string& newStaticBool);

    void camResetCommand();

    void camFogCommand(const std::string& fogToggle);

    void camDelayCommand(const std::string& newIntDelay);

    void versionCommand();

    void fullscreenCommand();

    void autoexecCommand();

    void phyDebugCommand(const std::string& newDebugBool);

    void terDebugPlanesCommand(const std::string& which);

    void terDebugPhyCommand(const std::string& newBool);

    void phyPerformanceAdjustCommand(const std::string& newBool);

    void phyStepTimeCommand(const std::string& newDouble);

    void phyStepSizeCommand(const std::string& newBool);

    void phyChangeTerrainCommand();

    void collectCoinsCommand(const std::string& newBool);

    void preStartCommand(const std::string& temp);

    void registerCommands();

public:
    MainApplication();

    virtual ~MainApplication();

    static void updatePhysics(int args);

    static void everyFrame(int args);

    void quitCommand();

    static void cleanUpAtExit();

    static void signalHandler(int sig);
};

} // namespace random_racer


#endif // _RR_MAINAPPLICATION_H_

---