Code convention edits.

Source/Urho3D/Physics/RaycastVehicle.cpp

@@ -21,8 +21,6 @@
 //
 
 #include "../Core/Context.h"
-#include <Bullet/BulletDynamics/Vehicle/btRaycastVehicle.h>
-#include <Bullet/BulletDynamics/Dynamics/btDynamicsWorld.h>
 #include "../Physics/PhysicsUtils.h"
 #include "../Physics/RigidBody.h"
 #include "../Physics/PhysicsWorld.h"
@@ -30,6 +28,9 @@
 #include "../IO/Log.h"
 #include "../Physics/RaycastVehicle.h"
 
+#include <Bullet/BulletDynamics/Vehicle/btRaycastVehicle.h>
+#include <Bullet/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h>
+
 namespace Urho3D
 {
 
@@ -53,8 +54,9 @@ public:
         vehicleRayCaster_ = 0;
         if (vehicle_)
         {
-            if (physWorld_) {
-                btDynamicsWorld *pbtDynWorld = (btDynamicsWorld*) physWorld_->GetWorld();
+            if (physWorld_)
+            {
+                btDynamicsWorld* pbtDynWorld = physWorld_->GetWorld();
                 pbtDynWorld->removeAction(vehicle_);
             }
             delete vehicle_;
@@ -62,41 +64,42 @@ public:
         vehicle_ = 0;
     }
 
-    btRaycastVehicle *Get()
+    btRaycastVehicle* Get()
     {
         return vehicle_;
     }
 
-    void Init(Scene *scene, RigidBody *body)
+    void Init(Scene* scene, RigidBody* body)
     {
         int rightIndex = 0;
         int upIndex = 1;
         int forwardIndex = 2;
-        PhysicsWorld *pPhysWorld = scene->GetComponent<PhysicsWorld>();
-        btDynamicsWorld *pbtDynWorld = (btDynamicsWorld*) pPhysWorld->GetWorld();
-	if (!pbtDynWorld)
-		return;
+        PhysicsWorld* pPhysWorld = scene->GetComponent<PhysicsWorld>();
+        btDynamicsWorld* pbtDynWorld = pPhysWorld->GetWorld();
+        if (!pbtDynWorld)
+            return;
+
+        // Delete old vehicle & action first
         if (vehicleRayCaster_)
-                delete vehicleRayCaster_;
+            delete vehicleRayCaster_;
         if (vehicle_)
         {
-		pbtDynWorld->removeAction(vehicle_);
-		delete vehicle_;
+            pbtDynWorld->removeAction(vehicle_);
+            delete vehicle_;
         }
 
         vehicleRayCaster_ = new btDefaultVehicleRaycaster(pbtDynWorld);
-        btRigidBody *bthullBody = body->GetBody();
-        vehicle_ = new btRaycastVehicle(tuning_, bthullBody,
-                                            vehicleRayCaster_);
+        btRigidBody* bthullBody = body->GetBody();
+        vehicle_ = new btRaycastVehicle(tuning_, bthullBody, vehicleRayCaster_);
         pbtDynWorld->addVehicle(vehicle_);
 
         vehicle_->setCoordinateSystem(rightIndex, upIndex, forwardIndex);
         physWorld_ = pPhysWorld;
     }
 
-    btVehicleRaycaster *vehicleRayCaster_;
-    btRaycastVehicle *vehicle_;
-    btRaycastVehicle::btVehicleTuning   tuning_;
+    btVehicleRaycaster* vehicleRayCaster_;
+    btRaycastVehicle* vehicle_;
+    btRaycastVehicle::btVehicleTuning tuning_;
 };
 
 RaycastVehicle::RaycastVehicle(Context* context)
@@ -192,18 +195,18 @@ void RaycastVehicle::ApplyAttributes()
         float engineForce = value[index++].GetFloat();
         float brake = value[index++].GetFloat();
         float skidInfo = value[index++].GetFloat();
-        Node *wheelNode = GetScene()->GetNode(node_id);
+        Node* wheelNode = GetScene()->GetNode(node_id);
         if (!wheelNode)
         {
             URHO3D_LOGERROR("RaycastVehicle: Incorrect node id = " + String(node_id) + " index: " + String(index));
             continue;
         }
-        btRaycastVehicle *vehicle_ = vehicleData_->Get();
+        btRaycastVehicle* vehicle = vehicleData_->Get();
         int id = GetNumWheels();
         btVector3 connectionPointCS0(connectionPoint.x_, connectionPoint.y_, connectionPoint.z_);
         btVector3 wheelDirectionCS0(direction.x_, direction.y_, direction.z_);
         btVector3 wheelAxleCS(axle.x_, axle.y_, axle.z_);
-        btWheelInfo& wheel = vehicle_->addWheel(connectionPointCS0,
+        btWheelInfo& wheel = vehicle->addWheel(connectionPointCS0,
                                 wheelDirectionCS0,
                                 wheelAxleCS,
                                 restLength,
@@ -242,10 +245,10 @@ void RaycastVehicle::Init()
 
 void RaycastVehicle::FixedUpdate(float timeStep)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
+    btRaycastVehicle* vehicle = vehicleData_->Get();
     for (int i = 0; i < GetNumWheels(); i++)
     {
-        btWheelInfo whInfo = vehicle_->getWheelInfo(i);
+        btWheelInfo whInfo = vehicle->getWheelInfo(i);
         if (whInfo.m_engineForce != 0.0f || whInfo.m_steering != 0.0f)
         {
             hullBody_->Activate();
@@ -256,14 +259,14 @@ void RaycastVehicle::FixedUpdate(float timeStep)
 
 void RaycastVehicle::PostUpdate(float timeStep)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
+    btRaycastVehicle* vehicle = vehicleData_->Get();
     for (int i = 0; i < GetNumWheels(); i++)
     {
-        vehicle_->updateWheelTransform(i, true);
-        btTransform transform = vehicle_->getWheelTransformWS(i);
+        vehicle->updateWheelTransform(i, true);
+        btTransform transform = vehicle->getWheelTransformWS(i);
         Vector3 origin = ToVector3(transform.getOrigin());
         Quaternion qRot = ToQuaternion(transform.getRotation());
-        Node *pWheel = wheelNodes_[i];
+        Node* pWheel = wheelNodes_[i];
         pWheel->SetWorldPosition(origin);
         pWheel->SetWorldRotation(qRot * origRotation_[i]);
     }
@@ -271,11 +274,11 @@ void RaycastVehicle::PostUpdate(float timeStep)
 
 void RaycastVehicle::FixedPostUpdate(float timeStep)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
+    btRaycastVehicle* vehicle = vehicleData_->Get();
     Vector3 velocity = hullBody_->GetLinearVelocity();
     for (int i = 0; i < GetNumWheels(); i++)
     {
-        btWheelInfo& whInfo = vehicle_->getWheelInfo(i);
+        btWheelInfo& whInfo = vehicle->getWheelInfo(i);
         if (!WheelIsGrounded(i) && GetEngineForce(i) != 0.0f)
         {
             float delta;
@@ -329,18 +332,18 @@ float RaycastVehicle::GetWheelSkidInfoCumulative(int wheel) const
     return skidInfoCumulative_[wheel];
 }
 
-void RaycastVehicle::AddWheel(Node *wheelNode,
+void RaycastVehicle::AddWheel(Node* wheelNode,
                                 Vector3 wheelDirection, Vector3 wheelAxle,
                                 float restLength, float wheelRadius,
                                 bool frontWheel)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
+    btRaycastVehicle* vehicle = vehicleData_->Get();
     int id = GetNumWheels();
     Vector3 connectionPoint = wheelNode->GetWorldPosition() - node_->GetWorldPosition();
     btVector3 connectionPointCS0(connectionPoint.x_, connectionPoint.y_, connectionPoint.z_);
     btVector3 wheelDirectionCS0(wheelDirection.x_, wheelDirection.y_, wheelDirection.z_);
     btVector3 wheelAxleCS(wheelAxle.x_, wheelAxle.y_, wheelAxle.z_);
-    btWheelInfo& wheel = vehicle_->addWheel(connectionPointCS0,
+    btWheelInfo& wheel = vehicle->addWheel(connectionPointCS0,
                             wheelDirectionCS0,
                             wheelAxleCS,
                             restLength,
@@ -357,126 +360,126 @@ void RaycastVehicle::AddWheel(Node *wheelNode,
 
 void RaycastVehicle::ResetSuspension()
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    vehicle_->resetSuspension();
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    vehicle->resetSuspension();
 }
 
 void RaycastVehicle::UpdateWheelTransform(int wheel, bool interpolated)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    vehicle_->updateWheelTransform(wheel, interpolated);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    vehicle->updateWheelTransform(wheel, interpolated);
 }
 
 Vector3 RaycastVehicle::GetWheelPosition(int wheel)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btTransform transform = vehicle_->getWheelTransformWS(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btTransform transform = vehicle->getWheelTransformWS(wheel);
     Vector3 origin = ToVector3(transform.getOrigin());
     return origin;
 }
 
 Quaternion RaycastVehicle::GetWheelRotation(int wheel)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btTransform transform = vehicle_->getWheelTransformWS(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btTransform transform = vehicle->getWheelTransformWS(wheel);
     Quaternion rotation = ToQuaternion(transform.getRotation());
     return rotation;
 }
 
 Vector3 RaycastVehicle::GetWheelConnectionPoint(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo whInfo = vehicle->getWheelInfo(wheel);
     return ToVector3(whInfo.m_chassisConnectionPointCS);
 }
 
 void RaycastVehicle::SetSteeringValue(int wheel, float steeringValue)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    vehicle_->setSteeringValue(steeringValue, wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    vehicle->setSteeringValue(steeringValue, wheel);
 }
 
 float RaycastVehicle::GetSteeringValue(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_steering;
 }
 
 void RaycastVehicle::SetWheelSuspensionStiffness(int wheel, float stiffness)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     whInfo.m_suspensionStiffness = stiffness;
 }
 
 float RaycastVehicle::GetWheelSuspensionStiffness(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_suspensionStiffness;
 }
 
 void RaycastVehicle::SetWheelDampingRelaxation(int wheel, float damping)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     whInfo.m_wheelsDampingRelaxation = damping;
 }
 
 float RaycastVehicle::GetWheelDampingRelaxation(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_wheelsDampingRelaxation;
 }
 
 void RaycastVehicle::SetWheelDampingCompression(int wheel, float compression)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     whInfo.m_wheelsDampingCompression = compression;
 }
 
 float RaycastVehicle::GetWheelDampingCompression(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_wheelsDampingCompression;
 }
 
 void RaycastVehicle::SetWheelFrictionSlip(int wheel, float slip)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     whInfo.m_frictionSlip = slip;
 }
 
 float RaycastVehicle::GetWheelFrictionSlip(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_frictionSlip;
 }
 
 void RaycastVehicle::SetWheelRollInfluence(int wheel, float rollInfluence)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     whInfo.m_rollInfluence = rollInfluence;
 }
 
 Vector3 RaycastVehicle::GetContactPosition(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     return ToVector3(whInfo.m_raycastInfo.m_contactPointWS);
 }
 
 Vector3 RaycastVehicle::GetContactNormal(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     return ToVector3(whInfo.m_raycastInfo.m_contactNormalWS);
 }
 
@@ -487,145 +490,145 @@ float RaycastVehicle::GetWheelSideSlipSpeed(int wheel) const
 
 float RaycastVehicle::GetWheelRollInfluence(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_rollInfluence;
 }
 
 void RaycastVehicle::SetWheelRadius(int wheel, float wheelRadius)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     whInfo.m_wheelsRadius = wheelRadius;
 }
 
 float RaycastVehicle::GetWheelRadius(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_wheelsRadius;
 }
 
 void RaycastVehicle::SetEngineForce(int wheel, float force)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    vehicle_->applyEngineForce(force, wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    vehicle->applyEngineForce(force, wheel);
 }
 
 float RaycastVehicle::GetEngineForce(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_engineForce;
 }
 
 void RaycastVehicle::SetBrake(int wheel, float force)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    vehicle_->setBrake(force, wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    vehicle->setBrake(force, wheel);
 }
 
 float RaycastVehicle::GetBrake(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_brake;
 }
 
 int RaycastVehicle::GetNumWheels() const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    return vehicle_->getNumWheels();
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    return vehicle->getNumWheels();
 }
 
-Node *RaycastVehicle::GetWheelNode(int wheel) const
+Node* RaycastVehicle::GetWheelNode(int wheel) const
 {
     return wheelNodes_[wheel];
 }
 
 void RaycastVehicle::SetMaxSuspensionTravel(int wheel, float maxSuspensionTravel)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     whInfo.m_maxSuspensionTravelCm = maxSuspensionTravel;
 }
 
 float RaycastVehicle::GetMaxSuspensionTravel(int wheel)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_maxSuspensionTravelCm;
 }
 
 void RaycastVehicle::SetWheelDirection(int wheel, Vector3 direction)
 {
     btVector3 dir(direction.x_, direction.y_, direction.z_);
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     whInfo.m_wheelDirectionCS = dir;
 }
 
 Vector3 RaycastVehicle::GetWheelDirection(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     return ToVector3(whInfo.m_wheelDirectionCS);
 }
 
 void RaycastVehicle::SetWheelAxle(int wheel, Vector3 axle)
 {
     btVector3 ax(axle.x_, axle.y_, axle.z_);
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     whInfo.m_wheelAxleCS = ax;
 }
 
 Vector3 RaycastVehicle::GetWheelAxle(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     return ToVector3(whInfo.m_wheelAxleCS);
 }
 
 void RaycastVehicle::SetWheelRestLength(int wheel, float length)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     whInfo.m_suspensionRestLength1 = length;
 }
 
 float RaycastVehicle::GetWheelRestLength(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_suspensionRestLength1;
 }
 
 void RaycastVehicle::SetWheelSkidInfo(int wheel, float factor)
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     whInfo.m_skidInfo = factor;
 }
 
 float RaycastVehicle::GetWheelSkidInfo(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_skidInfo;
 }
 
 bool RaycastVehicle::IsFrontWheel(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo& whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo& whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_bIsFrontWheel;
 }
 
 bool RaycastVehicle::WheelIsGrounded(int wheel) const
 {
-    btRaycastVehicle *vehicle_ = vehicleData_->Get();
-    btWheelInfo whInfo = vehicle_->getWheelInfo(wheel);
+    btRaycastVehicle* vehicle = vehicleData_->Get();
+    btWheelInfo whInfo = vehicle->getWheelInfo(wheel);
     return whInfo.m_raycastInfo.m_isInContact;
 }
 
