Merge pull request #86 from pixelsandpointers/various-fixes

Various fixes, cleanup, performance improvements, QoL

Author: Birdy2014

include/core/AsyncTaskQueue.hpp

@@ -22,10 +22,13 @@ class AsyncTaskQueue {
     void push_task(std::function<void()>);
     void close();
     bool is_open();
+    std::size_t num_queued_tasks();
+    std::size_t num_total_queued_tasks();
 
 private:
     std::queue<std::function<void()>> m_queue;
     std::mutex m_queue_mutex;
     std::condition_variable m_convar;
     bool m_is_open{true};
+    std::size_t m_total_queued_tasks{0};
 };

include/core/Config.hpp

@@ -15,7 +15,7 @@ struct Config {
     CameraController::Type camera_controller_type{CameraController::Type::UNITY};
     float movement_speed{1000.0f}; // Movement speed in distance / second
     float rotation_speed{0.2f}; // Mouse sensitivity for looking around in radians / second
-    float zoom_speed{1.0f};
+    float zoom_speed{5.0f};
 
     // FIXME: The CameraController breaks if position and target are equal
     glm::vec3 camera_position{0.0f};
@@ -24,5 +24,5 @@ struct Config {
     bool gizmo_use_snap{true};
     float gizmo_snap_translation{100.0f};
     float gizmo_snap_rotation{10.0f};
-    float gizmo_snap_scale{1.0f};
+    float gizmo_snap_scale{0.1f};
 };

include/core/Project.hpp

@@ -51,6 +51,7 @@ class Project {
     Texture const* white_texture() const;
 
 private:
+    friend struct Performance;
     static std::unique_ptr<Project> current;
 
     ColorTexture m_fallback_texture{ColorTexture::single_color(glm::vec4{1.0f})};

include/core/Scene.hpp

@@ -33,6 +33,9 @@ struct InstancedNode {
     std::vector<std::unique_ptr<InstancedNode>> children;
     std::string name;
 
+    static unsigned int counter;
+    unsigned int const id{counter++};
+
     void traverse(std::function<void(glm::mat4, Node const&)>) const;
     void compute_transforms(glm::mat4 = glm::mat4{1.0f});
 

include/core/Serializer.hpp

@@ -22,24 +22,19 @@ class Serializer {
     Project& m_project;
 
     [[nodiscard]] nlohmann::json serialize(InstancedNode const&) const;
-    [[nodiscard]] nlohmann::json serialize(glm::vec3 const&) const;
-    [[nodiscard]] nlohmann::json serialize(glm::vec4 const&) const;
-    [[nodiscard]] nlohmann::json serialize(glm::quat const&) const;
     [[nodiscard]] nlohmann::json serialize(Config const&) const;
     [[nodiscard]] nlohmann::json serialize(Uniforms const&) const;
 
-    template <class T>
-    T deserialize(nlohmann::json&) const;
-    template <>
-    std::unique_ptr<InstancedNode> deserialize(nlohmann::json& source) const;
-    template <>
-    glm::vec3 deserialize(nlohmann::json& source) const;
-    template <>
-    glm::vec4 deserialize(nlohmann::json& source) const;
-    template <>
-    glm::quat deserialize(nlohmann::json& source) const;
-    template <>
-    Config deserialize(nlohmann::json& source) const;
-    template <>
-    Uniforms deserialize(nlohmann::json& source) const;
+    std::unique_ptr<InstancedNode> deserialize_unique_ptr_instancednode(nlohmann::json& source) const;
+    Config deserialize_config(nlohmann::json& source) const;
+    Uniforms deserialize_uniforms(nlohmann::json& source) const;
 };
+
+namespace glm {
+    void to_json(nlohmann::json& j, vec3 const& v);
+    void from_json(nlohmann::json const& j, vec3& v);
+    void to_json(nlohmann::json& j, vec4 const& v);
+    void from_json(nlohmann::json const& j, vec4& v);
+    void to_json(nlohmann::json& j, quat const& q);
+    void from_json(nlohmann::json const& j, quat& v);
+}

include/renderer/Mesh.hpp

@@ -37,8 +37,8 @@ class Mesh {
     void draw() const;
     void draw(ViewingMode) const;
     [[nodiscard]] bool is_fully_loaded() const;
+    void setup_mesh();
 
 private:
-    unsigned int m_vao, m_vbo, m_ebo;
-    void setup_mesh();
+    unsigned int m_vao{0}, m_vbo{0}, m_ebo{0};
 };

include/renderer/Shader.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <functional>
 #include <glad/glad.h>
 #include <glm/glm.hpp>
 #include <glm/gtc/type_ptr.hpp>
@@ -46,6 +47,29 @@ struct Uniforms {
     } light;
 };
 
+struct UniformLocations {
+    // Vertex
+    int model{-1};
+    int view{-1};
+    int projection{-1};
+
+    // Fragment
+    int texture_diffuse{-1};
+    int texture_opacity{-1};
+    int light_direction{-1};
+    int light_color{-1};
+    int light_power{-1};
+    int camera_pos{-1};
+    int ambient_strength{-1};
+    int specularity_factor{-1};
+    int shininess{-1};
+    int gamma{-1};
+
+    int tex{-1};
+    int color{-1};
+    int id{-1};
+};
+
 /**
  * @brief Defines the types of shading techniques available in rendering.
  *
@@ -85,6 +109,7 @@ enum class ViewingMode {
 struct ShaderSource {
     char const* vertex_shader;
     char const* fragment_shader;
+    std::function<void(UniformLocations&, std::function<void(int&, char const*)>)> uniform_caching_function;
 };
 
 /**
@@ -121,24 +146,38 @@ class Shader {
     static void init();
 
     Shader() = default;
-    Shader(char const* vertex_path, char const* fragment_path);
     Shader(ShaderSource);
     Shader(Shader const&) = delete;
     Shader(Shader&&);
     Shader& operator=(Shader&&);
 
     unsigned int m_id;
+    UniformLocations uniform_locations;
     void use() const;
-    void set_bool(char const* name, bool value) const;
-    void set_int(char const* name, int value) const;
-    void set_uint(char const* name, unsigned int value) const;
-    void set_float(char const* name, float value) const;
-    void set_mat2(char const* name, glm::mat2 const& matrix) const;
-    void set_mat3(char const* name, glm::mat3 const& matrix) const;
-    void set_mat4(char const* name, glm::mat4 const& matrix) const;
-    void set_vec2(char const* name, glm::vec2 const& vector) const;
-    void set_vec3(char const* name, glm::vec3 const& vector) const;
-    void set_vec4(char const* name, glm::vec4 const& vector) const;
+
+    template <typename T>
+    void set_uniform(int location, T const& value) const
+    {
+        if (location < 0) {
+            return;
+        }
+
+        if constexpr (std::is_same_v<T, bool>) {
+            glUniform1i(location, static_cast<int>(value));
+        } else if constexpr (std::is_same_v<T, int>) {
+            glUniform1i(location, value);
+        } else if constexpr (std::is_same_v<T, unsigned int>) {
+            glUniform1ui(location, value);
+        } else if constexpr (std::is_same_v<T, float>) {
+            glUniform1f(location, value);
+        } else if constexpr (std::is_same_v<T, glm::mat4>) {
+            glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(value));
+        } else if constexpr (std::is_same_v<T, glm::vec3>) {
+            glUniform3fv(location, 1, glm::value_ptr(value));
+        } else if constexpr (std::is_same_v<T, glm::vec4>) {
+            glUniform4fv(location, 1, glm::value_ptr(value));
+        }
+    }
 
 private:
     void check_compile_errors(unsigned int shader, ShadingStage stage) const;

include/renderer/Texture.hpp

@@ -19,7 +19,7 @@ struct Image {
 struct ColorTexture;
 
 struct Texture {
-    unsigned int m_id;
+    unsigned int id;
     int width;
     int height;
     int channels;

include/ui/ObjectSelectionTree.hpp

@@ -10,5 +10,4 @@ struct ObjectSelectionTree {
 
 private:
     std::optional<ImRect> m_prev_rect;
-    int m_imgui_treenode_id;
 };

include/ui/Performance.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <array>
+#include <cstddef>
+
+struct Performance {
+    void render(double delta_time);
+
+private:
+    double const m_update_interval = 5.0;
+    double m_current_time{0};
+    double m_last_updated{-m_update_interval};
+    std::size_t m_last_total_background_tasks{0};
+    std::size_t m_total_background_tasks{0};
+    std::array<float, 100> m_frametimes;
+};