Merge branch 'master' of http://git.cubesoftware.xyz:20524/kacperks/rtfps

src/game/core.hpp

@@ -1,5 +1,5 @@
-#ifndef CORE_HPP
-#define CORE_HPP
+#ifndef POLYGUN_CORE_HPP
+#define POLYGUN_CORE_HPP
 
 #define SCR_HEIGHT 600
 #define SCR_WIDTH 800

src/game/engine.hpp

@@ -1,33 +0,0 @@
-#ifndef ENGINE_HPP
-#define ENGINE_HPP
-#include "core.hpp"
-#include "shader.hpp"
-#include "player_camera.hpp"
-
-namespace b3d{
-
-    class Engine {
-    private:
-        GLFWwindow* window;
-        // settings
-        //const unsigned int SCR_WIDTH = 800;
-        //const unsigned int SCR_HEIGHT = 600;
-
-        // camera
-        Camera camera;
-
-        // timing
-        float deltaTime = 0.0f;	// time between current frame and last frame
-        float lastFrame = 0.0f;
-
-    public:
-        Engine() = default;
-        ~Engine() = default;
-
-        void init();
-        void render();
-        void update();
-    };
-
-}
-#endif // ENGINE_HPP

src/game/engine/engine.cpp

@@ -1,6 +1,8 @@
 #include "engine.hpp"
 
