Merge pull request #4 from devprofile98/physic

Physic

CMakeLists.txt

@@ -12,7 +12,7 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 add_subdirectory(Engine)
 add_subdirectory(shm-physics)
 add_executable(playground PlayGround/main.cpp)
-target_include_directories(playground PUBLIC Engine/include/ Engine/openGLRenderer/ shm-physics/include/cyclon/)
+target_include_directories(playground PUBLIC Engine/include/ Engine/openGLRenderer/ shm-physics/include/cyclon/ cyclone-physics/include/cyclone)
 
 
 if (WIN32)

Engine/CMakeLists.txt

@@ -7,7 +7,8 @@ set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
 
 set(shm_src 
 #    F:/project/SHM/PlayGround/world.cpp
-    F:/project/SHM/PlayGround/gpc.cpp
+#    F:/project/SHM/PlayGround/gpc.cpp
+    F:/project/SHM/PlayGround/flappybird.cpp
     source/glad.c
     source/Engine.cpp
     source/context_manager.cpp
@@ -33,10 +34,28 @@ set(cyclon_src
     ../shm-physics/src/pfgen.cpp
     ../shm-physics/src/plinks.cpp
     ../shm-physics/src/pcontacts.cpp
+)
 
+set(physic_src
+    ../cyclone-physics/src/body.cpp
+    ../cyclone-physics/src/collide_coarse.cpp
+    ../cyclone-physics/src/collide_fine.cpp
+    ../cyclone-physics/src/contacts.cpp
+    ../cyclone-physics/src/core.cpp
+    ../cyclone-physics/src/fgen.cpp
+    ../cyclone-physics/src/joints.cpp
+    ../cyclone-physics/src/particle.cpp
+    ../cyclone-physics/src/pcontacts.cpp
+    ../cyclone-physics/src/pfgen.cpp
+    ../cyclone-physics/src/plinks.cpp
+    ../cyclone-physics/src/pworld.cpp
+    ../cyclone-physics/src/random.cpp
+    ../cyclone-physics/src/world.cpp
 )
+
+
 add_subdirectory(include/shys)
-add_library(shm-engine SHARED ${opengl_renderer_src} ${shm_src} ${cyclon_src} )
+add_library(shm-engine SHARED ${opengl_renderer_src} ${shm_src} ${cyclon_src} ${physic_src} )
 target_link_libraries(shm-engine shys)
 if (WIN32)
     target_link_libraries(shm-engine "F:/project/SHM/Engine/include/GLFW/glfw3.lib")
@@ -48,5 +67,5 @@ elseif(UNIX)
 endif()
 
 target_include_directories(shm-engine PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/openGLRenderer/)
-target_include_directories(shm-engine PUBLIC include/ ../shm-physics/include/cyclon/)
+target_include_directories(shm-engine PUBLIC include/ ../shm-physics/include/cyclon/ ../cyclone-physics/include/)
 

Engine/include/Common.hpp

@@ -5,9 +5,13 @@
 #include <glm/gtc/type_ptr.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <iostream>
+#include <vector>
 
 
 namespace SHM {
+    /**
+     represent a RGB color
+     */
     struct Color{
         Color(){};
         Color(float red, float green, float blue):r(red), g(green), b(blue)
@@ -16,7 +20,7 @@ namespace SHM {
         }
         float r, g, b;
 
-        // call normalize function if values are in range 0-255
+        /** call normalize function if values are in range 0-255*/
         void normalize(){
             if (r >1 || g>1 || b>1){
                 r = r/255.0f;
@@ -26,6 +30,10 @@ namespace SHM {
         }
     };
 
+    /** represent a basic 3D vector
+     * use shm-physic Vector3 for more usage and support
+    */
+
     class Vector3{
     public:
         Vector3(float x=0, float y=0, float z=0):x(x), y(y), z(z)
@@ -42,6 +50,50 @@ namespace SHM {
 
         float x, y, z;
     private:
+    };
+
+    /**
+     * @brief linear interpolation between start to end by duration
+     */
+    class Lerp{
+    public:
+        Lerp(float* ref_value, float duration, float start, float end)
+            :duration(duration), start(start), end(end), m_ref_value(ref_value)
+        {
+           step = (end - start) / duration;
+        }
+
+
+        float tick(){
+            if ((*m_ref_value) + step < end){
+                float temp = start;
+                temp += step;
+                start = temp;
+                (*m_ref_value) += step;
+                return temp;
+            }
+            return end;
+        }
+
+    private:
+        float duration = 0;
+        float step, start, end;
+        float* m_ref_value;
+    };
+
+
+    class LerpManager{
+    public:
+        LerpManager() = delete;
+        void add(Lerp p){
+            wait_list.push_back(p);
+        }
+        static inline std::vector<Lerp> wait_list;
+        static void exec(){
+            for (Lerp& l: wait_list){
+                l.tick();
+            }
+        };
 
     };
 }

Engine/include/Core.hpp

@@ -35,6 +35,7 @@
 
 // include common header files
 #include "BaseRenderer.hpp"
+#include "Common.hpp"
 
 // #include "openGLRenderer.hpp"
 #include "context_manager.hpp"

Engine/include/Engine.hpp

@@ -10,6 +10,7 @@
 #include "Camera.hpp"
 #include "Handler.hpp"
 #include "openGLRenderer.hpp"
+#include <string_view>
 
 
 namespace SHM
@@ -19,7 +20,7 @@ namespace SHM
         OPENGL,
         VULKAN
     };
-
+//    class Application;
     class SHM_EXPORT Engine{
     public:
         Engine(const char* project_name, API_TYPE api_type);
@@ -28,6 +29,7 @@ namespace SHM
         static std::shared_ptr<BaseRenderer> getRenderer();
         static std::shared_ptr<Camera> getCamera();
         void MainRenderLoop();
+        static Handler * getHandler();
 
         static std::shared_ptr<shader> CreateShader(const char *vertex_code, const char *fragment_code);
 
@@ -37,19 +39,19 @@ namespace SHM
         bool firstMouse=true;
 
         bool InitWorld() const;
-        void outLoop();
+        void outLoop(GLFWwindow* window=nullptr);
         void inLoop();
         void saveImage(char* file_path);
-
+//        void setKeyBinding(Application *app);
+        ContextManager* context_manager;
 
 
     private:
-        ContextManager* context_manager;
         void setRenderer(API_TYPE api_type);
         static std::shared_ptr<BaseRenderer> m_renderer;
 
         static std::shared_ptr<Camera > m_camera;
-        Handler* m_handler;
+        static inline Handler* m_handler;
     };
 
 }

Engine/include/Handler.hpp

@@ -7,6 +7,23 @@
 
 namespace SHM{
 
+//void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+//{
+//    if (key == GLFW_KEY_SPACE && action == GLFW_PRESS)
+//    {
+//        currentXPos--;
+//        if (currentXPos < 0)
+//            currentXPos = 0;
+//    }
+//}
+
+    class SHM_EXPORT Command{
+      public:
+        virtual ~Command(){};
+        virtual void execute(){};
+    };
+
+
     class SHM_EXPORT Handler{
         public:
             Handler(GLFWwindow *window, std::shared_ptr<Camera> camera);
@@ -20,6 +37,11 @@ namespace SHM{
             static inline std::shared_ptr<Camera> camera;
             float last_frame_time;
 
+            // buttons
+            Command* space_btn;
+//            void execspace(){
+//                space_btn->execute();
+//            }
 
     };
 

Engine/include/context_manager.hpp

@@ -9,7 +9,7 @@ namespace SHM{
     class SHM_EXPORT ContextManager{
     public:
         ContextManager(const char* window_name);
-        ~ContextManager();
+        virtual ~ContextManager();
 
         static void FrameBufferCallback(GLFWwindow* window, int width, int height);
         GLFWwindow* GetWindow() const;
@@ -20,10 +20,10 @@ namespace SHM{
         glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f,  10.0f);
         glm::vec3 cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);
         glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f,  0.0f);
+        GLFWwindow* window;
 
     private:
         void createWindow(uint32_t width, uint32_t height, const char* window_name);
-        GLFWwindow* window;
 
     };
 

Engine/openGLRenderer/Mesh.cpp

@@ -78,5 +78,5 @@ void Mesh::setupMesh()
 
         // always good practice to set everything back to defaults once configured.
         glActiveTexture(GL_TEXTURE0);
-        glBindTexture(GL_TEXTURE_2D, 0);
+//        glBindTexture(GL_TEXTURE_2D, 0);
     }

Engine/openGLRenderer/Model.cpp

@@ -66,7 +66,7 @@ void Model::Draw(std::shared_ptr<shader> sh){
     glm::mat4 model{1.0f};
     model = glm::translate(model, m_position);
     model = glm::scale(model, m_scale);
-        model = glm::rotate(model, glm::radians(90.0f), m_rotation);
+    model = glm::rotate(model, glm::radians(1.5f), m_rotation);
 
     if (sh){
         // calculate for shadow map
@@ -88,6 +88,14 @@ void Model::Draw(std::shared_ptr<shader> sh){
     }
 }
 
+void Model::DrawInstances(std::vector<glm::vec3> &positions, std::shared_ptr<shader> sh)
+{
+    for(glm::vec3& pos: positions){
+        m_position = pos;
+        this->Draw(sh);
+    }
+}
+
 std::shared_ptr<shader> Model::getShader()
 {
     return shader_program;
@@ -101,11 +109,11 @@ void Model::setPosition(const glm::vec3 &pos)
 void Model::setScale(const glm::vec3 &scale)
 {
     this->m_scale = scale;
-    std::cout << m_scale.x << m_scale.y <<m_scale.z<<std::endl;
 }
 
-void Model::setRotation(const glm::vec3 &rot)
+void Model::setRotation(const glm::vec3 &rot, float radians)
 {
+    this->m_rotation_radians = radians;
     this->m_rotation = rot;
 }
 

Engine/openGLRenderer/Model.hpp

@@ -5,6 +5,7 @@
 #include <GLFW/glfw3.h>
 //gl math
 #include <glm/glm.hpp>
+#include <glm/gtx/string_cast.hpp>
 #include <glm/gtc/type_ptr.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 
@@ -24,13 +25,14 @@ class Model{
 public:
     Model(const char* path, std::shared_ptr<shader> shader_program);
     void Draw(std::shared_ptr<shader> sh=nullptr);
+    void DrawInstances(std::vector<glm::vec3>& positions, std::shared_ptr<shader> shader_program);
     std::vector<Texture_INT> textures_loaded;
     std::vector<Mesh> meshes;
     std::shared_ptr<shader> getShader();
 
     void setPosition(const glm::vec3& pos);
     void setScale(const glm::vec3& scale);
-    void setRotation(const glm::vec3& rot);
+    void setRotation(const glm::vec3& rot, float radians=0);
 
     const glm::vec3 *getPosition() const;
     const glm::vec3 *getScale() const;
@@ -41,6 +43,7 @@ class Model{
     std::shared_ptr<shader> shader_program;
     void loadModel(std::string path);
     glm::vec3 m_position, m_rotation, m_scale;
+    float m_rotation_radians;
     void processNode(aiNode *node, const aiScene *scene);
     Mesh processMesh(aiMesh *mesh, const aiScene *scene);
     std::vector<Texture_INT> loadMaterialTexture(aiMaterial *mat, aiTextureType type, std::string typeName);

Engine/source/Camera.cpp

@@ -11,7 +11,4 @@ namespace SHM{
         m_up = up;
         m_fov = 45.0f;
     }
-
-
-
 }