@@ -646,7 +649,7 @@ void RaycastVehicle::ResetWheels()
     {
         UpdateWheelTransform(i, true);
         Vector3 origin = GetWheelPosition(i);
-        Node *wheelNode = GetWheelNode(i);
+        Node* wheelNode = GetWheelNode(i);
         wheelNode->SetWorldPosition(origin);
     }
 }
@@ -658,7 +661,7 @@ VariantVector RaycastVehicle::GetWheelDataAttr() const
     ret.Push(GetNumWheels());
     for (int i = 0; i < GetNumWheels(); i++)
     {
-        Node *wNode = GetWheelNode(i);
+        Node* wNode = GetWheelNode(i);
         int node_id = wNode->GetID();
         URHO3D_LOGDEBUG("RaycastVehicle: Saving node id = " + String(node_id));
         ret.Push(node_id);

Source/Urho3D/Physics/RaycastVehicle.h

@@ -48,7 +48,7 @@ public:
     virtual void ApplyAttributes();
 
     /// Add a wheel. All parameters are relative to RigidBody / node.
-    void AddWheel(Node *wheelNode, Vector3 wheelDirection, Vector3 wheelAxle, float restLength, float wheelRadius, bool frontWheel);
+    void AddWheel(Node* wheelNode, Vector3 wheelDirection, Vector3 wheelAxle, float restLength, float wheelRadius, bool frontWheel);
     /// Reset all suspension.
     void ResetSuspension(void);
     /// Update transform for particular wheel.
@@ -107,7 +107,7 @@ public:
     /// Get number of attached wheels.
     int GetNumWheels() const;
     /// Get node of the wheel.
-    Node *GetWheelNode(int wheel) const;
+    Node* GetWheelNode(int wheel) const;
     /// Get steering value of particular wheel.
     float GetSteeringValue(int wheel) const;
     /// Get suspension stiffness for particular wheel.
@@ -164,7 +164,7 @@ private:
     /// Hull RigidBody
     WeakPtr<RigidBody> hullBody_;
     /// Opaque Bullet data hidden from public
-    RaycastVehicleData *vehicleData_;
+    RaycastVehicleData* vehicleData_;
     /// Nodes of all wheels
     Vector<Node*> wheelNodes_;
     /// All wheels original rotations. These are applied in addition to wheel rotations by btRaycastVehicle