OgreNewt_RayCastVehicle.cpp

Go to the documentation of this file.

#include "External/ogrenewt/OgreNewt_Stdafx.h"
#include "External/ogrenewt/OgreNewt_Body.h"
#include "External/ogrenewt/OgreNewt_World.h"
#include "External/ogrenewt/OgreNewt_Tools.h"
#include "External/ogrenewt/OgreNewt_CollisionPrimitives.h"
#include "External/ogrenewt/OgreNewt_RayCastVehicle.h"
#include <CustomDGRayCastCar.h>
 
namespace OgreNewt
{
  RaycastVehicle::Tire::Tire(RaycastVehicle* vehicle, Ogre::Node* node, const bool steer, const bool driving, const int id)
  {
    m_vehicle = vehicle;
    m_steer = steer;
    m_driving = driving;
    m_tireId = id;
    m_node = node;
 
    m_debug.m_node = 0;
    m_debug.m_visualDebug = 0;
  }
 
  RaycastVehicle::Tire::~Tire()
  {
    if (m_debug.m_node != 0)
    {
      if (m_debug.m_node->getParent())
                    m_debug.m_node->getParent()->removeChild(m_debug.m_node);
 
                  m_debug.m_node->detachAllObjects();
 
                  delete m_debug.m_visualDebug;
 
                  m_debug.m_node = 0;
                  m_debug.m_visualDebug = 0;
    }
  }
 
  void RaycastVehicle::Tire::showDebug(Ogre::SceneNode* debugRootNode)
  {
    Body* carBody = m_vehicle->getCarBody();
                Ogre::Vector3 pos;
                Ogre::Quaternion orient;
 
                carBody->getVisualPositionOrientation(pos, orient);
                dMatrix carMatrix(dQuaternion (orient.w, orient.x, orient.y, orient.z), dVector (pos.x, pos.y, pos.z, 1.0f));
 
    CustomDGRayCastCar::Tire& tire = m_vehicle->GetTire(m_tireId);
 
    if (m_debug.m_node == 0)
    {
                        std::ostringstream oss;
                        oss << "__OgreNewt__Debugger__Lines__" << &tire << "__";
                        m_debug.m_visualDebug = new Ogre::ManualObject(oss.str());
                        m_debug.m_node = debugRootNode->createChildSceneNode();
                        OgreNewt::Debugger& debug(carBody->getWorld()->getDebugger());
 
      debug.buildDebugObjectFromCollision(m_debug.m_visualDebug, Ogre::ColourValue(0, 0, 1, 1), tire.m_shape);
 
                        m_debug.m_node->attachObject(m_debug.m_visualDebug);
    }
 
    dMatrix tireBaseMatrix (m_vehicle->CalculateSuspensionMatrix(m_tireId, tire.m_posit) * m_vehicle->GetChassisMatrixLocal() * carMatrix);
                Converters::MatrixToQuatPos (&tireBaseMatrix[0][0], orient, pos);
 
                m_debug.m_node->setPosition(pos);
                m_debug.m_node->setOrientation(orient);
                if (!m_debug.m_node->getParent())
                        debugRootNode->addChild(m_debug.m_node);
  }
 
  void RaycastVehicle::Tire::getTireMatrix(dMatrix &outMatrix)
  {
    outMatrix = m_vehicle->CalculateTireMatrix(m_tireId);
  }
 
  void RaycastVehicle::Tire::updateNodePosition()
  {
    dMatrix tireMat;
    getTireMatrix(tireMat);
 
    Ogre::Quaternion quat;
    Ogre::Vector3 pos;
    OgreNewt::Converters::MatrixToQuatPos(&tireMat[0][0], quat, pos);
 
    // Set position in global terms.
    Ogre::Node* m_nodeParent = m_node->getParent();
 
    m_nodeParent->_update(true, true);
 
    Ogre::Vector3 gscale = m_nodeParent->_getDerivedScale();
      //if this is a bad scale we ignore the set position
      if (gscale.x == 0.0f || gscale.y == 0.0f || gscale.z == 0.0f)
        return;
    
    m_node->setPosition((m_nodeParent->_getDerivedOrientation().Inverse() * (pos - m_nodeParent->_getDerivedPosition()) / gscale));
    m_node->setOrientation((m_nodeParent->_getDerivedOrientation().Inverse() * quat));
  }
 
  RaycastVehicle::RaycastVehicle(const dMatrix carMatrix, OgreNewt::Body* carBody) : CustomDGRayCastCar(16, carMatrix, carBody->getNewtonBody())
  {
    m_body = carBody;
    m_body->setNodeUpdateJointNotify<RaycastVehicle>(&RaycastVehicle::setTireTransformCallback, this);
  }
 
  RaycastVehicle::~RaycastVehicle()
  {
    m_body->setNodeUpdateNotify(0);
 
    for (unsigned int i = 0; i < m_lTires.size(); i ++)
    {
      Tire* tire = m_lTires.at(i);
      delete tire;
                }
 
    m_lTires.clear();
  }
 
