refactore physics, work in progress

Author: codenamecpp

src/GameCheatsWindow.cpp

@@ -68,7 +68,9 @@ void GameCheatsWindow::DoUI(ImGuiIO& imguiContext)
     {
         ImGui::Separator();
         glm::vec3 pedPosition = pedestrian->mPhysicsComponent->GetPosition();
-        ImGui::Text("pos: %f, %f, %f", pedPosition.x, pedPosition.y, pedPosition.z);
+        ImGui::Text("physical pos: %.3f, %.3f, %.3f", pedPosition.x, pedPosition.y, pedPosition.z);
+        glm::vec3 logicalPosition = Convert::MetersToMapUnits(pedPosition);
+        ImGui::Text("logical pos: %.3f, %.3f, %.3f", logicalPosition.x, logicalPosition.y, logicalPosition.z);
 
         cxx::angle_t pedHeading = pedestrian->mPhysicsComponent->GetRotationAngle();
         ImGui::Text("heading: %f", pedHeading.mDegrees);
@@ -146,9 +148,13 @@ void GameCheatsWindow::DoUI(ImGuiIO& imguiContext)
 
     if (ImGui::CollapsingHeader("Ped"))
     {
-        ImGui::SliderFloat("Turn speed", &gGameParams.mPedestrianTurnSpeed, 10.0f, 640.0f, "%.2f");
-        ImGui::SliderFloat("Run speed", &gGameParams.mPedestrianRunSpeed, 0.1f, 16.0f, "%.2f");
-        ImGui::SliderFloat("Walk speed", &gGameParams.mPedestrianWalkSpeed, 0.1f, 16.0f, "%.2f");
+        ImGui::SliderFloat("Turn speed (degs/s)", &gGameParams.mPedestrianTurnSpeed, 10.0f, 640.0f, "%.2f");
+        ImGui::SliderFloat("Run speed (m/s)", &gGameParams.mPedestrianRunSpeed, 
+            Convert::MapUnitsToMeters(0.1f), 
+            Convert::MapUnitsToMeters(16.0f), "%.2f");
+        ImGui::SliderFloat("Walk speed (m/s)", &gGameParams.mPedestrianWalkSpeed, 
+            Convert::MapUnitsToMeters(0.1f), 
+            Convert::MapUnitsToMeters(16.0f), "%.2f");
     }
 
     if (ImGui::CollapsingHeader("Graphics"))

src/GameMapHelpers.cpp

@@ -98,47 +98,47 @@ void GameMapHelpers::PutBlockFace(GameMapManager& cityScape, MapMeshData& meshDa
     {
         // N, 26 low, high
         case 1: case 2:
-            cubePoints[0].y = cubePoints[1].y = ((slope - 1) / 2.0f);
-            cubePoints[4].y = cubePoints[5].y = ((slope - 1 + 1) / 2.0f);
+            cubePoints[0].y = cubePoints[1].y = ((slope - 1) / 2.0f) * METERS_PER_MAP_UNIT;
+            cubePoints[4].y = cubePoints[5].y = ((slope - 1 + 1) / 2.0f) * METERS_PER_MAP_UNIT;
         break;
         // S, 26 low, high
         case 3: case 4:
-            cubePoints[4].y = cubePoints[5].y = ((slope - 3) / 2.0f);
-            cubePoints[0].y = cubePoints[1].y = ((slope - 3 + 1) / 2.0f);
+            cubePoints[4].y = cubePoints[5].y = ((slope - 3) / 2.0f) * METERS_PER_MAP_UNIT;
+            cubePoints[0].y = cubePoints[1].y = ((slope - 3 + 1) / 2.0f) * METERS_PER_MAP_UNIT;
         break;
         // W, 26 low, high
         case 5: case 6:
-            cubePoints[1].y = cubePoints[5].y = ((slope - 5) / 2.0f);
-            cubePoints[0].y = cubePoints[4].y = ((slope - 5 + 1) / 2.0f);
+            cubePoints[1].y = cubePoints[5].y = ((slope - 5) / 2.0f) * METERS_PER_MAP_UNIT;
+            cubePoints[0].y = cubePoints[4].y = ((slope - 5 + 1) / 2.0f) * METERS_PER_MAP_UNIT;
         break;
         // E, 26 low, high
         case 7: case 8:
-            cubePoints[0].y = cubePoints[4].y = ((slope - 7) / 2.0f);
-            cubePoints[1].y = cubePoints[5].y = ((slope - 7 + 1) / 2.0f);
+            cubePoints[0].y = cubePoints[4].y = ((slope - 7) / 2.0f) * METERS_PER_MAP_UNIT;
+            cubePoints[1].y = cubePoints[5].y = ((slope - 7 + 1) / 2.0f) * METERS_PER_MAP_UNIT;
         break;
         // N, 7 low - high
         case 9: case 10: case 11: case 12:
         case 13: case 14: case 15: case 16:
-            cubePoints[0].y = cubePoints[1].y = ((slope - 9) / 8.0f);
-            cubePoints[4].y = cubePoints[5].y = ((slope - 9 + 1) / 8.0f);
+            cubePoints[0].y = cubePoints[1].y = ((slope - 9) / 8.0f) * METERS_PER_MAP_UNIT;
+            cubePoints[4].y = cubePoints[5].y = ((slope - 9 + 1) / 8.0f) * METERS_PER_MAP_UNIT;
         break;
         // S, 7 low - high
         case 17: case 18: case 19: case 20:
         case 21: case 22: case 23: case 24:
-            cubePoints[4].y = cubePoints[5].y = ((slope - 17) / 8.0f);
-            cubePoints[0].y = cubePoints[1].y = ((slope - 17 + 1) / 8.0f);
+            cubePoints[4].y = cubePoints[5].y = ((slope - 17) / 8.0f) * METERS_PER_MAP_UNIT;
+            cubePoints[0].y = cubePoints[1].y = ((slope - 17 + 1) / 8.0f) * METERS_PER_MAP_UNIT;
         break;
         // W, 7 low - high
         case 25: case 26: case 27: case 28:
         case 29: case 30: case 31: case 32:
-            cubePoints[1].y = cubePoints[5].y = ((slope - 25) / 8.0f);
-            cubePoints[0].y = cubePoints[4].y = ((slope - 25 + 1) / 8.0f);
+            cubePoints[1].y = cubePoints[5].y = ((slope - 25) / 8.0f) * METERS_PER_MAP_UNIT;
+            cubePoints[0].y = cubePoints[4].y = ((slope - 25 + 1) / 8.0f) * METERS_PER_MAP_UNIT;
         break;
         // E, 7 low - high
         case 33: case 34: case 35: case 36:
         case 37: case 38: case 39: case 40:
-            cubePoints[0].y = cubePoints[4].y = ((slope - 33) / 8.0f);
-            cubePoints[1].y = cubePoints[5].y = ((slope - 33 + 1) / 8.0f);
+            cubePoints[0].y = cubePoints[4].y = ((slope - 33) / 8.0f) * METERS_PER_MAP_UNIT;
+            cubePoints[1].y = cubePoints[5].y = ((slope - 33 + 1) / 8.0f) * METERS_PER_MAP_UNIT;
         break;
         // 41 - 44 = 45 N,S,W,E
         case 41: cubePoints[0].y = cubePoints[1].y = 0.0f; break;
@@ -254,6 +254,8 @@ void GameMapHelpers::PutBlockFace(GameMapManager& cityScape, MapMeshData& meshDa
 
 int GameMapHelpers::GetSlopeHeight(int slopeType, int pxcoord_x, int pxcoord_y)
 {
+    return 0.0f; // todo: redo
+
     debug_assert(pxcoord_x >= 0 && pxcoord_x < PIXELS_PER_MAP_UNIT);
     debug_assert(pxcoord_y >= 0 && pxcoord_y < PIXELS_PER_MAP_UNIT);
 

src/GameParams.cpp

@@ -10,16 +10,16 @@ GameParams::GameParams()
 
 void GameParams::SetToDefaults()
 {
-    mPedestrianBoundsSphereRadius = 0.15f;
+    mPedestrianBoundsSphereRadius = Convert::MapUnitsToMeters(0.15f);
 
     mPedestrianTurnSpeed = 260.0f;
     mPedestrianTurnSpeedSlideOnCar = 120.0f;
-    mPedestrianSlideOnCarSpeed = 1.2f;
-    mPedestrianWalkSpeed = 0.7f;
-    mPedestrianRunSpeed = 1.5f;
-    mPedestrianSpotTheCarDistance = 3.0f;
+    mPedestrianSlideOnCarSpeed = Convert::MapUnitsToMeters(1.2f);
+    mPedestrianWalkSpeed = Convert::MapUnitsToMeters(0.7f);
+    mPedestrianRunSpeed = Convert::MapUnitsToMeters(1.5f);
+    mPedestrianSpotTheCarDistance = Convert::MapUnitsToMeters(3.0f);
     mPedestrianKnockedDownTime = 3.0f;
-    mPedestrianFallDeathHeight = 2.0f;
+    mPedestrianFallDeathHeight = Convert::MapUnitsToMeters(2.0f);
     mPedestrianDrowningTime = 0.05f;
 
     // weapons time todo
@@ -30,9 +30,9 @@ void GameParams::SetToDefaults()
     mWeaponsRechargeTime[eWeaponType_RocketLauncher] = 1.0f * 3.0f;
 
     // weapons distance todo
-    mWeaponsDistance[eWeaponType_Fists] = mPedestrianBoundsSphereRadius + 0.6f;
-    mWeaponsDistance[eWeaponType_Pistol] = 1.0f;
-    mWeaponsDistance[eWeaponType_Machinegun] = 1.0f;
-    mWeaponsDistance[eWeaponType_Flamethrower] = 1.0f;
-    mWeaponsDistance[eWeaponType_RocketLauncher] = 1.0f;
+    mWeaponsDistance[eWeaponType_Fists] = mPedestrianBoundsSphereRadius + Convert::MapUnitsToMeters(0.6f);
+    mWeaponsDistance[eWeaponType_Pistol] = Convert::MapUnitsToMeters(1.0f);
+    mWeaponsDistance[eWeaponType_Machinegun] = Convert::MapUnitsToMeters(1.0f);
+    mWeaponsDistance[eWeaponType_Flamethrower] = Convert::MapUnitsToMeters(1.0f);
+    mWeaponsDistance[eWeaponType_RocketLauncher] = Convert::MapUnitsToMeters(1.0f);
 }

src/GameParams.h

@@ -13,19 +13,19 @@ class GameParams
 
 public:
     // pedestrians
-    float mPedestrianBoundsSphereRadius; // bounding sphere radius, map units
+    float mPedestrianBoundsSphereRadius; // bounding sphere radius, meters
 
     float mPedestrianTurnSpeed; // degrees per second
     float mPedestrianTurnSpeedSlideOnCar; // degrees per second
-    float mPedestrianSlideOnCarSpeed; // in map units per second
-    float mPedestrianWalkSpeed; // in map units per second
-    float mPedestrianRunSpeed; // in map units per second
+    float mPedestrianSlideOnCarSpeed; // meters per second
+    float mPedestrianWalkSpeed; // meters per second
+    float mPedestrianRunSpeed; // meters per second
     float mPedestrianKnockedDownTime; // knocked down duration after the punch in face, seconds
-    float mPedestrianSpotTheCarDistance; // max distance to detect the car, map units
-    float mPedestrianFallDeathHeight; // falling distance which causes pedestrian death, map units
+    float mPedestrianSpotTheCarDistance; // max distance to detect the car, meters
+    float mPedestrianFallDeathHeight; // falling distance which causes pedestrian death, meters
     float mPedestrianDrowningTime; // seconds
     float mWeaponsRechargeTime[eWeaponType_COUNT]; // weapons reload time, seconds
-    float mWeaponsDistance[eWeaponType_COUNT]; // map units
+    float mWeaponsDistance[eWeaponType_COUNT]; // hit distance, meters
 };
 
 extern GameParams gGameParams;

src/PedestrianStates.cpp

@@ -129,12 +129,13 @@ void PedestrianStatesManager::ProcessRotateActions()
             turnSpeed = gGameParams.mPedestrianTurnSpeedSlideOnCar;
         }
 
-        float angularVelocity = turnSpeed * (mPedestrian->mCtlActions[ePedestrianAction_TurnLeft] ? -1.0f : 1.0f);
+        cxx::angle_t angularVelocity = cxx::angle_t::from_degrees(turnSpeed * (mPedestrian->mCtlActions[ePedestrianAction_TurnLeft] ? -1.0f : 1.0f));
         mPedestrian->mPhysicsComponent->SetAngularVelocity(angularVelocity);
     }
     else
     {
-        mPedestrian->mPhysicsComponent->SetAngularVelocity(0.0f);
+        cxx::angle_t angularVelocity;
+        mPedestrian->mPhysicsComponent->SetAngularVelocity(angularVelocity);
     }
 }
 
@@ -145,18 +146,18 @@ void PedestrianStatesManager::ProcessMotionActions()
     {
         glm::vec2 linearVelocity = gGameParams.mPedestrianSlideOnCarSpeed * mPedestrian->mPhysicsComponent->GetSignVector();
         mPedestrian->mPhysicsComponent->SetLinearVelocity(linearVelocity);
-
         return;
     }
 
+    glm::vec2 linearVelocity {};
     // generic case
     if (mPedestrian->mCtlActions[ePedestrianAction_WalkForward] || 
         mPedestrian->mCtlActions[ePedestrianAction_WalkBackward] || 
         mPedestrian->mCtlActions[ePedestrianAction_Run])
     {
         float moveSpeed = gGameParams.mPedestrianWalkSpeed;
 
-        glm::vec2 linearVelocity = mPedestrian->mPhysicsComponent->GetSignVector();
+        linearVelocity = mPedestrian->mPhysicsComponent->GetSignVector();
         if (mPedestrian->mCtlActions[ePedestrianAction_Run])
         {
             moveSpeed = gGameParams.mPedestrianRunSpeed;
@@ -165,12 +166,14 @@ void PedestrianStatesManager::ProcessMotionActions()
         {
             linearVelocity = -linearVelocity;
         }
-        mPedestrian->mPhysicsComponent->SetLinearVelocity(linearVelocity * moveSpeed);
+
+        linearVelocity *= moveSpeed;
     }
     else
     {
-        mPedestrian->mPhysicsComponent->SetLinearVelocity({}); // force stop
+        // force stop
     }
+    mPedestrian->mPhysicsComponent->SetLinearVelocity(linearVelocity); 
 }
 
 bool PedestrianStatesManager::TryToShoot()

src/PhysicsComponents.cpp

@@ -11,6 +11,8 @@ PhysicsComponent::PhysicsComponent(b2World* physicsWorld)
     : mHeight()
     , mPhysicsWorld(physicsWorld)
     , mPhysicsBody()
+    , mPreviousPosition()
+    , mSmoothPosition()
 {
     debug_assert(physicsWorld);
 }
@@ -75,9 +77,9 @@ glm::vec2 PhysicsComponent::GetLinearVelocity() const
     return { b2position.x, b2position.y };
 }
 
