lots of small fixes

WinteryFox · Oct 31, 2023 · cc3f481 · cc3f481
1 parent 336113f
commit cc3f481
Show file tree

Hide file tree

Showing 24 changed files with 234 additions and 109 deletions.
diff --git a/editor/shaders/triangle.vert b/editor/shaders/triangle.vert
@@ -5,7 +5,14 @@ layout(location = 1) in vec3 color;
 
 layout(location = 0) out vec3 vertColor;
 
+//layout(binding = 0) uniform ModelViewProjection {
+//    mat4 model;
+//    mat4 view;
+//    mat4 projection;
+//} mvp;
+
 void main() {
-    vertColor = color;
+//    gl_Position = mvp.projection * mvp.view * mvp.model * vec4(position, 1.0);
     gl_Position = vec4(position, 1.0);
+    vertColor = color;
 }
diff --git a/engine/Buffer.h b/engine/Buffer.h
@@ -26,7 +26,7 @@ namespace Vixen::Vk {
          * @param dataSize The size of the data.
          * @param offset The offset within this buffer to start writing from.
          */
-        virtual void write(const void *data, size_t dataSize, size_t offset) = 0;
+        virtual void write(const char *data, size_t dataSize, size_t offset) = 0;
 
         [[nodiscard]] size_t getSize() const;
 
@@ -45,7 +45,7 @@ namespace Vixen::Vk {
          */
         Buffer(Usage bufferUsage, const std::size_t &size);
 
-        virtual void *map() = 0;
+        virtual char *map() = 0;
 
         virtual void unmap() = 0;
     };

diff --git a/engine/CMakeLists.txt b/engine/CMakeLists.txt
@@ -10,8 +10,10 @@ find_library(FreeImage_LIBRARY NAMES FreeImage HINTS ${FreeImage_ROOT})
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(FreeImage DEFAULT_MSG FreeImage_INCLUDE_DIR FreeImage_LIBRARY)
 
-set(HEADERS Window.h ShaderModule.h ShaderProgram.h Monitor.h Buffer.h Mesh.h Util.h Renderer.h Vixen.h Framebuffer.h RenderPass.h Material.h Entity.h)
-set(SOURCES Window.cpp Buffer.cpp Blending.h)
+set(HEADERS Window.h ShaderModule.h ShaderProgram.h Monitor.h Buffer.h Mesh.h Util.h Renderer.h Vixen.h Framebuffer.h RenderPass.h Material.h Entity.h
+        Camera.h)
+set(SOURCES Window.cpp Buffer.cpp Blending.h
+        Camera.cpp)
 
 link_libraries(
         PkgConfig::GLM

diff --git a/engine/Camera.cpp b/engine/Camera.cpp
@@ -0,0 +1,59 @@
+#include "Camera.h"
+
+namespace Vixen {
+    Camera::Camera(float fieldOfView, float nearPlane, float farPlane, glm::vec3 clearColor)
+            : position(0, 0, 0),
+//              rotation(glm::quat{}),
+              rotation({}),
+              fieldOfView(fieldOfView),
+              nearPlane(nearPlane),
+              farPlane(farPlane),
+              clearColor(clearColor) {}
+
+    glm::mat4 Camera::view() const {
+//        const auto &reverse = glm::conjugate(rotation);
+//        glm::mat4 rot = glm::toMat4(reverse);
+//        glm::mat4 translation = glm::translate({1.0}, -position);
+//
+//        return rot * translation;
+        return glm::lookAt(
+                position,
+                position + rotation,
+                {0.0f, 1.0f, 0.0f}
+        );
+    }
+
+    glm::mat4 Camera::perspective(float aspectRatio) const {
+        return glm::perspective(
+                glm::radians(fieldOfView),
+                aspectRatio,
+                nearPlane,
+                farPlane
+        );
+    }
+
+    const glm::vec3 &Camera::getPosition() const {
+        return position;
+    }
+
+//    const glm::quat &Camera::getRotation() const {
+//        return rotation;
+//    }
+
+    glm::vec3 Camera::getEulerRotation() const {
+//        return glm::eulerAngles(rotation);
+        return rotation;
+    }
+
+    float Camera::getNearPlane() const {
+        return nearPlane;
+    }
+
+    float Camera::getFarPlane() const {
+        return farPlane;
+    }
+
+    const glm::vec3 &Camera::getClearColor() const {
+        return clearColor;
+    }
+}
diff --git a/engine/Camera.h b/engine/Camera.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/gtx/quaternion.hpp>
+
+namespace Vixen {
+    class Camera {
+        explicit Camera(
+                float fieldOfView = 114.0f,
+                float nearPlane = 0.01f,
+                float farPlane = 1000.0f,
+                glm::vec3 clearColor = {0.0f, 0.0f, 0.0f}
+        );
+
+        [[nodiscard]] glm::mat4 view() const;
+
+        [[nodiscard]] glm::mat4 perspective(float aspectRatio) const;
+
+    public:
+        [[nodiscard]] const glm::vec3 &getPosition() const;
+
+//        [[nodiscard]] const glm::quat &getRotation() const;
+
+        [[nodiscard]] glm::vec3 getEulerRotation() const;
+
+        [[nodiscard]] float getNearPlane() const;
+
+        [[nodiscard]] float getFarPlane() const;
+
+        [[nodiscard]] const glm::vec3 &getClearColor() const;
+
+    private:
+        glm::vec3 position;
+
+        //glm::quat rotation;
+        glm::vec3 rotation;
+
+        float fieldOfView;
+
+        float nearPlane;
+
+        float farPlane;
+
+        glm::vec3 clearColor;
+    };
+}
diff --git a/engine/ShaderModule.h b/engine/ShaderModule.h
@@ -26,18 +26,31 @@ namespace Vixen {
         struct IO {
             std::optional<uint32_t> binding;
             std::optional<uint32_t> location;
+            size_t size;
             size_t offset;
         };
 
+    private:
+        Stage stage;
+
+        std::string entrypoint;
+
+        std::vector<Binding> bindings;
+
+        std::vector<IO> inputs;
+
+        std::vector<IO> uniformBuffers;
+
+    public:
         ShaderModule(
                 Stage stage,
+                std::string entrypoint,
                 const std::vector<Binding> &bindings,
-                const std::vector<IO> &inputs,
-                std::string entrypoint
+                const std::vector<IO> &inputs
         ) : stage(stage),
+            entrypoint(std::move(entrypoint)),
             bindings(bindings),
-            inputs(inputs),
-            entrypoint(std::move(entrypoint)) {}
+            inputs(inputs) {}
 
         [[nodiscard]] Stage getStage() const {
             return stage;
@@ -54,14 +67,5 @@ namespace Vixen {
         [[nodiscard]] const std::vector<IO> &getInputs() const {
             return inputs;
         }
-
-    protected:
-        Stage stage;
-
-        std::string entrypoint;
-
-        std::vector<Binding> bindings;
-
-        std::vector<IO> inputs;
     };
 }
diff --git a/engine/ShaderProgram.h b/engine/ShaderProgram.h
@@ -4,9 +4,8 @@
 #include "ShaderModule.h"
 
 namespace Vixen {
-    template<class T, class = std::enable_if<std::is_base_of<ShaderModule, T>::value>>
+    template<class T> requires std::is_base_of_v<ShaderModule, T>
     class ShaderProgram {
-    protected:
         std::shared_ptr<T> vertex;
 
         std::shared_ptr<T> fragment;

diff --git a/engine/Window.cpp b/engine/Window.cpp
@@ -74,7 +74,8 @@ namespace Vixen {
         if (framebufferSizeChanged) {
             framebufferSizeChanged = false;
 
-            int width, height;
+            int width;
+            int height;
             glfwGetFramebufferSize(window, &width, &height);
 
             spdlog::trace("Framebuffer resized to {}x{}", width, height);
@@ -102,11 +103,14 @@ namespace Vixen {
     }
 
     void Window::center() const {
-        uint32_t w, h;
+        uint32_t w;
+        uint32_t h;
         glfwGetWindowSize(window, reinterpret_cast<int *>(&w), reinterpret_cast<int *>(&h));
 
         const auto mode = glfwGetVideoMode(monitor);
-        uint32_t x, y;
+
+        uint32_t x;
+        uint32_t y;
         glfwGetMonitorPos(monitor, reinterpret_cast<int *>(&x), reinterpret_cast<int *>(&y));
         glfwSetWindowPos(
                 window,
@@ -139,10 +143,12 @@ namespace Vixen {
     }
 
     void Window::setWindowedMode(Mode mode) const {
-        int w, h = 0;
-        int x, y = 0;
-        int refreshRate = 0;
-        GLFWmonitor *m = nullptr;
+        int w;
+        int h;
+        int x;
+        int y;
+        int refreshRate;
+        GLFWmonitor *m;
 
         if (mode == Mode::FULLSCREEN) {
             auto videoMode = glfwGetVideoMode(monitor);

diff --git a/engine/vk/GraphicsCard.h b/engine/vk/GraphicsCard.h
@@ -112,10 +112,11 @@ namespace Vixen::Vk {
         }
 
         [[nodiscard]] bool isExtensionSupported(const std::string &extension) const {
-            return std::find_if(
-                    extensions.begin(),
-                    extensions.end(),
-                    [extension](VkExtensionProperties props) { return extension == props.extensionName; }
+            return std::ranges::find_if(
+                    extensions,
+                    [extension](VkExtensionProperties props) {
+                        return extension == props.extensionName;
+                    }
             ) != std::end(extensions);
         }
 
@@ -137,10 +138,11 @@ namespace Vixen::Vk {
         }
 
         [[nodiscard]] bool isLayerSupported(const std::string &layer) const {
-            return std::find_if(
-                    layers.begin(),
-                    layers.end(),
-                    [layer](VkLayerProperties props) { return layer == props.layerName; }
+            return std::ranges::find_if(
+                    layers,
+                    [layer](VkLayerProperties props) {
+                        return layer == props.layerName;
+                    }
             ) != std::end(layers);
         }
 

diff --git a/engine/vk/Instance.cpp b/engine/vk/Instance.cpp
@@ -155,9 +155,8 @@ namespace Vixen::Vk {
     bool Instance::isExtensionSupported(const std::string &extension) {
         const auto extensions = getSupportedExtensions();
 
-        return std::find_if(
-                extensions.begin(),
-                extensions.end(),
+        return std::ranges::find_if(
+                extensions,
                 [extension](VkExtensionProperties props) { return extension == props.extensionName; }
         ) != std::end(extensions);
     }
@@ -175,9 +174,8 @@ namespace Vixen::Vk {
     bool Instance::isLayerSupported(const std::string &layer) {
         const auto layers = getSupportedLayers();
 
-        return std::find_if(
-                layers.begin(),
-                layers.end(),
+        return std::ranges::find_if(
+                layers,
                 [layer](VkLayerProperties props) { return layer == props.layerName; }
         ) != std::end(layers);
     }

diff --git a/engine/vk/Instance.h b/engine/vk/Instance.h
@@ -4,7 +4,6 @@
 #include "Vulkan.h"
 #include "GraphicsCard.h"
 #include "VkWindow.h"
-#include "../Util.h"
 
 namespace Vixen::Vk {
     class Instance {

diff --git a/engine/vk/Swapchain.h b/engine/vk/Swapchain.h
@@ -49,14 +49,17 @@ namespace Vixen::Vk {
             currentFrame = (currentFrame + 1) % imageCount;
 
             switch (result) {
+                using
+                enum State;
+
                 case VK_SUCCESS:
-                    return State::OK;
+                    return OK;
                 case VK_SUBOPTIMAL_KHR:
                     spdlog::warn("Suboptimal swapchain state");
-                    return State::SUBOPTIMAL;
+                    return SUBOPTIMAL;
                 default:
                     checkVulkanResult(result, "Failed to acquire swapchain image");
-                    return State::OUT_OF_DATE;
+                    return OUT_OF_DATE;
             }
         }
 
@@ -73,20 +76,20 @@ namespace Vixen::Vk {
         void invalidate();
 
     private:
+        std::shared_ptr<Device> device;
+
         uint32_t currentFrame;
 
         uint32_t imageCount;
 
-        std::shared_ptr<Device> device;
+        VkSurfaceFormatKHR format;
 
         VkSwapchainKHR swapchain;
 
         std::vector<::VkImage> images;
 
         std::vector<::VkImageView> imageViews;
 
-        VkSurfaceFormatKHR format{};
-
         VkExtent2D extent{};
 
         std::vector<VkSemaphore> imageAvailableSemaphores;