vrsode/VrsTest.cpp

Go to the documentation of this file.

#include <ode/ode.h>

#include <vrs/vrs.h>
#include <vrs/glut/glutcanvas.h>
#include <vrs/polygonsetbuilder.h>

#include "Car3DS.h"
#include "CarSimple.h"
#include "random_utils/LogManager.h"
#include "random_utils/ThreadSafeCanvas.h"
#include "PhysicsManager.h"
#include "PhysicsBody.h"
#include "PhysicsJointBall.h"
#include "SamplePlane.h"
#include "SampleBox.h"
#include "PlaneShape.h"
#include "BoxShape.h"

using namespace VRS;
using namespace vrsode;

#define VRSODE_MULTITHREAD

class VrsTest : public SharedObj
{
public:
    VrsTest();
private:
    void keyEvent();

    SO<BehaviorCallback>    m_keyCallBack;
    SO<random_utils::ThreadSafeCanvas>  m_canvas;
    SO<SceneThing>          m_rootNode;

    SO<CarSimple>           m_car;
};

SO<SceneThing>          g_rootNode;

VrsTest::VrsTest()
{
    // initialize glut and create canvas for this application
    m_canvas = new random_utils::ThreadSafeCanvas(
        "VrsTest", 640, 480, GLCanvas::RGBDDS);

    // create scene graph root
    m_rootNode = new SceneThing();
    g_rootNode = m_rootNode;

    // attach some background color
    m_rootNode->append(new BackgroundGL(Color(0.2),
                       Color(0.9), BackgroundGL::TopToBottom));

    // attach some nice green color as default
    m_rootNode->append(new ShapeMaterialGL(
            Color(0.5, 1.0, 0.5), Color(0.15, 0.3, 0.15)));

    m_rootNode->append(new TransparencyTechniqueGL());

    PhysicsManager::get();

//     PhysicsManager::get()->lock();

    // create a big box, which is the ground
    SO<SceneThing> boxGround = new SceneThing(m_rootNode);
    boxGround->append(new Box(Vector(-82,-80,-82), Vector(82,0,82)));
    SO<CollisionBody> boxGroundPhy = new CollisionBody(boxGround, CS_Box);
    boxGroundPhy->surface()->setBounce(1.0);
    boxGroundPhy->surface()->setBounceVelocity(0.0);
    boxGroundPhy->setDebugNode();

    // create walls
    SO<SceneThing> wall[4];
    SO<BoxShape> wallShape[4];
    SO<CollisionBody> wallPhy[4];

    wallShape[0] = new BoxShape(Bounds(Vector(80,0,80),Vector(81,30,-80)));
    wallShape[1] = new BoxShape(Bounds(Vector(-80,0,80),Vector(-81,30,-80)));
    wallShape[2] = new BoxShape(Bounds(Vector(80,0,80),Vector(-80,30,81)));
    wallShape[3] = new BoxShape(Bounds(Vector(80,0,-80),Vector(-80,30,-81)));

    for(int i = 0; i < 4; i++)
    {
        wall[i] = new SceneThing(m_rootNode);
        wallPhy[i] = new CollisionBody(wall[i], wallShape[i]);
        wallPhy[i]->setDebugNode();
    }

    // create a box,
    SO<SceneThing> box = new SceneThing(m_rootNode);
    SO<BoxShape> boxShape = new BoxShape(
            Bounds(Vector(-1,-20,-20), Vector(1,20,20)));
    SO<CollisionBody> boxPhy = new SampleBox(box, boxShape);
    boxPhy->setPosition(10,20.1,0);
    boxPhy->surface()->setBounce(1.0);
    boxPhy->surface()->setBounceVelocity(0.0);
    boxPhy->setDebugNode();

//     for(int i = 0; i < 160; i+=40)
//         for(int j = 0; j < 160; j+=40)
//         {
//             SO<SceneThing> ball = new SceneThing(m_rootNode);
//             ball->append(new Sphere(1.0));
//             SO<PhysicsBody> ballPhy = new PhysicsBody(ball, CS_Sphere);
//             ballPhy->setPosition(-80 + i,30,-80 + j);
//             ballPhy->surface()->setBounce(1.0);
//             ballPhy->surface()->setBounceVelocity(0.0);
//             ballPhy->setAngularVelocity(VRS::Vector(0.0,0.0,-5.0));
//             ballPhy->setDebugNode();
//             ballPhy->setCollisionPartnerCategories(2);
//         }

    // create a crate
    SO<SceneThing> crate = new SceneThing(m_rootNode);
    crate->append(new Box(Vector(-4,-5,-40), Vector(4,0.1,40)));
    SO<CollisionBody> cratePhy = new CollisionBody(crate, CS_Box);
    cratePhy->setPosition(0, 0, -5);
    cratePhy->setRotation(0,0,1,18);

//     // create a sample plane
//     SO<SceneThing> plane = new SceneThing(m_rootNode);
//     SO<PlaneShape> planeShape = new PlaneShape(Vector(0,-1,0),-50);
//     SO<CollisionBody> planePhy = new SamplePlane(plane, planeShape);

    // create a car
    SO<SceneThing> car = new SceneThing(m_rootNode);
    m_car = new CarSimple(car);

    // collision groups
    // the ball does not collide with the plane
    boxPhy->setCollisionCategory(1);

//     PhysicsManager::get()->unlock();

    // create a camera
    SO<SceneThing> view = new SceneThing();
    view->append(new Camera(
        new Perspective(72, 0.1, 200.0),
        new LookAt(Vector(-70,6,40), Vector(0,0,0))));

    // let there be light
    view->append(new DistantLight(Vector(1,1,1)));
    view->append(new PointLight(Vector(0,1,-2)));

    m_canvas->append(view);
    m_canvas->append(m_rootNode);

    // create and connect behaviors
    m_canvas->append(new TrackBall(m_rootNode));

    // add keyboard callback
    m_canvas->append(m_keyCallBack = new BehaviorCallback());
    m_keyCallBack->setCanvasCallback(
            new MethodCallback<VrsTest>(this, &VrsTest::keyEvent));
    m_keyCallBack->activate();

#ifdef VRSODE_MULTITHREAD
    PhysicsManager::get()->setStepTime(0.005);
    PhysicsManager::get()->setStepSize(0.02);

    // PhysicsManager::get()->setPerformanceAutoAdjust(true);
    PhysicsManager::startThread();
#endif
}

