random_racer/src/MainApplication.cpp

Go to the documentation of this file.

// #include <signal.h>
#include <stdio.h>
#include <unistd.h>

#include <sstream>

#include <vrs/vrs.h>
#include <vrs/glut/glutcanvas.h>
#include <vrs/opengl/transparencytechniquegl.h>

#include <ode/ode.h>

#include "SDL.h"

#include <vrsode/BoxShape.h>
#include <vrsode/PhysicsBody.h>
#include <vrsode/PhysicsManager.h>
#include <vrsode/PlaneShape.h>
#include <vrsode/CylinderShape.h>
#include <vrsode/TriangleData.h>
#include <vrsode/TrimeshShape.h>

#include <random_utils/Macros.h>
#include <random_utils/ThreadSafeCanvas.h>

#include "BuggyCar.h"
#include "BuggyFunCar.h"
#include "CenterScreenDisplay.h"
#include "Console.h"
#include "ControlPointContainer.h"
#include "ControlPointGenerator.h"
#include "GameContext.h"
#include "ItemDistributor.h"
#include "LoaderGlue.h"
#include "ODETerrainLoader.h"
#include "ReloadPlane.h"
#include "ResourceManager.h"
#include "TestCar.h"
#include "ThirdPersonCameraHelper.h"
#include "VRSTerrainLoader.h"
#include "Version.h"
#include "Presenter.h"

#include "MainApplication.h"

using namespace VRS;
using namespace vrsode;
using namespace random_utils;

#define _RR_VRSODE_RUN_MULTITHREADED_
#define _RR_PRESENTATION_