  OgreNewt::Body* RaycastVehicle::getCarBody()
  {
    return m_body;
  }
 
  void RaycastVehicle::getTireMatrix(unsigned int index, dMatrix &outMatrix)
  {
    if (index < m_lTires.size())
      m_lTires.at(index)->getTireMatrix(outMatrix);
  }
 
  void RaycastVehicle::ApplyTorque(dFloat torque)
  {
    for (unsigned int i = 0; i < m_lTires.size(); i ++)
    {
      Tire* tire = m_lTires.at(i);
      if (tire->isDriving())
        SetTireTorque(tire->getId(), torque);
                }
  }
 
  void RaycastVehicle::ApplySteering(dFloat angle)
  {
    for (unsigned int i = 0; i < m_lTires.size(); i ++)
    {
      Tire* tire = m_lTires.at(i);
      if (tire->isSteer())
        SetTireSteerAngleForce(tire->getId(), angle, 0.5f);
                }
  }
 
  void RaycastVehicle::ApplyBrake(dFloat brakeTorque)
  {
    for (unsigned int i = 0; i < m_lTires.size(); i ++)
    {
      Tire* tire = m_lTires.at(i);
      SetTireBrake(tire->getId(), brakeTorque);
                }
  }
 
  void RaycastVehicle::addTire(Ogre::Node* node, const Ogre::Real mass, const Ogre::Real radius, const Ogre::Real width, const Ogre::Real friction, const Ogre::Real susLength, const Ogre::Real susSpring, const Ogre::Real susShock, const bool steer, const bool driving)
  {
    //the class use a table of 16 for tires
    //todo send an exception
    if (GetTiresCount() > 16)
      return;
 
    Ogre::Quaternion quat = node->_getDerivedOrientation();
    Ogre::Vector3 pos = node->_getDerivedPosition();
    dMatrix nodeMat;
    OgreNewt::Converters::QuatPosToMatrix(quat, pos, &nodeMat[0][0]);
 
    AddSingleSuspensionTire(nodeMat, mass, radius, width, friction, susLength, susSpring, susShock, 1);
    int tireId = GetTiresCount() - 1;
 
    Tire* ntire = new Tire(this, node, steer, driving, tireId);
 
    /*
    if (steer)
    {
      Tire* ltire = 0;
      //search for an another directionnal tire
      for (unsigned int i = 0; i < m_lTires.size() && (ltire == 0); i ++)
      {
        if (!m_lTires.at(i)->getUsedByDiferencial() && m_lTires.at(i)->isSteer())
          ltire = m_lTires.at(i);
                  }
 
      if (ltire != 0)
      (
        ltire->setUsedByDiferencial(true);
        ntire->setUsedByDiferencial(true);
        AddSlipDifferencial(ltire->getId(), ntire->getId(), 0.5f);
      );
    }*/
 
    m_lTires.push_back(ntire);
  }
 
  RaycastVehicle::Tire* RaycastVehicle::getTire(unsigned int index)
  {
    if (index < m_lTires.size())
      return m_lTires[index];
    else
      return 0;
  }
 
  void RaycastVehicle::setTireTransformCallback(OgreNewt::Body* carBody)
        {
    for (unsigned int i = 0; i < m_lTires.size(); i ++)
    {
      Tire* tire = m_lTires.at(i);
      tire->updateNodePosition();
                }
  }
 
  void RaycastVehicle::showDebugData(Ogre::SceneNode* debugRootNode)
  {
    for (unsigned int i = 0; i < m_lTires.size(); i ++)
    {
      Tire* tire = m_lTires.at(i);
      tire->showDebug(debugRootNode);
                }
  }
 
  bool RaycastVehicle::getTireOnAir(unsigned int index)
  {
    if (index < m_lTires.size())
    {
      CustomDGRayCastCar::Tire& tire = GetTire(m_lTires.at(index)->getId());
      return (tire.m_tireIsOnAir == 1) ? true : false;
    }
 
    return true;
  }
 
  Ogre::Real RaycastVehicle::getTireAngularVelocity(unsigned int index)
  {
    if (index < m_lTires.size())
    {
      float omega = 0.0f;
      CustomDGRayCastCar::Tire& tire = GetTire(m_lTires.at(index)->getId());
      omega = tire.m_angularVelocity;
      return omega;
    }
 
    return 0.0f;
  }
 
  int RaycastVehicle::getTireIndexByNode(Ogre::Node* node)
  {
    int index = -1;
 
    for (unsigned int i = 0; i < m_lTires.size() && (index == -1); i ++)
    {
      Tire* tire = m_lTires.at(i);
      if (tire->getNode() == node)
        index = i;
                }
 
    return index;
  }
 
  /*void RaycastVehicle::SubmitConstraints(dFloat timestep, int threadIndex)
  {
  }
 
  void RaycastVehicle::GetInfo(NewtonJointRecord* info)
  {
  }*/
 
}   // end NAMESPACE OgreNewt