-namespace b3d{
+using namespace polygun::renderer;
+
+namespace polygun::engine {
     void framebuffer_size_callback(GLFWwindow* window, int width, int height) { glViewport(0, 0, width, height); }
 
     void Engine::init() {
@@ -107,7 +109,7 @@ namespace b3d{
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         int width, height, nrChannels;
         stbi_set_flip_vertically_on_load(true); 
-        unsigned char *data = stbi_load("res/textures/gold.png", &width, &height, &nrChannels, 0);
+        unsigned char *data = stbi_load("res/textures/grass.png", &width, &height, &nrChannels, 0);
         if (data)
         {
             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
@@ -137,17 +139,17 @@ namespace b3d{
                 glfwSetWindowShouldClose(window, true);
 
             if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
-                camera.ProcessMovement(FORWARD, deltaTime);
+                camera.ProcessMovement(polygun::engine::FORWARD, deltaTime);
             if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
-                camera.ProcessMovement(BACKWARD, deltaTime);
+                camera.ProcessMovement(polygun::engine::BACKWARD, deltaTime);
             if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
                 camera.ProcessMovement(LEFT, deltaTime);
             if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
-                camera.ProcessMovement(RIGHT, deltaTime);
+                camera.ProcessMovement(polygun::engine::RIGHT, deltaTime);
             if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
-                camera.ProcessMovement(UP, deltaTime);
+                camera.ProcessMovement(polygun::engine::UP, deltaTime);
             if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
-                camera.ProcessMovement(DOWN, deltaTime);
+                camera.ProcessMovement(polygun::engine::DOWN, deltaTime);
 
 
             camera.Update();
@@ -163,7 +165,7 @@ namespace b3d{
             // activate shader
             chunk_shader.bind();
 
-            glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
+            glm::mat4 projection = glm::perspective(glm::radians(camera.m_zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
             chunk_shader.setuniform("projection", projection);
 
             glm::mat4 view = camera.GetViewMatrix();

src/game/engine/engine.hpp

@@ -0,0 +1,27 @@
+#ifndef POLYGUN_ENGINE_HPP
+#define POLYGUN_ENGINE_HPP
+#include "../core.hpp"
+#include "../renderer/shader.hpp"
+#include "player_camera.hpp"
+
+namespace polygun::engine{
+
+    class Engine {
+    private:
+        GLFWwindow* window;
+        Camera camera;
+
+        float deltaTime = 0.0f;
+        float lastFrame = 0.0f;
+
+    public:
+        Engine() = default;
+        ~Engine() = default;
+
+        void init();
+        void render();
+        void update();
+    };
+
+}
+#endif // POLYGUN_ENGINE_HPP

src/game/engine/nodes.hpp

@@ -1,9 +1,9 @@
-#ifndef NODES_HPP
-#define NODES_HPP
+#ifndef POLYGUN_NODES_HPP
+#define POLYGUN_NODES_HPP
 
-#include "core.hpp"
+#include "../core.hpp"
 
-namespace b3d {
+namespace polygun::engine {
     /*
     struct Node {
         std::string name;
@@ -18,4 +18,4 @@ namespace b3d {
     */
 }
 
-#endif // NODES_HPP
+#endif // POLYGUN_NODES_HPP

src/game/engine/player_camera.hpp

@@ -0,0 +1,141 @@
+#ifndef CAMERA_H
+#define CAMERA_H
+
+#include "../core.hpp"
+
+namespace polygun::engine{
+    enum camera_movement {
+        FORWARD,
+        BACKWARD,
+        LEFT,
+        RIGHT,
+        UP,
+        DOWN
+    };
+
+    const float YAW         = -90.0f;
+    const float PITCH       =  0.0f;
+    const float SPEED       =  2.5f;
+    const float SENSITIVITY =  0.1f;
+    const float ZOOM        =  45.0f;
+
+    static float mx,my;
+
+    class Camera {
+    public:
+        glm::vec3 m_position;
+        glm::vec3 m_front;
+        glm::vec3 m_up;
+        glm::vec3 m_right;
+        glm::vec3 m_worldup;
+        float m_yaw;
+        float m_pitch;
+        float m_movement_speed;
+        float m_mouse_sensitivity;
+        float m_zoom;
+
+
+        Camera(glm::vec3 m_position = glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f), float yaw = YAW, float pitch = PITCH) : m_front(glm::vec3(0.0f, 0.0f, -1.0f)), m_movement_speed(SPEED), m_mouse_sensitivity(SENSITIVITY), m_zoom(ZOOM) {
+            m_position = m_position;
+            m_worldup = up;
+            m_yaw = yaw;
+            m_pitch = pitch;
+            updateCameraVectors();
+        }
+
+        Camera(float posX, float posY, float posZ, float upX, float upY, float upZ, float yaw, float pitch) : m_front(glm::vec3(0.0f, 0.0f, -1.0f)), m_movement_speed(SPEED), m_mouse_sensitivity(SENSITIVITY), m_zoom(ZOOM) {
+            m_position = glm::vec3(posX, posY, posZ);
+            m_worldup = glm::vec3(upX, upY, upZ);
+            m_yaw = yaw;
+            m_pitch = pitch;
+            updateCameraVectors();
+        }
+
+        glm::mat4 GetViewMatrix() {
+            return glm::lookAt(m_position, m_position + m_front, m_up);
+        }
+
+        void Update(){
+            if (firstMouse)
+            {
+                lastX = mx;
+                lastY = my;
+                firstMouse = false;
+            }
+
+            float xoffset = mx - lastX;
+            float yoffset = lastY - my; 
+
+            lastX = mx;
+            lastY = my;
+
+            ProcessMouseMovement(xoffset, yoffset);
+        }
+
+        void ProcessMovement(camera_movement direction, float deltaTime) {
+            float velocity = m_movement_speed * deltaTime;
+            if (direction == FORWARD)
+                m_position += m_front * velocity;
+            if (direction == BACKWARD)
+                m_position -= m_front * velocity;
+            if (direction == LEFT)
+                m_position -= m_right * velocity;
+            if (direction == RIGHT)
+                m_position += m_right * velocity;
+            if (direction == UP)
+                m_position += glm::vec3(0.0F, 1.0F, 0.0F) * velocity;
+            if (direction == DOWN)
+                m_position += glm::vec3(0.0F, -1.0F, 0.0F) * velocity;
+        }
+
+        void ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch = true) {
+            xoffset *= m_mouse_sensitivity;
+            yoffset *= m_mouse_sensitivity;
+
+            m_yaw   += xoffset;
+            m_pitch += yoffset;
+
+            if (constrainPitch)
+            {
+                if (m_pitch > 89.0f)
+                    m_pitch = 89.0f;
+                if (m_pitch < -89.0f)
+                    m_pitch = -89.0f;
+            }
+
+            updateCameraVectors();
+        }
+
+        void ProcessMouseScroll(float yoffset) {
+            m_zoom -= (float)yoffset;
+            if (m_zoom < 1.0f)
+                m_zoom = 1.0f;
+            if (m_zoom > 45.0f)
+                m_zoom = 45.0f;
+        }
+
+
+        static void mouse_callback(GLFWwindow* window, double xposIn, double yposIn) {
+            mx = static_cast<float>(xposIn);
+            my = static_cast<float>(yposIn);
+        }
+
+
+    private:
+        void updateCameraVectors() {
+            glm::vec3 front;
+            front.x = cos(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));
+            front.y = sin(glm::radians(m_pitch));
+            front.z = sin(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));
+            m_front = glm::normalize(front);
+            m_right = glm::normalize(glm::cross(m_front, m_worldup));  
+            m_up    = glm::normalize(glm::cross(m_right, m_front));
+        }
+
+        float lastX = SCR_WIDTH / 2.0f;
+        float lastY = SCR_HEIGHT / 2.0f;
+        bool firstMouse = true;
+    };
+}
+
+#endif

src/game/player_camera.hpp

@@ -1,153 +0,0 @@
-#ifndef CAMERA_H
-#define CAMERA_H
-
-#include "core.hpp"
-#include <GL/glew.h>
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-
-namespace b3d{
-    enum Camera_Movement {
-        FORWARD,
-        BACKWARD,
-        LEFT,
-        RIGHT,
-        UP,
-        DOWN
-    };
-
-    const float YAW         = -90.0f;
-    const float PITCH       =  0.0f;
-    const float SPEED       =  2.5f;
-    const float SENSITIVITY =  0.1f;
-    const float ZOOM        =  45.0f;
-
-    static float mx,my;
-
-    class Camera
-    {
-    public:
-        glm::vec3 Position;
-        glm::vec3 Front;
-        glm::vec3 Up;
-        glm::vec3 Right;
-        glm::vec3 WorldUp;
-        float Yaw;
-        float Pitch;
-        float MovementSpeed;
-        float MouseSensitivity;
-        float Zoom;
-
-
-        Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f), float yaw = YAW, float pitch = PITCH) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM)
-        {
-            Position = position;
-            WorldUp = up;
-            Yaw = yaw;
-            Pitch = pitch;
-            updateCameraVectors();
-        }
-
-        Camera(float posX, float posY, float posZ, float upX, float upY, float upZ, float yaw, float pitch) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM)
-        {
-            Position = glm::vec3(posX, posY, posZ);
-            WorldUp = glm::vec3(upX, upY, upZ);
-            Yaw = yaw;
-            Pitch = pitch;
-            updateCameraVectors();
-        }
-
-        glm::mat4 GetViewMatrix()
-        {
-            return glm::lookAt(Position, Position + Front, Up);
-        }
-
-        void Update(){
-            if (firstMouse)
-            {
-                lastX = mx;
-                lastY = my;
-                firstMouse = false;
-            }
-
-            float xoffset = mx - lastX;
-            float yoffset = lastY - my; 
-
-            lastX = mx;
-            lastY = my;
-
-            ProcessMouseMovement(xoffset, yoffset);
-        }
-
-        void ProcessMovement(Camera_Movement direction, float deltaTime)
-        {
-            float velocity = MovementSpeed * deltaTime;
-            if (direction == FORWARD)
-                Position += Front * velocity;
-            if (direction == BACKWARD)
-                Position -= Front * velocity;
-            if (direction == LEFT)
-                Position -= Right * velocity;
-            if (direction == RIGHT)
-                Position += Right * velocity;
-            if (direction == UP)
-                Position += glm::vec3(0.0F, 1.0F, 0.0F) * velocity;
-            if (direction == DOWN)
-                Position += glm::vec3(0.0F, -1.0F, 0.0F) * velocity;
-        }
-
-        void ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch = true)
-        {
-            xoffset *= MouseSensitivity;
-            yoffset *= MouseSensitivity;
-
-            Yaw   += xoffset;
-            Pitch += yoffset;
-
-            if (constrainPitch)
-            {
-                if (Pitch > 89.0f)
-                    Pitch = 89.0f;
-                if (Pitch < -89.0f)
-                    Pitch = -89.0f;
-            }
-
-            updateCameraVectors();
-        }
-
-        void ProcessMouseScroll(float yoffset)
-        {
-            Zoom -= (float)yoffset;
-            if (Zoom < 1.0f)
-                Zoom = 1.0f;
-            if (Zoom > 45.0f)
-                Zoom = 45.0f;
-        }
-
-
-        static void mouse_callback(GLFWwindow* window, double xposIn, double yposIn)
-        {
-            mx = static_cast<float>(xposIn);
-            my = static_cast<float>(yposIn);
-        }
-
-
-    private:
-        void updateCameraVectors()
-        {
-            glm::vec3 front;
-            front.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch));
-            front.y = sin(glm::radians(Pitch));
-            front.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch));
-            Front = glm::normalize(front);
-            Right = glm::normalize(glm::cross(Front, WorldUp));  
-            Up    = glm::normalize(glm::cross(Right, Front));
-        }
-
-        float lastX = SCR_WIDTH / 2.0f;
-        float lastY = SCR_HEIGHT / 2.0f;
-        bool firstMouse = true;
-    };
-}
-
-#endif

