vrsode/src/Car3DS.cpp

Go to the documentation of this file.

/*
#include "Car3DS.h"
#include "PhysicsManager.h"
#include "LogManager.h"

#include <vrs/box.h>
#include <vrs/color.h>
#include <vrs/io/filedataresource.h>
#include <vrs/torus.h>
#include <vrs/io/threedsreader.h>
#include <vrs/vector.h>
#include <vrs/opengl/shapematerialgl.h>
#include <vrs/sg/scenegraphprinter.h>


namespace vrsode
{

Car3DS::Car3DS(VRS::SO<VRS::SceneThing> p_parent)
{
    m_springLengthFront = 0.0;
    m_springLengthRear = 0.0;

    m_springPowerFront = 31;
    m_springPowerRear = 27;

    m_springSpeedFront = 1.4;
    m_springSpeedRear = 1.4;

    m_wheelSizeFront = 1.0;
    m_wheelSizeRear = 1.0;
    m_wheelMass = 0.01;

    m_bodyMass = 8;


    m_rootNode = new VRS::SceneThing(p_parent);
    m_rootNode ->append(new VRS::ShapeMaterialGL(
            VRS::Color(0.1, 0.1, 0.1), VRS::Color(0.1, 0.1, 0.1)));

    VRS::SO<VRS::SceneThing> st;

    // collision space
//  m_space = PhysicsManager::get()->createSimpleSpace(0);

    // chassis body
    st = new VRS::SceneThing(m_rootNode);
    st->append(new VRS::ShapeMaterialGL(
            VRS::Color(1.0, 0.3, 0.3), VRS::Color(0.15, 0.05, 0.05)));

    VRS::SO<VRS::ThreeDSReader> reader = new VRS::ThreeDSReader();


    st->append(((VRS::SceneThing*)reader->
            readObject("car01chassis.3ds", "Cube.002")->object(2))->object(2));

//     st->append(new VRS::Box(VRS::Vector(-2.0, -0.2, -0.8),
//                             VRS::Vector(2.0, 0.2, 0.8)));

    for(int i = 0; i < st->objects(); i++)
        std::cout << ((VRS::SceneThing*)st->object(i))->
                getObjectName() << std::endl;

    m_chassis = PhysicsManager::get()->createPhysicsBody(st, CS_Box);
    m_chassis->setRotation(1,0,0,0,0,0,90);
//     m_chassis->setDebugNode();
//  m_space->addChild(m_chassis);

    // wheel body front left
    st = new VRS::SceneThing(m_rootNode);
    st->append(new VRS::Torus(m_wheelSizeFront));
    m_wheelFL = PhysicsManager::get()->createPhysicsBody(st, CS_Sphere);
//     m_wheelFL->setDebugNode();
//  m_space->addChild(m_wheelFL);

    // suspension body front left
    st = new VRS::SceneThing(m_rootNode);
    st->append(new VRS::Box(VRS::Vector(-0.01, -0.01, -0.01),
                            VRS::Vector( 0.01,  0.01,  0.01)));
    m_suspensionFL = PhysicsManager::get()->createPhysicsBody(st, CS_Box);
//     m_suspensionFL->setDebugNode();
//  m_space->addChild(m_suspensionFL);

    // steering body front left
    st = new VRS::SceneThing(m_rootNode);
    st->append(new VRS::Box(VRS::Vector(-0.01, -0.01, -0.01),
                            VRS::Vector( 0.01,  0.01,  0.01)));
    m_steerFL = PhysicsManager::get()->createPhysicsBody(st, CS_Box);
//     m_steerFL->setDebugNode();
//  m_space->addChild(m_steerFL);

    // wheel body front right
    st = new VRS::SceneThing(m_rootNode);
    st->append(new VRS::Torus(m_wheelSizeFront));
    m_wheelFR = PhysicsManager::get()->createPhysicsBody(st, CS_Sphere);
//     m_wheelFR->setDebugNode();
//  m_space->addChild(m_wheelFR);

    // suspension body front right
    st = new VRS::SceneThing(m_rootNode);
    st->append(new VRS::Box(VRS::Vector(-0.01, -0.01, -0.01),
                            VRS::Vector( 0.01,  0.01,  0.01)));
    m_suspensionFR = PhysicsManager::get()->createPhysicsBody(st, CS_Box);
//     m_suspensionFR->setDebugNode();
//  m_space->addChild(m_suspensionFR);

    // steering body front right
    st = new VRS::SceneThing(m_rootNode);
    st->append(new VRS::Box(VRS::Vector(-0.01, -0.01, -0.01),
                            VRS::Vector( 0.01,  0.01,  0.01)));
    m_steerFR = PhysicsManager::get()->createPhysicsBody(st, CS_Box);
//     m_steerFR->setDebugNode();
//  m_space->addChild(m_steerFR);

    // wheel body rear left
    st = new VRS::SceneThing(m_rootNode);
    st->append(new VRS::Torus(m_wheelSizeRear));
    m_wheelRL = PhysicsManager::get()->createPhysicsBody(st, CS_Sphere);
//     m_wheelRL->setDebugNode();
//  m_space->addChild(m_wheelRL);

    // suspension body rear left
    st = new VRS::SceneThing(m_rootNode);
    st->append(new VRS::Box(VRS::Vector(-0.01, -0.01, -0.01),
                            VRS::Vector( 0.01,  0.01,  0.01)));
    m_suspensionRL = PhysicsManager::get()->createPhysicsBody(st, CS_Box);
//     m_suspensionRL->setDebugNode();
//  m_space->addChild(m_suspensionRL);

    // wheel body rear right
    st = new VRS::SceneThing(m_rootNode);
    st->append(new VRS::Torus(m_wheelSizeRear));
    m_wheelRR = PhysicsManager::get()->createPhysicsBody(st, CS_Sphere);
//     m_wheelRR->setDebugNode();
//  m_space->addChild(m_wheelRR);

    // suspension body rear right
    st = new VRS::SceneThing(m_rootNode);
    st->append(new VRS::Box(VRS::Vector(-0.01, -0.01, -0.01),
                            VRS::Vector( 0.01,  0.01,  0.01)));
    m_suspensionRR = PhysicsManager::get()->createPhysicsBody(st, CS_Box);
//     m_suspensionRR->setDebugNode();
//  m_space->addChild(m_suspensionRR);

    // rotate wheels to position
    m_wheelFL->setRotation(1,0,0,0,0,0,90);
    m_wheelFR->setRotation(1,0,0,0,0,0,90);
    m_wheelRL->setRotation(1,0,0,0,0,0,90);
    m_wheelRR->setRotation(1,0,0,0,0,0,90);

    double maxSpringLength = m_springLengthFront > m_springLengthRear ?
                             m_springLengthFront : m_springLengthRear;

    // position chassis bodies
    m_chassis->setPosition( 0.0, 1.6 + maxSpringLength,  0.0);

    // position wheel bodies
    m_wheelFL->setPosition( 2.1, 1.6 + maxSpringLength, -1.8);
    m_wheelFR->setPosition( 2.1, 1.6 + maxSpringLength,  1.8);
    m_wheelRL->setPosition(-2.1, 1.6 + maxSpringLength, -1.8);
    m_wheelRR->setPosition(-2.1, 1.6 + maxSpringLength,  1.8);

    // position steer bodies
    m_steerFL->setPosition( 2.3, 1.0, -0.5);
    m_steerFR->setPosition( 2.3, 1.0,  0.5);

    // position suspension bodies
    m_suspensionFL->setPosition( 2.1, 1.1, -0.5);
    m_suspensionFR->setPosition( 2.1, 1.1,  0.5);
    m_suspensionRL->setPosition(-2.1, 1.1, -0.5);
    m_suspensionRR->setPosition(-2.1, 1.1,  0.5);

    // joints
    // front left
    // connect wheel and steering
    m_axisFL = PhysicsManager::get()->
            createHingeJoint(m_wheelFL, m_steerFL,
                             VRS::Vector( 2.1, 1.6 + maxSpringLength,-1.8),
                             VRS::Vector(0,0,1));

    // connect steering and suspension
    m_steerControlFL = PhysicsManager::get()->
            createHingeJoint(m_steerFL, m_suspensionFL,
                             VRS::Vector( 2.1, 0.7, -1.8),
                             VRS::Vector(0,1,0));

    // connect suspension and chassis
    m_springFL = PhysicsManager::get()->
            createSliderJoint(m_chassis, m_suspensionFL,
                             VRS::Vector(0,1,0));

    // front right
    // connect wheel and steering
    m_axisFR = PhysicsManager::get()->
            createHingeJoint(m_wheelFR, m_steerFR,
                             VRS::Vector( 2.1, 1.6 + maxSpringLength, 1.8),
                             VRS::Vector(0,0,1));


    // connect steering and suspension
    m_steerControlFR = PhysicsManager::get()->
            createHingeJoint(m_steerFR, m_suspensionFR,
                             VRS::Vector( 2.1, 0.7, 1.8),
                             VRS::Vector(0,1,0));


    // connect suspension and chassis
    m_springFR = PhysicsManager::get()->
            createSliderJoint(m_chassis, m_suspensionFR,
                             VRS::Vector(0,1,0));

    // rear left
    // connect wheel and suspension
    m_axisRL = PhysicsManager::get()->
            createHingeJoint(m_suspensionRL, m_wheelRL,
                             VRS::Vector(-2.1, 1.6 + maxSpringLength,-1.8),
                             VRS::Vector(0,0,1));

    // connect suspension and chassis
    m_springRL = PhysicsManager::get()->
            createSliderJoint(m_chassis, m_suspensionRL,
                             VRS::Vector(0,1,0));

    // rear right
    // connect wheel and suspension
    m_axisRR = PhysicsManager::get()->
            createHingeJoint(m_suspensionRR, m_wheelRR,
                             VRS::Vector(-2.1, 1.6 + maxSpringLength, 1.8),
                             VRS::Vector(0,0,1));

    // connect suspension and chassis
    m_springRR = PhysicsManager::get()->
            createSliderJoint(m_chassis, m_suspensionRR,
                             VRS::Vector(0,1,0));

    // high speed rotation mode
    m_wheelFL->setHighSpeedRotationMode(true);
    m_wheelFR->setHighSpeedRotationMode(true);
    m_wheelRL->setHighSpeedRotationMode(true);
    m_wheelRR->setHighSpeedRotationMode(true);

    m_wheelFL->setHighSpeedRotationAxis(VRS::Vector(0,0,1));
    m_wheelFR->setHighSpeedRotationAxis(VRS::Vector(0,0,1));
    m_wheelRL->setHighSpeedRotationAxis(VRS::Vector(0,0,1));
    m_wheelRR->setHighSpeedRotationAxis(VRS::Vector(0,0,1));


    // set masses
    m_chassis->setMass(m_bodyMass, VRS::Vector(0,-30,0));
    m_wheelFL->setMass(m_wheelMass);
    m_wheelFR->setMass(m_wheelMass);
    m_wheelRL->setMass(m_wheelMass);
    m_wheelRR->setMass(m_wheelMass);

    // configure suspension springs
    m_springFL->setHighStop(0.0);
    m_springFL->setLowStop(-m_springLengthFront);
    m_springFL->setMotorVelocity(m_springSpeedFront);
    m_springFL->setMotorMaxForce(m_springPowerFront);

    m_springFR->setHighStop(0.0);
    m_springFR->setLowStop(-m_springLengthFront);
    m_springFR->setMotorVelocity(m_springSpeedFront);
    m_springFR->setMotorMaxForce(m_springPowerFront);

    m_springRL->setHighStop(0.0);
    m_springRL->setLowStop(-m_springLengthRear);
    m_springRL->setMotorVelocity(m_springSpeedRear);
    m_springRL->setMotorMaxForce(m_springPowerRear);

    m_springRR->setHighStop(0.0);
    m_springRR->setLowStop(-m_springLengthRear);
    m_springRR->setMotorVelocity(m_springSpeedRear);
    m_springRR->setMotorMaxForce(m_springPowerRear);

    // configure steering
    m_steerControlFL->setHighStop(0.0);
    m_steerControlFL->setLowStop(0.0);
    m_steerControlFR->setHighStop(0.0);
    m_steerControlFR->setLowStop(0.0);

//     // cfm
//     double cfm = 0.000001;
//
//     m_axisFL->setCFM(cfm);
//     m_axisFR->setCFM(cfm);
//     m_axisRL->setCFM(cfm);
//     m_axisRR->setCFM(cfm);
//
//     m_steerControlFL->setCFM(cfm);
//     m_steerControlFR->setCFM(cfm);
//
//     m_springFL->setCFM(cfm);
//     m_springFR->setCFM(cfm);
//     m_springRL->setCFM(cfm);
//     m_springRR->setCFM(cfm);

    // done :)
}

Car3DS::~Car3DS()
{
    // TODO: cleanup
}

void
Car3DS::accelerate(double p_amount)
{

    if(p_amount)
    {
        m_axisRL->setMotorVelocity(100 * p_amount);
        m_axisRR->setMotorVelocity(100 * p_amount);
        m_axisRL->setMotorMaxForce(50);
        m_axisRR->setMotorMaxForce(50);
    }
    else
    {
        m_axisRL->setMotorVelocity(100);
        m_axisRR->setMotorVelocity(100);
        m_axisRL->setMotorMaxForce(0);
        m_axisRR->setMotorMaxForce(0);
    }
}

void
Car3DS::steerLeft(double p_amount)
{
    m_steerControlFL->setHighStop(-0.55 * p_amount);
    m_steerControlFL->setLowStop(-0.55 * p_amount);
    m_steerControlFR->setHighStop(-0.55 * p_amount);
    m_steerControlFR->setLowStop(-0.55 * p_amount);
}

void
Car3DS::steerRight(double p_amount)
{
    m_steerControlFL->setHighStop(0.55 * p_amount);
    m_steerControlFL->setLowStop(0.55 * p_amount);
    m_steerControlFR->setHighStop(0.55 * p_amount);
    m_steerControlFR->setLowStop(0.55 * p_amount);
}

void
Car3DS::nos(double p_amount)
{
    m_chassis->addRelativeForceAtRelativePosition(
            VRS::Vector(350 * p_amount,-40,0),
            VRS::Vector(-2,0,0));
}

void
Car3DS::handBreak(bool p_enable)
{
    if(p_enable)
    {
        m_axisFL->setMotorVelocity(0);
        m_axisFR->setMotorVelocity(0);
        m_axisFL->setMotorMaxForce(15);
        m_axisFR->setMotorMaxForce(15);
        m_axisRL->setMotorVelocity(0);
        m_axisRR->setMotorVelocity(0);
        m_axisRL->setMotorMaxForce(200);
        m_axisRR->setMotorMaxForce(200);
    }
    else
    {
        m_axisFL->setMotorVelocity(100);
        m_axisFR->setMotorVelocity(100);
        m_axisFL->setMotorMaxForce(0);
        m_axisFR->setMotorMaxForce(0);
        m_axisRL->setMotorVelocity(100);
        m_axisRR->setMotorVelocity(100);
        m_axisRL->setMotorMaxForce(0);
        m_axisRR->setMotorMaxForce(0);
    }
}

VRS::SO<VRS::SceneThing>
Car3DS::sceneThing()
{
    return m_chassis->sceneThing();
}

void
Car3DS::attachCamera(VRS::SO<VRS::Camera> p_camera)
{

}

}*/

---