Feat/physics world improvement

app/main.cpp

@@ -10,50 +10,45 @@ int main(){
     cout << "Hello Worlds\n";
     cout << "Testing\n";
 
-    //const float dt=1.0f/60.0f;
-    //const Vec3 gravity(0.0f,-9.8f,0.0f);
-
-    //Vec3 position(0.0f,10.0f,0.0f);
-    //Vec3 velocity;
-
-    //float simulation_time=0.0f;
-    //float total_runtime=3.0f; // we will run the simulation for 3 seconds in the startung testing phase
-
-    //auto last_time=std::chrono::high_resolution_clock::now();
-    //float accumulator=0.0f;
-
-    //while(simulation_time<total_runtime){
-    //    auto current_time=std::chrono::high_resolution_clock::now();
-    //    float frametime=std::chrono::duration<float>(current_time-last_time).count();
-    //    last_time=current_time;
-
-    //    accumulator+=frametime;
-    //    while(accumulator>=dt){
-    //        velocity=velocity+(gravity*dt);
-    //        position=position+(velocity*dt);
-
-    //        simulation_time+=dt;
-    //        accumulator-=dt;
-    //    }
-    //    std::cout<<"Time: "<<simulation_time<<"  Y Position: "<< position.y<<std::endl;
-    //    std::this_thread::sleep_for(std::chrono::milliseconds(16));
-    //}
-    PhysicsEngine engine;
-    Rigidbody body1(Vec3(0.0f, 0.0f, 0.0f), Vec3(1.0f, 0.0f, 0.0f), 1.0f);
-	Rigidbody body2(Vec3(10.0f, 0.0f, 0.0f), Vec3(-1.0f, 0.0f, 0.0f), 1.0f);
-    engine.addBody(&body1);
-	engine.addBody(&body2);
-
-    const float dt = 1.0f / 60.0f;
-    for(int i=0;i<300; i++){
-        engine.update(dt);
-        if(checkCollision(body1,body2, 1.0f)){
-            std::cout << "Collision detected at time " <<  i << " ms\n";
-            break;
-        }
+    PhysicsWorld world;
+    Rigidbody test_body(Vec3(0.0f,16.0f,0.0f),Vec3(2.0f,0.0f,0.0f),4.0f);
+    world.addBody(test_body);
+    const float dt=1.0f/60.0f;
+
+    float simulation_time=0.0f;
+    float total_runtime=3.0f; // we will run the simulation for 3 seconds in the startung testing phase
+
+    auto last_time=std::chrono::high_resolution_clock::now();
+    float accumulator=0.0f;
+
+    while(simulation_time<total_runtime){
+       auto current_time=std::chrono::high_resolution_clock::now();
+       float frametime=std::chrono::duration<float>(current_time-last_time).count();
+       last_time=current_time;
+
+       accumulator+=frametime;
+       while(accumulator>=dt){
+           world.step(dt);
+
+           simulation_time+=dt;
+           accumulator-=dt;
+       }
+       std::cout<<"Time: "<<simulation_time<<"  Y Position: "<<world.getBodies()[0].position.y<<std::endl;
+       std::this_thread::sleep_for(std::chrono::milliseconds(16));
     }
-
-
-
+    // PhysicsEngine engine;
+    // Rigidbody body1(Vec3(0.0f, 0.0f, 0.0f), Vec3(1.0f, 0.0f, 0.0f), 1.0f);
+	// Rigidbody body2(Vec3(10.0f, 0.0f, 0.0f), Vec3(-1.0f, 0.0f, 0.0f), 1.0f);
+    // engine.addBody(&body1);
+	// engine.addBody(&body2);
+
+    // const float dt = 1.0f / 60.0f;
+    // for(int i=0;i<300; i++){
+    //     engine.update(dt);
+    //     if(checkCollision(body1,body2, 1.0f)){
+    //         std::cout << "Collision detected at time " <<  i << " ms\n";
+    //         break;
+    //     }
+    // }
     return 0;
 }

engine/core/rigidbody.cpp

@@ -1,13 +1,17 @@
 #include "core/rigidbody.hpp"
 
-Rigidbody::Rigidbody(Vec3 position, Vec3 velocity, float m)
-	: position(position), velocity(velocity), mass(m) {}
+Rigidbody::Rigidbody(const Vec3& pos,
+                     const Vec3& vel,
+                     float mass)
+    : position(pos), velocity(vel), force_accum(0,0,0)
+{
+    inverse_mass=(mass>0.0f)?1.0f/mass:0.0f;
+}
 
-void Rigidbody::applyForce(const Vec3& force, float dt) {
-	Vec3 acceleration = force * (1.0f / mass);
-	velocity = velocity + acceleration * dt;
+void Rigidbody::applyForce(const Vec3& force) {
+    force_accum=force_accum+force;
 }
 
-void Rigidbody::update(float dt) {
-	position = position + velocity * dt;
+void Rigidbody::clearForces() {
+    force_accum = Vec3();
 }

engine/core/rigidbody.hpp

@@ -5,8 +5,13 @@ class Rigidbody {
 public: 
 	Vec3 position;
 	Vec3 velocity;
-	float mass;
-	Rigidbody(Vec3 position = Vec3(), Vec3 velocity = Vec3(), float m = 1.0f);
-	void applyForce(const Vec3& force, float dt);
-	void update(float dt);
+	Vec3 force_accum;
+	float inverse_mass;
+
+	Rigidbody(const Vec3& position,
+		const Vec3& velocity,
+		float mass=1.0f);
+
+	void applyForce(const Vec3& force);
+	void clearForces();
 };

engine/engine/physicsworld.cpp

@@ -1,11 +1,27 @@
 #include "engine/physicsworld.hpp"
+#include<vector>
 
-void PhysicsEngine::addBody(Rigidbody* body) {
+PhysicsWorld::PhysicsWorld():gravity(0.0f,-9.8f,0.0f){}
+
+void PhysicsWorld::addBody(const Rigidbody& body) {
 	bodies.push_back(body);
 }
 
-void PhysicsEngine::update(float dt) {
-	for (auto& body : bodies) {
-		body->update(dt);
+std::vector<Rigidbody>& PhysicsWorld::getBodies(){
+	return bodies;
+}
+
+void PhysicsWorld::step(float dt) {
+	for (auto& body:bodies) {
+		if(body.inverse_mass==0.0f)continue;// skipping immovable objects jaise ground or some terrain
+
+		Vec3 GravityForce=gravity*(1.0f/body.inverse_mass);
+		body.applyForce(GravityForce);
+
+		Vec3 acceleration=body.force_accum*body.inverse_mass;
+		body.velocity+=acceleration*dt;
+		body.position+=body.velocity*dt;
+
+		body.clearForces();
 	}
 }

engine/engine/physicsworld.hpp

@@ -2,11 +2,15 @@
 #include "core/rigidbody.hpp"
 #include <vector>
 
-class PhysicsEngine {
+class PhysicsWorld {
 private: 
-	std::vector<Rigidbody*> bodies;
+	std::vector<Rigidbody> bodies;
+	Vec3 gravity;
 
 public: 
-	void addBody(Rigidbody* body);
-	void update(float dt);
+	PhysicsWorld();
+	void addBody(const Rigidbody& body);
+	void step(float dt);
+
+	std::vector<Rigidbody>& getBodies();
 };

engine/math/vec3.cpp

@@ -8,6 +8,13 @@ Vec3 Vec3::operator+(const Vec3& other) const {
     return Vec3(x+other.x, y+other.y, z+other.z);
 }
 
+Vec3& Vec3::operator+=(const Vec3& other) {
+    x+=other.x;
+    y+=other.y;
+    z+=other.z;
+    return *this; 
+}
+
 Vec3 Vec3::operator-(const Vec3& other) const {
     return Vec3(x-other.x, y-other.y,z-other.z);
 }

engine/math/vec3.hpp

@@ -9,6 +9,7 @@ class Vec3 {
     Vec3(float x, float y, float z);
 
     Vec3 operator+(const Vec3& other) const;
+    Vec3& operator+=(const Vec3& other);
     Vec3 operator-(const Vec3& other) const;
     Vec3 operator*(float scalar) const;