void dropBall(int p);

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

//     PhysicsManager::get()->lock();

    if(event != NULL && event->pressed ())
        switch(event->keyCode())
        {
//             case Key::Escape: exit(0); break;
            case Key::Up: m_car->accelerate(1.0); break;
            case Key::Down: m_car->accelerate(-0.2); break;
            case Key::Left: m_car->steerLeft(1.0); break;
            case Key::Right: m_car->steerRight(1.0); break;
//             case Key::End: m_car->nos(1.0); break;
            case Key::Escape: m_car->handBreak(true); break;
            case Key::End: dropBall(0); break;
        }
    if(event != NULL && event->released())
        switch(event->keyCode())
        {
            case Key::Up: m_car->accelerate(0.0); break;
            case Key::Down: m_car->accelerate(0.0); break;
            case Key::Left: m_car->steerLeft(0.0); break;
            case Key::Right: m_car->steerRight(0.0); break;
            case Key::Escape: m_car->handBreak(false); break;
        }

//     PhysicsManager::get()->unlock();

    m_canvas->postForRedisplay();
}

#ifndef VRSODE_MULTITHREAD
void
singleThreadPhysicsUpdate(int p)
{
    PhysicsManager::get()->update(0.05);
    glutTimerFunc(50, singleThreadPhysicsUpdate, 0);
}
#endif

void
dropBall(int p)
{
    PhysicsManager::get()->lock();
    {
        SO<SceneThing> ball = new SceneThing(g_rootNode);
        ball->append(new Sphere(1.0));
        SO<PhysicsBody> ballPhy = new PhysicsBody(ball, CS_Box);
        ballPhy->setPosition(-40,30,-2);
        ballPhy->surface()->setBounce(1.0);
        ballPhy->surface()->setBounceVelocity(0.0);
        ballPhy->setAngularVelocity(VRS::Vector(0.0,0.0,-5.0));
        ballPhy->setDebugNode();
        // ballPhy->setCollisionPartnerCategories(2);
    }
    /*
    {
        SO<SceneThing> ball = new SceneThing(g_rootNode);
        ball->append(new Sphere(1.0));
        SO<PhysicsBody> ballPhy = new PhysicsBody(ball, CS_Sphere);
        ballPhy->setPosition(-40,30,2);
        ballPhy->surface()->setBounce(1.0);
        ballPhy->surface()->setBounceVelocity(0.0);
        ballPhy->setAngularVelocity(VRS::Vector(0.0,0.0,-5.0));
        ballPhy->setDebugNode();
        ballPhy->setCollisionPartnerCategories(2);
    }
    */
    PhysicsManager::get()->unlock();

    glutTimerFunc(1800, dropBall, 0);

}


// don't let SDL rename our main
#ifdef __APPLE__
  #undef main
#endif

int
main(int p_argc, char** p_argv)
{
    glutInit(&p_argc, p_argv);
    SDL_Init(SDL_INIT_EVENTTHREAD | SDL_INIT_TIMER);


    SO<VrsTest> application = new VrsTest;

#ifndef VRSODE_MULTITHREAD
    glutTimerFunc(20, singleThreadPhysicsUpdate, 0);
#endif

    glutTimerFunc(1000, dropBall, 0);
    glutMainLoop();

    PhysicsManager::get()->stop();
    PhysicsManager::get()->release();

    SDL_Quit();
    return 0;
}

/* trash code

    m_rootNode->append(new ConstantDetail(32, 64));

    for(int j = -200; j < 200; j+= 60)
    {
        for(int i = -200; i < 200; i+= 60)
        {
            SO<SceneThing> boxHouse = new SceneThing(m_rootNode);
            boxHouse->append(new VRS::ConstantDetail(1, 1));
            boxHouse->append(new Box(Vector(i,-10,j), Vector(i+10,20,j+10)));

            SO<CollisionBody> boxHousePhy =
                    PhysicsManager::get()->createCollisionBody(boxHouse, CS_Box);

            boxHousePhy->setPosition(0,-1,0);
            boxHousePhy->setDebugNode();
        }
    }

    m_car = new Car3DS(car);

    // create an mesh from scratch
    PhysicsBody* phyPlane = new PhysicsBody(
        new PolygonSet(PolygonSet::Quads,
            makeIterator(
                Vector(-1.0, 0.0,  1.0),
                Vector( 1.0, 0.0,  1.0),
                Vector( 1.0, 0.0, -1.0),
                Vector(-1.0, 0.0, -1.0)),
            0, 0,
            makeIterator(
                Color(0.1),
                Color(0.1),
                Color(0.9),
                Color(0.9))));

    childNode->append(phyPlane->polygonSet());

    SO<Car3DS>              m_car;
*/

---