namespace random_racer
{

const double MainApplication::c_defaultFov = 72.0;
const unsigned int MainApplication::c_canvasWidth = 800;
const unsigned int MainApplication::c_canvasHeight = 600;

MainApplication* MainApplication::s_daMainApp = NULL;

MainApplication::MainApplication()
{
    s_daMainApp = this;

    m_oldFov = -1;

    m_canvas = new ThreadSafeCanvas("Random Racer", c_canvasWidth, 
                                    c_canvasHeight, GLCanvas::RGBDDS);

    m_isFullscreen = false;

    // the root for the real scene
    m_scene = new SceneThing();
    m_canvas->append(m_scene);

    // add the console (and hide it)
    Console::get()->attach(m_canvas);
    Console::get()->hide();

#ifdef _RR_PRESENTATION_
    // Presentation
    m_presenter = new Presenter(m_canvas);
#endif

    m_centerScreen = new CenterScreenDisplay(m_canvas);
    m_centerScreen->showText(
        12000,
        "Welcome to Random Racer "RR_VERSION,
        "Press < or ^ for the console.");


    // make some light
    m_scene->append(new DistantLight(
        Vector(1,2,1)));/*,
        Color(1.0),
        0.6,
        0.05));*/

    // m_scene->append(new AmbientLight(Color(1.0, 0.98, 0.9), 0.5));


    // create camera
    m_lookAt        = new LookAt();
    m_perspective   = new Perspective(c_defaultFov, 2.5, 333.3);

    m_scene->append(new Camera(m_perspective, m_lookAt));

    // enable transparency in our scene
    m_scene->append(new TransparencyTechniqueGL());
    
    // enable fog in our scene
    m_fog = new Fog(0.96, Color(0.6, 0.6, 0.7), Fog::Linear, 196, 224);
    m_scene->append(m_fog);

    // the background with an cubetexture
    SO<ImageCubeMapTextureGL> cubeTexture = 
                    ResourceManager::get()->loadCubeTexture("miramar", ".png");  
    cubeTexture->setWrap(TextureGL::REPEAT);
    cubeTexture->setFilter(TextureGL::LINEAR_MIPMAP_LINEAR);
    m_scene->append(new BackgroundGL(cubeTexture));
    
    // this is the root for all objects excluding things like light
    m_geometryRoot = new SceneThing(m_scene);

    // create a car
    m_activeCar = 0;
    SO<SceneThing> car = new SceneThing(m_geometryRoot);

#ifdef RR_OTHER_CAR
    // m_car[m_activeCar] = new TestCar(car);
    m_car[m_activeCar] = new BuggyCar(car);
    m_car[m_activeCar]->setPosition(0,5,0);
#else
    m_car[m_activeCar] = new BuggyFunCar(car);
    m_car[m_activeCar]->setPosition(0,2,0);
#endif

    // create the helper which updates the camera by passing him a lookAt
    // to use (the one of the Camera) and a car to which he should look.
    m_camHelper = new ThirdPersonCameraHelper(
            m_lookAt, m_car[m_activeCar]->cameraHook(), Vector(0, -15, 10));

    camResetCommand();


    // add keyboard callback
    m_keyCallBack = new BehaviorCallback();
    m_canvas->append(m_keyCallBack);

    m_keyCallBack->setCanvasCallback(
        new MethodCallback<MainApplication>(this, &MainApplication::keyEvent));

    m_keyCallBack->activate();

    registerCommands();


    m_car[m_activeCar]->cameraHook()->setCollisionCategory(
        m_car[m_activeCar]->cameraHook()->collisionCategory() | 1);
        
    // make the car collide with coins
    m_car[m_activeCar]->cameraHook()->setCollisionPartnerCategories(
        m_car[m_activeCar]->cameraHook()->collisionPartnerCategories() | 32);


    // this is where the vrsLoader puts in its terrain, etc
    SO<SceneThing> vrsTerrainThing = new SceneThing(m_geometryRoot);
    SO<SceneThing> odeTerrainThing = new SceneThing(m_geometryRoot);


    m_generator = new ControlPointGenerator(32);
    m_container = new ControlPointContainer(
        32, 1024, m_generator->getCallback(), -35.0, 20.0);


    m_vrsLoader = new VRSTerrainLoader(
       // vrsTerrainThing, m_container, 64.0 + 32, 512.0);
        vrsTerrainThing, m_container, 128.0, 512.0);

    SO<SceneThing> itemRoot = new SceneThing(m_geometryRoot);
    itemRoot->append(cubeTexture);
    itemRoot->append(new TexGenGL(TexGenGL::ReflectionMap));

    m_itemDistributor = new ItemDistributor(
            itemRoot, m_vrsLoader, m_centerScreen);


    m_vrsGlue = new LoaderGlue(
        // m_car[m_activeCar]->cameraHook(), m_vrsLoader, 64.0, 64.0 - 16);
        m_car[m_activeCar]->cameraHook(), m_vrsLoader, 128.0, 128.0 - 32.0, 
        VRS::Vector(0,0,0), m_itemDistributor);


    m_odeLoader = new ODETerrainLoader(
        odeTerrainThing, m_vrsLoader, 30.0, 64.0);

    m_odeGlue   = new LoaderGlue(
        m_car[m_activeCar]->cameraHook(), m_odeLoader, 30.0, 20.0);


    // create 8 planes and asign them their callbacks
    for(unsigned int i = 0; i < 8; i++)
        if(i < 4)
            m_planes[i] = new ReloadPlane(m_geometryRoot, 
                                          m_vrsGlue->getCallback(), i);
        else
            m_planes[i] = new ReloadPlane(m_geometryRoot, 
                                          m_odeGlue->getCallback(), i, false);

    m_vrsGlue->registerPlanes(m_planes);
    m_odeGlue->registerPlanes(m_planes+4);
}

MainApplication::~MainApplication()
{
}

void
MainApplication::keyEvent()
{
    KeyEvent* event = VRS_Cast(KeyEvent, m_keyCallBack->currentCanvasEvent());

    if(event != NULL && event->pressed())
        switch(event->keyCode())
        {
            case Key::Up: m_car[m_activeCar]->accelerate(1.0); break;
            case Key::Down: m_car[m_activeCar]->accelerate(-0.2); break;
            case Key::Left: m_car[m_activeCar]->steer(-1.0); break;
            case Key::Right: m_car[m_activeCar]->steer(1.0); break;
            case Key::End:
                if(m_oldFov == -1)
                {
                    m_oldFov = m_perspective->getFovy();
                    m_targetFov = m_oldFov + 45;
                    m_lastFov = m_oldFov;
                }
                else if(m_lastFov != m_targetFov)
                {
                    m_perspective->setFovy(
                        random_utils::inRange(0.001, 
                            m_lastFov + ((m_targetFov - m_lastFov) * 0.09), 
                            179.999));
                
                    m_lastFov = m_lastFov + ((m_targetFov - m_lastFov) * 0.09);
                }
                m_car[m_activeCar]->nitro(1.0); 
            break;
            case ' ': m_car[m_activeCar]->handBreak(1.0); break;
        }
    if(event != NULL && event->released())
        switch(event->keyCode())
        {
            case Key::Up: m_car[m_activeCar]->accelerate(0.0); break;
            case Key::Down: m_car[m_activeCar]->accelerate(0.0); break;
            case Key::Left: m_car[m_activeCar]->steer(0.0); break;
            case Key::Right: m_car[m_activeCar]->steer(0.0); break;
            case Key::End: 
                if(m_oldFov > -1)
                    m_perspective->setFovy(
                        random_utils::inRange(0.001, m_oldFov, 179.999));
                m_oldFov = -1;
            break;
            case ' ': m_car[m_activeCar]->handBreak(0.0); break;
        }

    m_canvas->postForRedisplay();
}

void
MainApplication::updatePhysics(int p_args)
{
#ifndef _RR_VRSODE_RUN_MULTITHREADED_
    PhysicsManager::get()->update(0.02);
    glutTimerFunc(50, MainApplication::updatePhysics, p_args);
#endif
}

void
MainApplication::everyFrame(int p_args)
{
    MainApplication* self = (MainApplication*)p_args;

    // self->m_camHelper->updateLookAt();

    // just the vrs glue needs to check for collisions
    // because ode the ode terrain moving collisions
    // happen in the other thread.
    self->m_vrsGlue->checkForCollisions();

    self->m_itemDistributor->checkForCollisionsAndRotate(1.4);

    glutTimerFunc(10, MainApplication::everyFrame, p_args);
}

void
MainApplication::registerCommands()
{
    Console::get()->registerCommand("car_reset",
        new MethodCallback<MainApplication>(
            this, &MainApplication::carResetCommand));

    Console::get()->registerCommand("car_position",
        new MethodCallback<MainApplication>(
            this, &MainApplication::carPositionCommand));

    Console::get()->registerCommand("cam_fov",
        new MethodCallback1<MainApplication, const std::string&>(
            this, &MainApplication::fovCommand));

    Console::get()->registerCommand("cam_static",
        new MethodCallback1<MainApplication, const std::string&>(
            this, &MainApplication::camStaticCommand));

    Console::get()->registerCommand("cam_up",
        new MethodCallback1<MainApplication, const std::string&>(
            this, &MainApplication::camUpCommand));

    Console::get()->registerCommand("cam_correct",
        new MethodCallback1<MainApplication, const std::string&>(
            this, &MainApplication::camCorrectCommand));

    Console::get()->registerCommand("cam_back",
        new MethodCallback1<MainApplication, const std::string&>(
            this, &MainApplication::camBackCommand));

    Console::get()->registerCommand("cam_reset",
        new MethodCallback<MainApplication>(
            this, &MainApplication::camResetCommand));
            
    Console::get()->registerCommand("cam_fog",
        new MethodCallback1<MainApplication, const std::string&>(
            this, &MainApplication::camFogCommand));

    // Console::get()->registerCommand("cam_delay",
    //     new MethodCallback1<MainApplication, const std::string&>(
    //         this, &MainApplication::camDelayCommand));

    Console::get()->registerCommand("collect_coins",
        new MethodCallback1<MainApplication, const std::string&>(
            this, &MainApplication::collectCoinsCommand));

    Console::get()->registerCommand("quit",
        new MethodCallback<MainApplication>(
            this, &MainApplication::quitCommand));

    Console::get()->registerCommand("version",
        new MethodCallback<MainApplication>(
            this, &MainApplication::versionCommand));

    Console::get()->registerCommand("fullscreen",
        new MethodCallback<MainApplication>(
            this, &MainApplication::fullscreenCommand));

    Console::get()->registerCommand("autoexec",
        new MethodCallback<MainApplication>(
            this, &MainApplication::autoexecCommand));

    Console::get()->registerCommand("phy_debug",
        new MethodCallback1<MainApplication, const std::string&>(
            this, &MainApplication::phyDebugCommand));

    Console::get()->registerCommand("phy_performance_adjust",
        new MethodCallback1<MainApplication, const std::string&>(
            this, &MainApplication::phyPerformanceAdjustCommand));

    Console::get()->registerCommand("phy_step_time",
        new MethodCallback1<MainApplication, const std::string&>(
            this, &MainApplication::phyStepTimeCommand));

    Console::get()->registerCommand("phy_step_size",
        new MethodCallback1<MainApplication, const std::string&>(
            this, &MainApplication::phyStepSizeCommand));

    Console::get()->registerCommand("ter_debug_planes",
        new MethodCallback1<MainApplication, const std::string&>(
            this, &MainApplication::terDebugPlanesCommand));

    Console::get()->registerCommand("ter_debug_phy",
        new MethodCallback1<MainApplication, const std::string&>(
            this, &MainApplication::terDebugPhyCommand));
    
        Console::get()->registerCommand("pre_start",
            new MethodCallback1<MainApplication, const std::string&>(
                this, &MainApplication::preStartCommand));
}

void
MainApplication::fovCommand(const std::string& p_newFov)
{
    if(!p_newFov.empty())
    {
        double fov;
        std::istringstream s(p_newFov);
        s >> fov;

        m_perspective->setFovy(random_utils::inRange(0.001, fov, 179.999));
    }
    else
    {
        std::ostringstream s;
        s << m_perspective->getFovy();

        Console::get()->addLine(s.str());
    }
}

void
MainApplication::quitCommand()
{
    // after this cleanUpAtExit() will be called
    exit(0);
}

void
MainApplication::autoexecCommand()
{
    Console::get()->autoexec();
}

void
MainApplication::carResetCommand()
{
    if(!(m_car[m_activeCar]->chassis()))
        std::cerr << "ERROR: chassis is NULL" << std::endl;
    
    Vector pos = m_car[m_activeCar]->chassis()->position();
    pos[1] += 2;

    m_car[m_activeCar]->chassis()->setRotation(Vector(0,1,0), 1);
    m_car[m_activeCar]->setPosition(pos);
}

void
MainApplication::carPositionCommand()
{
    std::ostringstream s;
    s << m_car[m_activeCar]->cameraHook()->position();

    Console::get()->addLine(s.str());
}

void
MainApplication::camUpCommand(const std::string& p_newUp)
{
    if(!p_newUp.empty())
    {
        double up;
        std::istringstream s(p_newUp);
        s >> up;

        m_camHelper->setDistanceY(up);
    }
    else
    {
        std::ostringstream s;
        s << m_camHelper->distanceY();

        Console::get()->addLine(s.str());
    }
}

void
MainApplication::camBackCommand(const std::string& p_newBack)
{
    if(!p_newBack.empty())
    {
        double back;
        std::istringstream s(p_newBack);
        s >> back;

        if(back == 0.0)
            back = 0.05;

        m_camHelper->setDistanceX(back);
    }
    else
    {
        std::ostringstream s;
        s << m_camHelper->distanceX();

        Console::get()->addLine(s.str());
    }
}

void
MainApplication::camResetCommand()
{
    m_perspective->setFovy(c_defaultFov);
    m_camHelper->setDistanceX(12.0);
    m_camHelper->setDistanceY(3.5);
    m_camHelper->setCorrectY(3.0);
    m_camHelper->setStaticY(false);
}

void
MainApplication::camStaticCommand(const std::string& p_newStatic)
{
    if(p_newStatic.empty())
    {
        if(m_camHelper->isStaticY())
            Console::get()->addLine("true");
        else
            Console::get()->addLine("false");
    }
    else if(p_newStatic == "true" || p_newStatic == "1")
        m_camHelper->setStaticY(true);

    else
        m_camHelper->setStaticY(false);
}

void
MainApplication::camCorrectCommand(const std::string& p_newDouble)
{
    if(p_newDouble.empty())
    {
        std::ostringstream s;
        s << m_camHelper->correctY();

        Console::get()->addLine(s.str());
    }
    else
    {
        double correct;
        std::istringstream s(p_newDouble);
        s >> correct;

        m_camHelper->setCorrectY(correct);
    }
}

void
MainApplication::camFogCommand(const std::string& p_fogToggle)
{
    if(p_fogToggle.empty())
    {
        m_scene->contains(m_fog) ? 
                m_scene->remove(m_fog) : 
                m_scene->prepend(m_fog);
    }
    else if(p_fogToggle == "true" || p_fogToggle == "1")
    {
        if(!m_scene->contains(m_fog))
            m_scene->prepend(m_fog);
    }
    else
    {
        if(m_scene->contains(m_fog))
            m_scene->remove(m_fog);
    }  
}


void
MainApplication::phyDebugCommand(const std::string& p_newDebug)
{
    if(p_newDebug.empty() || p_newDebug == "true" || p_newDebug == "1")
        PhysicsManager::get()->setDebugNodesGlobal(true);
    else
        PhysicsManager::get()->setDebugNodesGlobal(false);
}

void
MainApplication::phyPerformanceAdjustCommand(const std::string& p_newPerf)
{
    if(p_newPerf.empty())
        PhysicsManager::get()->performanceAutoAdjust() ?
                Console::get()->addLine("true") :
                Console::get()->addLine("false");

    else if(p_newPerf == "true" || p_newPerf == "1")
        PhysicsManager::get()->setPerformanceAutoAdjust(true);

    else
        PhysicsManager::get()->setPerformanceAutoAdjust(false);
}

void
MainApplication::phyStepTimeCommand(const std::string& p_newTime)
{
    if(!p_newTime.empty())
    {
        double time;
        std::istringstream s(p_newTime);
        s >> time;

        PhysicsManager::get()->setStepTime(time);
    }
    else
    {
        std::ostringstream s;
        s << PhysicsManager::get()->stepTime();

        Console::get()->addLine(s.str());
    }
}

void
MainApplication::phyStepSizeCommand(const std::string& p_newSize)
{
    if(!p_newSize.empty())
    {
        double size;
        std::istringstream s(p_newSize);
        s >> size;

        PhysicsManager::get()->setStepSize(size);
    }
    else
    {
        std::ostringstream s;
        s << PhysicsManager::get()->stepSize();

        Console::get()->addLine(s.str());
    }
}

void
MainApplication::versionCommand()
{
    std::string versionString;
    versionString += "Random Racer "RR_VERSION;
    versionString += " - using ";
    versionString += PhysicsManager::get()->odeVersionString();
    versionString += ", ";
    
    std::stringstream sdlVersionString;
    sdlVersionString << "libSDL " 
            << SDL_MAJOR_VERSION << "." 
            << SDL_MINOR_VERSION << "." 
            << SDL_PATCHLEVEL;

    versionString += sdlVersionString.str();
    
    versionString += ", ";

    std::stringstream vrsVersionString;
    vrsVersionString << "VRS3D "  
        << VRS_MAJOR_VERSION << "."
        << VRS_MINOR_VERSION << "."
        << VRS_PATCH_VERSION;

    versionString += vrsVersionString.str();

    Console::get()->addLine(versionString);
}

void
MainApplication::fullscreenCommand()
{
    if(m_isFullscreen)
    {
        m_canvas->setSize(c_canvasWidth, c_canvasHeight);
        m_isFullscreen = false;
    }
    else
    {
        glutFullScreen();
        m_isFullscreen = true;
    }
}

void
MainApplication::terDebugPlanesCommand(const std::string& p_which)
{
    if(p_which == "ode")
        for(unsigned int i = 4; i < 8; i++)
            m_planes[i]->setDebug(true);

    else if(p_which == "vrs")
        for(unsigned int i = 0; i < 4; i++)
            m_planes[i]->setDebug(true);

    else if(p_which == "off" || p_which == "none" ||
            p_which == "0" || p_which == "false")
        for(unsigned int i = 0; i < 8; i++)
            m_planes[i]->setDebug(false);

    else
        Console::get()->addLine("try ode, vrs oder off");
}

void
MainApplication::camDelayCommand(const std::string& p_newIntDelay)
{
    if(p_newIntDelay.empty())
    {
        std::ostringstream s;
        s << m_camHelper->delay();

        Console::get()->addLine(s.str());
    }
    else
    {
        unsigned int delay;
        std::istringstream s(p_newIntDelay);
        s >> delay;

        m_camHelper->setDelay(delay);
    }
}

void
MainApplication::terDebugPhyCommand(const std::string& p_newBool)
{
    if(p_newBool.empty() || p_newBool == "true" || p_newBool == "1")
        m_odeLoader->setDebug(true);
    else
        m_odeLoader->setDebug(false);
}

void
MainApplication::collectCoinsCommand(const std::string& p_newBool)
{
    if(p_newBool.empty() || p_newBool == "true" || p_newBool == "1")
        m_itemDistributor->setEnabled(true);
    else
        m_itemDistributor->setEnabled(false);
}

void 
MainApplication::preStartCommand(const std::string& p_temp)
{
    m_presenter->startPresentation();
}

void
MainApplication::cleanUpAtExit()
{
    PhysicsManager::terminate();    

    s_daMainApp->m_vrsLoader->terminate();

    SDL_Quit();
}

void
MainApplication::signalHandler(int sig)
{
    exit(0);
}

} // namespace random_racer


