IT FALLSS

src/main.cpp

@@ -35,6 +35,9 @@ int main() {
     glfwMakeContextCurrent(window);
     glewInit();
 
+    simulationInit();
+    renderInit(window);
+
     parts.push_back(Part {
         .position = glm::vec3(0),
         .rotation = glm::vec3(0),
@@ -45,9 +48,7 @@ int main() {
             .shininess = 32.0f,
         }
     });
-
-    simulationInit();
-    renderInit(window);
+    syncPartPhysics(parts.back());
 
     float lastTime = glfwGetTime();
     do {
@@ -143,6 +144,7 @@ void keyCallback(GLFWwindow* window, int key, int scancode, int action, int mods
                 .shininess = 32.0f,
             }
         });
+        syncPartPhysics(parts.back());
     }
 
     float shiftFactor = (mods & GLFW_MOD_SHIFT) ? -0.2 : 0.2;

src/part.cpp

@@ -1,27 +0,0 @@
-#include <glm/ext.hpp>
-#include <reactphysics3d/engine/PhysicsCommon.h>
-#include <reactphysics3d/engine/PhysicsWorld.h>
-#include "physics/util.h"
-
-#include "part.h"
-
-namespace rp = reactphysics3d;
-
-extern rp::PhysicsWorld* world;
-extern rp::PhysicsCommon physicsCommon;
-
-void Part::syncTransforms() {
-    glm::mat4 rotMat = glm::mat4(1.0f);
-    rotMat = glm::rotate(rotMat, rotation.x, glm::vec3(1., 0., 0.));
-    rotMat = glm::rotate(rotMat, rotation.y, glm::vec3(0., 1., 0.));
-    rotMat = glm::rotate(rotMat, rotation.z, glm::vec3(0., 0., 1.));
-    glm::quat quat(rotMat);
-
-    rp::Transform transform(glmToRp(position), glmToRp(quat));
-    rigidBody = world->createRigidBody(transform);
-
-    rp::BoxShape* shape = physicsCommon.createBoxShape(glmToRp(scale * glm::vec3(0.5)));
-
-    rigidBody->removeCollider(rigidBody->getCollider(0));
-    rigidBody->addCollider(shape, rp::Transform());
-}

src/physics/simulation.cpp

@@ -1,5 +1,6 @@
 #include <cstdio>
 #include <glm/ext/matrix_float3x3.hpp>
+#include <glm/gtc/quaternion.hpp>
 #include <reactphysics3d/collision/shapes/BoxShape.h>
 #include <reactphysics3d/collision/shapes/CollisionShape.h>
 #include <reactphysics3d/components/RigidBodyComponents.h>
@@ -28,15 +29,10 @@ void simulationInit() {
     rp::Vector3 position(0, 20, 0);
     rp::Quaternion orientation = rp::Quaternion::identity();
     rp::Transform transform(position, orientation);
-    // body = world->createRigidBody(transform);
+    rp::RigidBody* body = world->createRigidBody(transform);
 }
 
-void addToSimulation(Part part) {
-    if (part.rigidBody) {
-        fprintf(stderr, "Attempt to add part to simulation that already has a rigid body.\n");
-        return;
-    }
-
+void syncPartPhysics(Part& part) {
     glm::mat4 rotMat = glm::mat4(1.0f);
     rotMat = glm::rotate(rotMat, part.rotation.x, glm::vec3(1., 0., 0.));
     rotMat = glm::rotate(rotMat, part.rotation.y, glm::vec3(0., 1., 0.));
@@ -44,9 +40,17 @@ void addToSimulation(Part part) {
     glm::quat quat(rotMat);
 
     rp::Transform transform(glmToRp(part.position), glmToRp(quat));
-    part.rigidBody = world->createRigidBody(transform);
+    if (!part.rigidBody) {
+        part.rigidBody = world->createRigidBody(transform);
+    } else {
+        part.rigidBody->setTransform(transform);
+    }
 
-    rp::BoxShape* shape = physicsCommon.createBoxShape(rp::Vector3(.5, .5, .5));
+    rp::BoxShape* shape = physicsCommon.createBoxShape(glmToRp(part.scale * glm::vec3(0.5f)));
+
+    if (part.rigidBody->getNbColliders() > 0) {
+        part.rigidBody->removeCollider(part.rigidBody->getCollider(0));
+    }
 
     part.rigidBody->addCollider(shape, rp::Transform());
     part.rigidBody->setType(part.anchored ? rp::BodyType::STATIC : rp::BodyType::DYNAMIC);
@@ -56,10 +60,9 @@ void physicsStep(float deltaTime) {
     // Step the simulation a few steps
     world->update(deltaTime);
 
-    // Get the updated position of the body
-    // const rp::Transform& transform = body->getTransform();
-    // const rp::Vector3& position = transform.getPosition();
-
-    // Display the position of the body
-    // std::cout << "Body Position: (" << position.x << ", " << position.y << ", " << position.z << ")" << std::endl;
+    for (Part& part : parts) {
+        const rp::Transform& transform = part.rigidBody->getTransform();
+        part.position = rpToGlm(transform.getPosition());
+        part.rotation = glm::eulerAngles(rpToGlm(transform.getOrientation()));
+    }
 }

src/physics/simulation.h

@@ -3,5 +3,5 @@
 #include "../part.h"
 
 void simulationInit();
-void addToSimulation(Part part);
+void syncPartPhysics(Part& part);
 void physicsStep(float deltaTime);

src/physics/util.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <glm/ext/vector_float3.hpp>
 #include <reactphysics3d/mathematics/Quaternion.h>
 #include <reactphysics3d/mathematics/Vector3.h>
 #include <reactphysics3d/mathematics/mathematics.h>
@@ -11,5 +12,13 @@ inline rp::Vector3 glmToRp(glm::vec3 vec) {
 }
 
 inline rp::Quaternion glmToRp(glm::quat quat) {
-    return rp::Quaternion(rp::Vector3(quat.x, quat.y, quat.z), quat.w);
+    return rp::Quaternion(quat.w, rp::Vector3(quat.x, quat.y, quat.z));
+}
+
+inline glm::vec3 rpToGlm(rp::Vector3 vec) {
+    return glm::vec3(vec.x, vec.y, vec.z);
+}
+
+inline glm::quat rpToGlm(rp::Quaternion quat) {
+    return glm::quat(quat.w, quat.x, quat.y, quat.z);
 }