RaceCar.cpp

Go to the documentation of this file.

#include "RaceCar.h"

REGISTER_ODE_OBJECT_CLASS( RaceCar )

RaceCar::~RaceCar()
{
}

void RaceCar::Init()
{
    MercuryODEObjectLoadable::Init();
}

bool RaceCar::LoadFromINI( MercuryINI & pINI, const MString & sShapeName, const dWorldID &oWorld )
{
    if ( !MercuryODEObjectLoadable::LoadFromINI( pINI, sShapeName, oWorld ) )
        return false;

    for( unsigned i = 0; i < 4; i++ )
    {
        MString sName = GetName() + ssprintf( "Wheel%d", i );
        MercuryODEObjectLoadable * c = (*ToMakeODEs)["MercuryODEObjectLoadable"]( sName );

        c->m_oSpace = m_oSpace;
        c->m_bBodied = true;

        switch( i )
        {
        case 0: c->m_pPrePosition = MercuryPoint( 2.5, 4, 0 ); break;
        case 1: c->m_pPrePosition = MercuryPoint( -2.5, 4, 0 ); break;
        case 2: c->m_pPrePosition = MercuryPoint( 2.5, -4, 0 ); break;
        case 3: c->m_pPrePosition = MercuryPoint( -2.5, -4, 0 ); break;
        }

        c->m_pPrePosition += m_pPrePosition;

        c->m_oWorldSpace = m_oSpace;
        c->SetName( sName );
        c->Init();

        c->LoadFromINI( pINI, "RCWheel", oWorld );
        
        m_pWorld->AddObject( c, true );
        oWheels[i] = c;
    }

    for( unsigned j = 0; j < 4; j++ )
    {
        dBodyEnable( oWheels[j]->m_oBody );
        
        MQuaternion qThis = (float*)dBodyGetRotation( m_oBody );
        MercuryPoint pThis = dBodyGetPosition( m_oBody );

        //Rotated axis of rotation (for all wheels, tanget to the car)
        MercuryPoint p = (qThis * MercuryPoint(1,0,0) * qThis.conjugate()).ToPoint();

        m_Wheel[j] = dJointCreateHinge2( m_pWorld->GetWorldID(), 0 );
        dJointAttach( m_Wheel[j], m_oBody, oWheels[j]->m_oBody );
        const dReal * rearWheelPos = dBodyGetPosition( oWheels[j]->m_oBody );
        dJointSetHingeAnchor( m_Wheel[j], rearWheelPos[0], rearWheelPos[1], rearWheelPos[2] );
        dJointSetHinge2Axis1( m_Wheel[j], 0, 0, 1 );
        dJointSetHinge2Axis2( m_Wheel[j], 1, 0, 0 );
        dJointSetHinge2Param (m_Wheel[j],dParamFudgeFactor,1.1);
    
        if( j < 2 )
        {
            dJointSetHinge2Param (m_Wheel[j],dParamLoStop,0);   //Steering
            dJointSetHinge2Param (m_Wheel[j],dParamHiStop,0);
        } else {
            dJointSetHinge2Param (m_Wheel[j],dParamLoStop,0);
            dJointSetHinge2Param (m_Wheel[j],dParamHiStop,0);
        }
    }

    return true;
}

void RaceCar::PreCycleUpdate( const float dTime )
{
    for( unsigned i = 0; i < 4; i++ )
    {
        dBodyEnable( oWheels[i]->m_oBody );
    }

    if( m_bBreaking )
    {
        dBodySetAngularVel( oWheels[0]->m_oBody, 0, 0, 0 );
        dBodySetAngularVel( oWheels[1]->m_oBody, 0, 0, 0 );
        dBodySetAngularVel( oWheels[2]->m_oBody, 0, 0, 0 );
        dBodySetAngularVel( oWheels[3]->m_oBody, 0, 0, 0 );
    }
    else
    {
        float fTotalDisjointSpeed = 
            dJointGetHinge2Angle2Rate( m_Wheel[0] ) + dJointGetHinge2Angle2Rate( m_Wheel[2] ) +
            dJointGetHinge2Angle2Rate( m_Wheel[1] ) + dJointGetHinge2Angle2Rate( m_Wheel[3] );


        if( fTotalDisjointSpeed < m_fSpeed )
        {
            float fTorque = m_fSpeed - fTotalDisjointSpeed;
            fTorque *= 1/dTime;
            dJointAddHinge2Torques (m_Wheel[3], 0,fTorque);
            dJointAddHinge2Torques (m_Wheel[2], 0,fTorque);
//          dJointAddHinge2Torques (m_Wheel[1], 0,fTorque);
//          dJointAddHinge2Torques (m_Wheel[0], 0,fTorque);
        }
    }

    for( unsigned k = 0; k < 2; k++ )
    {
        dJointSetHinge2Param( m_Wheel[k], dParamLoStop, m_fSteer ); //Steering
        dJointSetHinge2Param( m_Wheel[k], dParamHiStop, m_fSteer );
    }

    MercuryODEObjectLoadable::PreCycleUpdate( dTime );
}

bool RaceCar::Collide( MercuryODEObject * pHit, dContact &pContact, MercuryODEWorld * pWorld )
{
    if( pHit == this )
        return false;
    return true;
}

void RaceCar::Message( int Message, PStack & data, const MString & name )
{
    MercuryODEObjectLoadable::Message( Message, data, name );
}



/* 
 * Copyright (c) 2007, Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by