-float PhysicsComponent::GetAngularVelocity() const
+cxx::angle_t PhysicsComponent::GetAngularVelocity() const
 {
-    float angularVelocity = glm::degrees(mPhysicsBody->GetAngularVelocity());
+    cxx::angle_t angularVelocity = cxx::angle_t::from_radians(mPhysicsBody->GetAngularVelocity());
     return angularVelocity;
 }
 
@@ -86,9 +88,9 @@ void PhysicsComponent::AddAngularImpulse(float impulse)
     mPhysicsBody->ApplyAngularImpulse(impulse, true);
 }
 
-void PhysicsComponent::SetAngularVelocity(float angularVelocity)
+void PhysicsComponent::SetAngularVelocity(cxx::angle_t angularVelocity)
 {
-    mPhysicsBody->SetAngularVelocity(glm::radians(angularVelocity));
+    mPhysicsBody->SetAngularVelocity(angularVelocity.to_radians());
 }
 
 void PhysicsComponent::SetLinearVelocity(const glm::vec2& velocity)
@@ -151,7 +153,7 @@ PedPhysicsComponent::PedPhysicsComponent(b2World* physicsWorld, const glm::vec3&
     debug_assert(mPhysicsBody);
 
     b2CircleShape shapeDef;
-    shapeDef.m_radius = Convert::MapUnitsToMeters(gGameParams.mPedestrianBoundsSphereRadius);
+    shapeDef.m_radius = gGameParams.mPedestrianBoundsSphereRadius;
 
     b2FixtureDef fixtureDef;
     fixtureDef.shape = &shapeDef;
@@ -162,7 +164,7 @@ PedPhysicsComponent::PedPhysicsComponent(b2World* physicsWorld, const glm::vec3&
     debug_assert(b2fixture);
 
     // create sensor
-    shapeDef.m_radius = Convert::MapUnitsToMeters(gGameParams.mPedestrianBoundsSphereRadius);
+    shapeDef.m_radius = gGameParams.mPedestrianBoundsSphereRadius;
     fixtureDef.shape = &shapeDef;
     fixtureDef.isSensor = true;
     fixtureDef.filter.categoryBits = PHYSICS_OBJCAT_PED_SENSOR;

src/PhysicsComponents.h

@@ -25,46 +25,57 @@ class PhysicsComponent: public cxx::noncopyable
     glm::vec3 mSmoothPosition; // for rendering only
 
 public:
-    // set/get object's world position and rotation angle
-    // @param position: Coordinate
-    // @param rotationAngle: Rotation, optional
+    virtual ~PhysicsComponent();
+
+    // Set or get object's world position and rotation angle
+    // @param position: Coordinate, meters
+    // @param rotationAngle: Angle
     void SetPosition(const glm::vec3& position);
     void SetPosition(const glm::vec3& position, cxx::angle_t rotationAngle);
     glm::vec3 GetPosition() const;
-    // set/get object's heading angle 
-    // @param rotationAngle: Angle value
+
+    // Set or get object's heading angle 
+    // @param rotationAngle: Angle
     void SetRotationAngle(cxx::angle_t rotationAngle);
     cxx::angle_t GetRotationAngle() const;
-    // set/get current angular velocity
-    // @param velocity: new angular velocity in degrees/second
-    void SetAngularVelocity(float angularVelocity);
-    float GetAngularVelocity() const;
-	/// set/get the linear velocity of the center of mass
-	/// @param velocity: new linear velocity of the center of mass
+
+    // Set or get current angular velocity
+    // @param velocity: New angular velocity in degrees/second
+    void SetAngularVelocity(cxx::angle_t angularVelocity);
+    cxx::angle_t GetAngularVelocity() const;
+
+	/// Set or get the linear velocity of the center of mass
+	/// @param velocity: New linear velocity of the center of mass, meters per second
     void SetLinearVelocity(const glm::vec2& velocity);
     glm::vec2 GetLinearVelocity() const;
     glm::vec2 GetSignVector() const;
-    // convert coordinate from local to world space and vice versa
+
+    // Convert coordinate from local to world space and vice versa
+    // @param localPosition, worldPosition: Coordinate in meters
     glm::vec2 GetWorldPoint(const glm::vec2& localPosition) const;
     glm::vec2 GetLocalPoint(const glm::vec2& worldPosition) const;
-    // apply an impulse to the center of mass
+
+    // Apply an impulse to the center of mass
     // @param impulse: The world impulse vector, usually in N-seconds or kg-m/s
     void AddLinearImpulse(const glm::vec2& impulse);
-	// apply a force to the center of mass
+
+	// Apply a force to the center of mass
     // @param force: Force, the world force vector, usually in Newtons (N)
     void AddForce(const glm::vec2& force);
-	// apply an angular impulse
+
+	// Apply an angular impulse
 	// @param impulse the angular impulse in units of kg*m*m/s
     void AddAngularImpulse(float impulse);
-    // cancel currently active forces
+
+    // Cancel currently active forces
     void ClearForces();
-    // clear state
+
+    // Clear state
     void SetRespawned();
 
 protected:
     // only derived classes could be instantiated
     PhysicsComponent(b2World* physicsWorld);
-    virtual ~PhysicsComponent();
 
 protected:
     b2World* mPhysicsWorld;

src/Vehicle.cpp

@@ -101,14 +101,14 @@ void Vehicle::DrawDebug(DebugRenderer& debugRender)
     {
         glm::vec2 rotated_pos;
         GetDoorPos(idoor, rotated_pos);
-        debugRender.DrawCube(glm::vec3(rotated_pos.x, position.y + 0.05f, rotated_pos.y), glm::vec3(0.05f, 0.05f, 0.05f), Color32_Yellow, false);
+        debugRender.DrawCube(glm::vec3(rotated_pos.x, position.y + 0.15f, rotated_pos.y), glm::vec3(0.15f, 0.15f, 0.15f), Color32_Yellow, false);
     }
 
     if (mCarStyle->mDoorsCount > 0)
     {
         glm::vec2 seatpos;
         GetSeatPos(eCarSeat_Driver, seatpos);
-        debugRender.DrawCube(glm::vec3(seatpos.x, position.y + 0.05f, seatpos.y), glm::vec3(0.05f, 0.05f, 0.05f), Color32_Green, false);
+        debugRender.DrawCube(glm::vec3(seatpos.x, position.y + 0.15f, seatpos.y), glm::vec3(0.15f, 0.15f, 0.15f), Color32_Green, false);
     }
 
     // draw wheels