Feature/rework type setting

CMakeLists.txt

@@ -24,6 +24,7 @@ set(ENGINE_CORE
     src/limitless/core/context_observer.cpp
     src/limitless/core/state_query.cpp
     src/limitless/core/profiler.cpp
+    src/limitless/core/cpu_profiler.cpp
     src/limitless/core/time_query.cpp
 
     src/limitless/core/texture/texture.cpp
@@ -96,11 +97,14 @@ set(ENGINE_LOADERS
     src/limitless/loaders/dds_loader.cpp
     src/limitless/loaders/cgltf.c
     src/limitless/loaders/gltf_model_loader.cpp
+    src/limitless/loaders/cgltf_write.c
+    src/limitless/loaders/gltf_model_saver.cpp
 )
 
 set(ENGINE_MODELS
     src/limitless/models/elementary_model.cpp
     src/limitless/models/text_model.cpp
+    src/limitless/models/text_selection_model.cpp
     src/limitless/models/skeletal_model.cpp
     src/limitless/models/abstract_model.cpp
     src/limitless/models/cube.cpp
@@ -141,6 +145,7 @@ set(ENGINE_MS
 set(ENGINE_TEXT
     src/limitless/text/text_instance.cpp
     src/limitless/text/font_atlas.cpp
+    src/limitless/text/type_setter.cpp
 )
 
 set(ENGINE_FX
@@ -173,6 +178,7 @@ set(ENGINE_RENDERER
     src/limitless/renderer/deferred_lighting_pass.cpp
     src/limitless/renderer/depth_pass.cpp
     src/limitless/renderer/translucent_pass.cpp
+    src/limitless/renderer/fog_pass.cpp
     src/limitless/renderer/bloom_pass.cpp
     src/limitless/renderer/composite_pass.cpp
     src/limitless/renderer/ssao_pass.cpp

include/limitless/camera.hpp

@@ -6,31 +6,27 @@
 #include <glm/gtx/quaternion.hpp>
 
 namespace Limitless {
-    enum class CameraMovement { Forward, Backward, Left, Right, Up, Down };
-    enum class CameraMode { Free, Panning };
-
     class Camera {
     private:
         glm::vec3 position;
-        glm::vec3 front, up, right, world_up;
+        glm::vec3 front;
+        glm::vec3 up;
+        glm::vec3 right;
+        glm::vec3 world_up;
 
         glm::mat4 projection;
         glm::mat4 view;
         glm::mat4 view_to_screen;
 
-        CameraMode mode {};
-
-        float pitch;
+        float pitch; // degrees
         float yaw;
 
         float fov {90}; // degrees
         float near_distance {0.01f};
         float far_distance {100.0f};
 
-        float move_speed {2.0f};
-        float mouse_sence {0.5f};
     public:
-        explicit Camera(glm::uvec2 window_size) noexcept;
+        explicit Camera(glm::uvec2 screen_size) noexcept;
 
         [[nodiscard]] const auto& getViewToScreen() const noexcept { return view_to_screen; }
         [[nodiscard]] const auto& getProjection() const noexcept { return projection; }
@@ -42,21 +38,16 @@ namespace Limitless {
         [[nodiscard]] const auto& getNear() const noexcept { return near_distance; }
         [[nodiscard]] const auto& getFar() const noexcept { return far_distance; }
         [[nodiscard]] const auto& getFov() const noexcept { return fov; }
-
-        [[nodiscard]] auto& getMoveSpeed() noexcept { return move_speed; }
-        [[nodiscard]] auto& getMouseSence() noexcept { return mouse_sence; }
-        [[nodiscard]] auto& getMode() noexcept { return mode; }
+        [[nodiscard]] const auto& getPitch() const noexcept { return pitch; }
+        [[nodiscard]] const auto& getYaw() const noexcept { return yaw; }
 
         void setPosition(const glm::vec3& position) noexcept;
-        void setFront(const glm::vec3& front) noexcept;
-        void setFov(glm::uvec2 size, float fov) noexcept;
-        void setMode(CameraMode mode) noexcept;
-
-        void mouseMove(glm::dvec2 offset) noexcept;
-        void mouseScroll(float yoffset) noexcept;
-        void movement(CameraMovement move, float delta) noexcept;
+        void setFov(glm::uvec2 screen_size, float fov) noexcept;
+        void setPitch(float pitch) noexcept;
+        void setYaw(float yaw) noexcept;
+        void setRotation(float pitch, float yaw) noexcept;
 
         void updateView() noexcept;
-        void updateProjection(glm::uvec2 size) noexcept;
+        void updateProjection(glm::uvec2 screen_size) noexcept;
     };
-}
+}

include/limitless/core/context_initializer.hpp

@@ -26,7 +26,7 @@ namespace Limitless {
 
         static void initializeGLEW();
         static void initializeGLFW();
-        static void getExtensions() noexcept;
+        static void discoverExtensions() noexcept;
         static void getLimits() noexcept;
 
         ContextInitializer();
@@ -41,6 +41,9 @@ namespace Limitless {
         static void printExtensions() noexcept;
         static bool isExtensionSupported(std::string_view name) noexcept;
         static bool checkMinimumRequirements() noexcept;
+        static const auto& getExtensions() noexcept {
+            return extensions;
+        }
 
         static bool isProgramInterfaceQuerySupported() noexcept;
         static bool isBindlessTextureSupported() noexcept;

include/limitless/core/cpu_profiler.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <chrono>
+#include <unordered_map>
+
+namespace Limitless {
+	struct CpuProfiler {
+		using MonotonicTime = std::chrono::steady_clock::time_point;
+		using Duration      = std::chrono::steady_clock::duration;
+
+		struct Frame {
+			void record(Duration period);
+
+			Duration getMinDuration() const noexcept;
+			Duration getMaxDuration() const noexcept;
+			Duration getAverageDuration() const noexcept;
+			Duration getLastDuration() const noexcept;
+			size_t getCount() const noexcept;
+
+			Duration getTotalPerFrame() const noexcept;
+			size_t getCountPerFrame() const noexcept;
+
+			void startFrame();
+
+		private:
+			Duration min {Duration::max()};
+			Duration max {Duration::min()};
+			Duration avg {Duration::zero()};
+			Duration last {Duration::zero()};
+			Duration total_per_frame {Duration::zero()};
+			size_t n_per_frame {0};
+			size_t n {0};
+		};
+
+		std::unordered_map<const char*, Frame> frames;
+
+		void startFrame();
+	};
+
+	extern CpuProfiler global_profiler;
+
+	struct CpuProfileScope {
+		CpuProfiler::Frame& frame;
+		// Is a const char* to avoid dynamically allocating a std::sting for
+		// every profile frame.
+		const char* identifier;
+		CpuProfiler::MonotonicTime start;
+
+		CpuProfileScope(CpuProfiler& profiler, const char* id) noexcept;
+
+		~CpuProfileScope();
+
+	private:
+		// TODO: consider taking a clock instance.
+		static CpuProfiler::MonotonicTime now() noexcept;
+	};
+}

include/limitless/core/texture/texture.hpp

@@ -67,7 +67,11 @@ namespace Limitless {
 
             // GL_ARB_texture_compression_rgtc
             R_RGTC = GL_COMPRESSED_RED_RGTC1,
-            RG_RGTC = GL_COMPRESSED_RG_RGTC2
+            RG_RGTC = GL_COMPRESSED_RG_RGTC2,
+
+            // GL_KHR_texture_compression_astc_ldr
+            RGBA_ASTC_4x4 = GL_COMPRESSED_RGBA_ASTC_4x4_KHR,
+            sRGBA8_ASTC_4x4 = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR
         };
 
         enum class Format {
@@ -131,6 +135,8 @@ namespace Limitless {
         bool mipmap {false};
         bool compressed {false};
         bool immutable {false};
+
+        size_t getBytesPerPixel() const noexcept;
     protected:
         Texture() = default;
     public:
@@ -164,6 +170,7 @@ namespace Limitless {
         [[nodiscard]] auto isCubemapArray() const noexcept { return target == Type::TexCubeMapArray; }
         [[nodiscard]] uint32_t getId() const noexcept;
         [[nodiscard]] auto& getExtensionTexture() noexcept { return *texture; }
+        [[nodiscard]] std::vector<std::byte> getPixels() const noexcept;
 
         Texture& setMinFilter(Filter filter);
         Texture& setMagFilter(Filter filter);

include/limitless/core/texture/texture_builder.hpp

@@ -45,10 +45,10 @@ namespace Limitless {
         Builder& wrap_t(Texture::Wrap wrap);
         Builder& wrap_r(Texture::Wrap wrap);
 
-        void useStateExtensionTexture();
-        void useNamedExtensionTexture();
-        void useBindlessExtensionTexture();
-        void useBestSupportedExtensionTexture();
+        Builder& useStateExtensionTexture();
+        Builder& useNamedExtensionTexture();
+        Builder& useBindlessExtensionTexture();
+        Builder& useBestSupportedExtensionTexture();
 
         std::shared_ptr<Texture> buildMutable();
         std::shared_ptr<Texture> buildImmutable();

include/limitless/core/vertex.hpp

@@ -14,14 +14,27 @@ namespace Limitless {
     struct TextVertex {
         glm::vec2 position;
         glm::vec2 uv;
+        glm::vec4 color;
 
-        TextVertex(glm::vec2 _position, glm::vec2 _uv) noexcept
+        TextVertex(glm::vec2 _position, glm::vec2 _uv, glm::vec4 _color) noexcept
             : position{_position}
-            , uv{_uv} {}
+            , uv{_uv}
+            , color{_color}
+        {}
 
         TextVertex() = default;
     };
 
+    struct TextSelectionVertex {
+        glm::vec2 position;
+
+        TextSelectionVertex(glm::vec2 _position) noexcept
+            : position{_position}
+        {}
+
+        TextSelectionVertex() = default;
+    };
+
     struct VertexNormal {
         glm::vec3 position;
         glm::vec3 normal;

include/limitless/core/vertex_array.hpp

@@ -75,6 +75,7 @@ namespace Limitless {
         VertexArray& operator<<(const std::pair<TextVertex, const std::shared_ptr<Buffer>&>& attribute) noexcept;
         VertexArray& operator<<(const std::pair<VertexNormalTangent, const std::shared_ptr<Buffer>&>& attribute) noexcept;
         VertexArray& operator<<(const std::pair<VertexTerrain, const std::shared_ptr<Buffer>&>& attribute) noexcept;
+        VertexArray& operator<<(const std::pair<TextSelectionVertex, const std::shared_ptr<Buffer>&>& attribute) noexcept;
     };
 
     void swap(VertexArray& lhs, VertexArray& rhs);

include/limitless/instances/instanced_instance.hpp

@@ -34,6 +34,7 @@ namespace Limitless {
         void update(const Camera &camera) override;
 
         auto& getInstances() noexcept { return instances; }
+        const auto& getInstances() const noexcept { return instances; }
         auto& getVisibleInstances() noexcept { return visible_instances; }
         auto& getBuffer() noexcept { return buffer ; }
 

include/limitless/loaders/gltf_model_loader.hpp

@@ -8,6 +8,7 @@
 
 namespace Limitless {
 	class AbstractModel;
+	class TextureLoaderFlags;
 
 	enum class ModelLoaderOption {
 		FlipUV,
@@ -27,6 +28,7 @@ namespace Limitless {
 		std::set<ModelLoaderOption> options;
 		float scale_factor {1.0f};
 		InstanceTypes additional_instance_types;
+		TextureLoaderFlags base_tex_flags;
 
 		auto isPresent(ModelLoaderOption option) const { return options.count(option) != 0; }
 
@@ -39,17 +41,24 @@ namespace Limitless {
 			additional_instance_types.emplace(InstanceType::Instanced);
 			return *this;
 		}
+
+		ModelLoaderFlags& baseTextureLoaderFlags(TextureLoaderFlags tex_flags) {
+			base_tex_flags = std::move(tex_flags);
+			return *this;
+		}
 	};
 
 	class GltfModelLoader {
 	public:
-		// Load a 3D model from given file.
+		// Load a GLTF 3D model from given file.
 		// Will also attempt to load materials referenced in model definition.
 		// Returns a shared pointer to resulting model on success.
 		// Provided assets are modified.
 		// On failure, a ModelLoadError exception is thrown.
 		static std::shared_ptr<AbstractModel> loadModel(
-			Assets& assets, const fs::path& path, const ModelLoaderFlags& flags
+			Assets& assets,
+			const fs::path& path,
+			const ModelLoaderFlags& flags
 		);
 	};
 }

include/limitless/loaders/gltf_model_saver.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <filesystem>
+#include <limitless/assets.hpp>
+#include <limitless/models/model.hpp>
+
+namespace Limitless {
+    struct ModelSaveError : public std::runtime_error { 
+        explicit ModelSaveError(const std::string& msg) noexcept
+            : std::runtime_error(msg) {}
+    };
+
+	class GltfModelSaver {
+	public:
+		static void saveModel(const std::filesystem::path& output_path, const Model& model);
+	};
+}