using namespace random_racer;

// WUHAHAHAHA, don't let SDL rename our main :>
#ifdef __APPLE__
  #undef main
#endif

int
main(int p_argc, char** p_argv)
{
    // assume this because we want to pass a pointer to glutTimerFunc()
    // which points to all its arguments
    assert(sizeof(int) == sizeof(MainApplication*));

    // i hope this helps a bit :>
    SharedObj::enableThreadSafeSOs(true);

    // init glut and sdl
    glutInit(&p_argc, p_argv);
    SDL_Init(SDL_INIT_TIMER);

    glutSetKeyRepeat(GLUT_KEY_REPEAT_ON);

    ResourceManager::get()->setArgv((p_argc >= 1) ? p_argv[0] : "");

    SO<MainApplication> app = new MainApplication;

    srand(SDL_GetTicks());
    srandom(SDL_GetTicks()*23);


    // ensure that we guit nicely
    atexit(MainApplication::cleanUpAtExit);

    signal(SIGHUP, MainApplication::signalHandler);
    signal(SIGINT, MainApplication::signalHandler);
    signal(SIGKILL, MainApplication::signalHandler);


    Console::get()->autoexec();

#ifdef _RR_VRSODE_RUN_MULTITHREADED_
    PhysicsManager::get()->startThread();
#endif

    glutTimerFunc(0, MainApplication::updatePhysics,
                  (int)((MainApplication*)app));

    glutTimerFunc(0, MainApplication::everyFrame,
                  (int)((MainApplication*)app));

    glutMainLoop();

    // will never be called
    return 0;
}

---