src/game/renderer/shader.cpp

@@ -1,7 +1,7 @@
 #include "shader.hpp"
-namespace b3d{
-    Shader::Shader(const char* vertexPath, const char* fragmentPath)
-    {
+
+namespace polygun::renderer {
+    Shader::Shader(const char* vertexPath, const char* fragmentPath) {
             std::string vertexCode;
             std::string fragmentCode;
             std::ifstream vShaderFile;

src/game/renderer/shader.hpp

@@ -1,9 +1,9 @@
-#ifndef SHADER_H
-#define SHADER_H
+#ifndef POLYGUN_RENDERER_SHADER_H
+#define POLYGUN_RENDERER_SHADER_H
 
-#include "core.hpp"
+#include "../core.hpp"
 
-namespace b3d{
+namespace polygun::renderer {
     class Shader {
         public:
         Shader() : program(0) {}
@@ -26,7 +26,7 @@ namespace b3d{
         void setuniform(const GLchar* uName, GLuint tex2d, GLint unit); // sample 2d
         
         GLuint getuniform(const char* name);
-        GLuint GetProgram() { return program; }
+        GLuint getprogram() { return program; }
 
         private:
         

src/main.cpp

@@ -1,8 +1,8 @@
 
-#include "game/engine.hpp"
+#include "game/engine/engine.hpp"
 
 int main() {
-    b3d::Engine engine;
+    polygun::engine::Engine engine;
     engine.init();
     return 0;
 }