From f9ce347ca0715ef5ce0f4c88a5f42488e4347019 Mon Sep 17 00:00:00 2001
From: light7734 <light7734@tuta.io>
Date: Thu, 17 Jul 2025 10:44:00 +0330
Subject: [PATCH] feat: initial math module implementation

refactor: replace glm with built-in math library
---
 modules/CMakeLists.txt                        |   1 +
 modules/camera/CMakeLists.txt                 |   2 +-
 modules/camera/include/camera/camera.hpp      |  13 ++-
 modules/camera/include/camera/component.hpp   |   1 -
 modules/camera/src/scene.cpp                  |  32 +++--
 .../ecs/components/sprite_renderer.hpp        |   6 +-
 .../ecs/include/ecs/components/transform.hpp  |  28 +++--
 modules/ecs/include/ecs/scene.hpp             |   1 -
 modules/ecs/src/scene.cpp                     |   1 -
 modules/ecs/src/serializer.cpp                |  29 ++---
 modules/input/CMakeLists.txt                  |   2 +-
 modules/input/include/input/events/mouse.hpp  |   6 +-
 modules/input/include/input/events/window.hpp |  10 +-
 modules/input/include/input/input.hpp         |   8 +-
 modules/input/src/input.cpp                   |   4 +-
 modules/math/CMakeLists.txt                   |   1 +
 modules/math/include/math/algebra.hpp         |  57 +++++++++
 modules/math/include/math/mat4.hpp            | 109 ++++++++++++++++++
 modules/math/include/math/trig.hpp            |  26 +++++
 modules/math/include/math/vec2.hpp            |  56 +++++++++
 modules/math/include/math/vec3.hpp            |  53 +++++++++
 modules/math/include/math/vec4.hpp            |  78 +++++++++++++
 .../mirror/include/mirror/editor_layer.hpp    |   4 +-
 .../include/mirror/panel/properties.hpp       |   3 +-
 modules/mirror/src/editor_layer.cpp           |  13 ++-
 modules/mirror/src/mirror.cpp                 |   3 +-
 modules/mirror/src/panel/properties.cpp       |  11 +-
 .../renderer/include/renderer/framebuffer.hpp |   8 +-
 .../include/renderer/gl/framebuffers.hpp      |   7 +-
 .../include/renderer/gl/render_command.hpp    |   4 +-
 .../include/renderer/programs/quad.hpp        |   6 +-
 .../include/renderer/programs/texture.hpp     |   7 +-
 .../renderer/programs/tinted_texture.hpp      |   9 +-
 .../include/renderer/render_command.hpp       |   5 +-
 .../renderer/include/renderer/renderer.hpp    |  47 ++++----
 modules/renderer/include/renderer/shader.hpp  |   2 -
 modules/renderer/src/gl/framebuffers.cpp      |   5 +-
 modules/renderer/src/gl/render_command.cpp    |   2 +-
 modules/renderer/src/gl/shader.cpp            |   3 -
 modules/renderer/src/renderer.cpp             |  77 ++++++-------
 .../window/include/window/linux/window.hpp    |   2 +-
 modules/window/include/window/window.hpp      |   8 +-
 modules/window/src/linux/window.cpp           |   2 +-
 43 files changed, 564 insertions(+), 188 deletions(-)
 create mode 100644 modules/math/CMakeLists.txt
 create mode 100644 modules/math/include/math/algebra.hpp
 create mode 100644 modules/math/include/math/mat4.hpp
 create mode 100644 modules/math/include/math/trig.hpp
 create mode 100644 modules/math/include/math/vec2.hpp
 create mode 100644 modules/math/include/math/vec3.hpp
 create mode 100644 modules/math/include/math/vec4.hpp

diff --git a/modules/CMakeLists.txt b/modules/CMakeLists.txt
index fc2e0fc..09e490d 100644
--- a/modules/CMakeLists.txt
+++ b/modules/CMakeLists.txt
@@ -3,6 +3,7 @@ add_subdirectory(./base)
 add_subdirectory(./time)
 add_subdirectory(./logger)
 add_subdirectory(./debug)
+add_subdirectory(./math)
 
 add_subdirectory(./asset_baker)
 add_subdirectory(./asset_parser)
diff --git a/modules/camera/CMakeLists.txt b/modules/camera/CMakeLists.txt
index b1c5525..35083e5 100644
--- a/modules/camera/CMakeLists.txt
+++ b/modules/camera/CMakeLists.txt
@@ -1,3 +1,3 @@
 add_library_module(camera camera.cpp scene.cpp)
 
-target_link_libraries(camera PUBLIC glm::glm)
+target_link_libraries(camera PUBLIC math)
diff --git a/modules/camera/include/camera/camera.hpp b/modules/camera/include/camera/camera.hpp
index 244ca7c..b6c4fa7 100644
--- a/modules/camera/include/camera/camera.hpp
+++ b/modules/camera/include/camera/camera.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
-#include <glm/glm.hpp>
+#include <math/mat4.hpp>
+#include <math/vec4.hpp>
 
 namespace lt {
 
@@ -9,26 +10,26 @@ class Camera
 public:
 	Camera() = default;
 
-	[[nodiscard]] auto get_projection() const -> const glm::mat4 &
+	[[nodiscard]] auto get_projection() const -> const math::mat4 &
 	{
 		return m_projection;
 	}
 
-	[[nodiscard]] auto get_background_color() const -> const glm::vec4 &
+	[[nodiscard]] auto get_background_color() const -> const math::vec4 &
 	{
 		return m_background_color;
 	}
 
-	void set_background_color(const glm::vec4 &color)
+	void set_background_color(const math::vec4 &color)
 	{
 		m_background_color = color;
 	}
 
 protected:
-	glm::mat4 m_projection {};
+	math::mat4 m_projection;
 
 private:
-	glm::vec4 m_background_color = glm::vec4(1.0f, 0.0f, 0.0f, 1.0f);
+	math::vec4 m_background_color = math::vec4(1.0f, 0.0f, 0.0f, 1.0f);
 };
 
 } // namespace lt
diff --git a/modules/camera/include/camera/component.hpp b/modules/camera/include/camera/component.hpp
index 895baea..0bd75ea 100644
--- a/modules/camera/include/camera/component.hpp
+++ b/modules/camera/include/camera/component.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
 #include <camera/scene.hpp>
-#include <glm/glm.hpp>
 
 namespace lt {
 
diff --git a/modules/camera/src/scene.cpp b/modules/camera/src/scene.cpp
index 038b6d0..466f662 100644
--- a/modules/camera/src/scene.cpp
+++ b/modules/camera/src/scene.cpp
@@ -1,11 +1,12 @@
 #include <camera/scene.hpp>
-#include <glm/gtc/matrix_transform.hpp>
+#include <math/algebra.hpp>
+#include <math/trig.hpp>
 
 namespace lt {
 
 SceneCamera::SceneCamera()
     : m_orthographic_specification { .size = 1000.0f, .near_plane = -1.0f, .far_plane = 10000.0f }
-    , m_perspective_specification { .vertical_fov = glm::radians(45.0f),
+    , m_perspective_specification { .vertical_fov = math::radians(45.0f),
 	                                .near_plane = 0.01f,
 	                                .far_plane = 10000.0f }
     , m_aspect_ratio(16.0f / 9.0f)
@@ -64,26 +65,19 @@ void SceneCamera::set_perspective_near_plane(float near_plane)
 
 void SceneCamera::calculate_projection()
 {
+	// TODO(Light): implement ortho perspective
 	if (m_projection_type == ProjectionType::Orthographic)
 	{
-		m_projection = glm::ortho(
-		    -m_orthographic_specification.size * 0.5f * m_aspect_ratio,
-		    m_orthographic_specification.size * 0.5f * m_aspect_ratio,
-		    -m_orthographic_specification.size * 0.5f,
-		    m_orthographic_specification.size * 0.5f,
-		    m_orthographic_specification.far_plane,
-		    m_orthographic_specification.near_plane
-		);
-	}
-	else // perspective
-	{
-		m_projection = glm::perspective(
-		    m_perspective_specification.vertical_fov,
-		    m_aspect_ratio,
-		    m_perspective_specification.near_plane,
-		    m_perspective_specification.far_plane
-		);
+		// throw std::runtime_error { "ortho perspective not supported yet" };
 	}
+
+	// defaults to perspective for now...
+	m_projection = math::perspective(
+	    m_perspective_specification.vertical_fov,
+	    m_aspect_ratio,
+	    m_perspective_specification.near_plane,
+	    m_perspective_specification.far_plane
+	);
 }
 
 } // namespace lt
diff --git a/modules/ecs/include/ecs/components/sprite_renderer.hpp b/modules/ecs/include/ecs/components/sprite_renderer.hpp
index ece1fb5..2b11c3d 100644
--- a/modules/ecs/include/ecs/components/sprite_renderer.hpp
+++ b/modules/ecs/include/ecs/components/sprite_renderer.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <glm/glm.hpp>
+#include <math/vec4.hpp>
 #include <utility>
 
 namespace lt {
@@ -15,7 +15,7 @@ struct SpriteRendererComponent
 
 	SpriteRendererComponent(
 	    Ref<Texture> _texture,
-	    const glm::vec4 &_tint = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f)
+	    const math::vec4 &_tint = math::vec4 { 1.0f, 1.0f, 1.0f, 1.0f }
 	)
 	    : texture(std::move(std::move(_texture)))
 	    , tint(_tint)
@@ -29,7 +29,7 @@ struct SpriteRendererComponent
 
 	Ref<Texture> texture;
 
-	glm::vec4 tint {};
+	math::vec4 tint {};
 };
 
 } // namespace lt
diff --git a/modules/ecs/include/ecs/components/transform.hpp b/modules/ecs/include/ecs/components/transform.hpp
index a03fd54..cd9fe4e 100644
--- a/modules/ecs/include/ecs/components/transform.hpp
+++ b/modules/ecs/include/ecs/components/transform.hpp
@@ -1,10 +1,7 @@
 #pragma once
 
-#define GLM_ENABLE_EXPERIMENTAL
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtx/transform.hpp>
+#include <math/mat4.hpp>
+#include <math/vec3.hpp>
 
 namespace lt {
 
@@ -13,9 +10,9 @@ struct TransformComponent
 	TransformComponent(const TransformComponent &) = default;
 
 	TransformComponent(
-	    const glm::vec3 &_translation = glm::vec3(0.0f, 0.0f, 0.0f),
-	    const glm::vec3 &_scale = glm::vec3(1.0f, 1.0f, 1.0f),
-	    const glm::vec3 &_rotation = glm::vec3(0.0f, 0.0f, 0.0f)
+	    const math::vec3 &_translation = math::vec3(0.0f, 0.0f, 0.0f),
+	    const math::vec3 &_scale = math::vec3(1.0f, 1.0f, 1.0f),
+	    const math::vec3 &_rotation = math::vec3(0.0f, 0.0f, 0.0f)
 	)
 
 	    : translation(_translation)
@@ -24,22 +21,23 @@ struct TransformComponent
 	{
 	}
 
-	[[nodiscard]] auto get_transform() const -> glm::mat4
+	[[nodiscard]] auto get_transform() const -> math::mat4
 	{
-		return glm::translate(translation) * glm::rotate(rotation.z, glm::vec3(0.0f, 0.0f, 1.0f))
-		       * glm::scale(scale);
+		return math::translate(translation)
+		       * math::rotate(rotation.z, math::vec3 { 0.0f, 0.0f, 1.0f }) //
+		       * math::scale(scale);
 	}
 
-	operator const glm::mat4() const
+	operator const math::mat4() const
 	{
 		return get_transform();
 	}
 
-	glm::vec3 translation;
+	math::vec3 translation;
 
-	glm::vec3 scale;
+	math::vec3 scale;
 
-	glm::vec3 rotation;
+	math::vec3 rotation;
 };
 
 } // namespace lt
diff --git a/modules/ecs/include/ecs/scene.hpp b/modules/ecs/include/ecs/scene.hpp
index 17979dc..02c8911 100644
--- a/modules/ecs/include/ecs/scene.hpp
+++ b/modules/ecs/include/ecs/scene.hpp
@@ -3,7 +3,6 @@
 #include <ecs/components/transform.hpp>
 #include <ecs/uuid.hpp>
 #include <entt/entt.hpp>
-#include <glm/glm.hpp>
 
 namespace lt {
 
diff --git a/modules/ecs/src/scene.cpp b/modules/ecs/src/scene.cpp
index 2c4e00b..12444fe 100644
--- a/modules/ecs/src/scene.cpp
+++ b/modules/ecs/src/scene.cpp
@@ -2,7 +2,6 @@
 #include <ecs/components.hpp>
 #include <ecs/entity.hpp>
 #include <ecs/scene.hpp>
-#include <glm/glm.hpp>
 #include <renderer/renderer.hpp>
 
 namespace lt {
diff --git a/modules/ecs/src/serializer.cpp b/modules/ecs/src/serializer.cpp
index 793226d..3dd1335 100644
--- a/modules/ecs/src/serializer.cpp
+++ b/modules/ecs/src/serializer.cpp
@@ -2,14 +2,16 @@
 #include <camera/component.hpp>
 #include <ecs/components.hpp>
 #include <ecs/serializer.hpp>
+#include <math/vec3.hpp>
+#include <math/vec4.hpp>
 #include <yaml-cpp/yaml.h>
 
 namespace YAML {
 
 template<>
-struct convert<glm::vec3>
+struct convert<lt::math::vec3>
 {
-	static auto encode(const glm::vec3 &rhs) -> Node
+	static auto encode(const lt::math::vec3 &rhs) -> Node
 	{
 		auto node = Node {};
 		node.push_back(rhs.x);
@@ -18,7 +20,7 @@ struct convert<glm::vec3>
 		return node;
 	}
 
-	static auto decode(const Node &node, glm::vec3 &rhs) -> bool
+	static auto decode(const Node &node, lt::math::vec3 &rhs) -> bool
 	{
 		if (!node.IsSequence() || node.size() != 3)
 		{
@@ -33,9 +35,9 @@ struct convert<glm::vec3>
 };
 
 template<>
-struct convert<glm::vec4>
+struct convert<lt::math::vec4>
 {
-	static auto encode(const glm::vec4 &rhs) -> Node
+	static auto encode(const lt::math::vec4 &rhs) -> Node
 	{
 		auto node = Node {};
 		node.push_back(rhs.x);
@@ -45,7 +47,7 @@ struct convert<glm::vec4>
 		return node;
 	}
 
-	static auto decode(const Node &node, glm::vec4 &rhs) -> bool
+	static auto decode(const Node &node, lt::math::vec4 &rhs) -> bool
 	{
 		if (!node.IsSequence() || node.size() != 4)
 		{
@@ -63,14 +65,14 @@ struct convert<glm::vec4>
 
 namespace lt {
 
-auto operator<<(YAML::Emitter &out, const glm::vec3 &v) -> YAML::Emitter &
+auto operator<<(YAML::Emitter &out, const math::vec3 &v) -> YAML::Emitter &
 {
 	out << YAML::Flow;
 	out << YAML::BeginSeq << v.x << v.y << v.z << YAML::EndSeq;
 	return out;
 }
 
-auto operator<<(YAML::Emitter &out, const glm::vec4 &v) -> YAML::Emitter &
+auto operator<<(YAML::Emitter &out, const math::vec4 &v) -> YAML::Emitter &
 {
 	out << YAML::Flow;
 	out << YAML::BeginSeq << v.x << v.y << v.z << v.w << YAML::EndSeq;
@@ -156,9 +158,10 @@ auto SceneSerializer::deserialize(const std::string &file_path) -> bool
 				                                      .get_component<TransformComponent>();
 
 				entityTransforomComponent.translation = transformComponent["Translation"]
-				                                            .as<glm::vec3>();
-				entityTransforomComponent.rotation = transformComponent["Rotation"].as<glm::vec3>();
-				entityTransforomComponent.scale = transformComponent["Scale"].as<glm::vec3>();
+				                                            .as<math::vec3>();
+				entityTransforomComponent.rotation = transformComponent["Rotation"]
+				                                         .as<math::vec3>();
+				entityTransforomComponent.scale = transformComponent["Scale"].as<math::vec3>();
 			}
 
 			/* #TEMPORARY SOLUTION# */
@@ -168,7 +171,7 @@ auto SceneSerializer::deserialize(const std::string &file_path) -> bool
 				auto &entitySpriteRendererComponent = deserializedEntity
 				                                          .add_component<SpriteRendererComponent>();
 				entitySpriteRendererComponent.tint = spriteRendererComponent["Tint"]
-				                                         .as<glm::vec4>();
+				                                         .as<math::vec4>();
 
 				auto texturePath = spriteRendererComponent["Texture"].as<std::string>();
 
@@ -213,7 +216,7 @@ auto SceneSerializer::deserialize(const std::string &file_path) -> bool
 				);
 
 				entityCameraComponent.camera.set_background_color(
-				    cameraSpecifications["BackgroundColor"].as<glm::vec4>()
+				    cameraSpecifications["BackgroundColor"].as<math::vec4>()
 				);
 
 				entityCameraComponent.isPrimary = cameraComponent["IsPrimary"].as<bool>();
diff --git a/modules/input/CMakeLists.txt b/modules/input/CMakeLists.txt
index f8aa62f..dbf7a96 100644
--- a/modules/input/CMakeLists.txt
+++ b/modules/input/CMakeLists.txt
@@ -1,2 +1,2 @@
 add_library_module(input input.cpp)
-target_link_libraries(input PUBLIC glm::glm imgui logger)
+target_link_libraries(input PUBLIC math imgui logger)
diff --git a/modules/input/include/input/events/mouse.hpp b/modules/input/include/input/events/mouse.hpp
index 77b4d8e..99f9128 100644
--- a/modules/input/include/input/events/mouse.hpp
+++ b/modules/input/include/input/events/mouse.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
-#include <glm/glm.hpp>
 #include <input/events/event.hpp>
+#include <math/vec2.hpp>
 #include <sstream>
 
 namespace lt {
@@ -13,7 +13,7 @@ public:
 	{
 	}
 
-	[[nodiscard]] auto get_position() const -> const glm::vec2 &
+	[[nodiscard]] auto get_position() const -> const math::vec2 &
 	{
 		return m_position;
 	}
@@ -46,7 +46,7 @@ public:
 	}
 
 private:
-	const glm::vec2 m_position;
+	const math::vec2 m_position;
 };
 
 class WheelScrolledEvent: public Event
diff --git a/modules/input/include/input/events/window.hpp b/modules/input/include/input/events/window.hpp
index 40b65ee..063711f 100644
--- a/modules/input/include/input/events/window.hpp
+++ b/modules/input/include/input/events/window.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
-#include <glm/glm.hpp>
 #include <input/events/event.hpp>
+#include <math/vec2.hpp>
 #include <sstream>
 
 namespace lt {
@@ -32,7 +32,7 @@ public:
 	{
 	}
 
-	[[nodiscard]] auto get_position() const -> const glm::ivec2 &
+	[[nodiscard]] auto get_position() const -> const math::ivec2 &
 	{
 		return m_position;
 	}
@@ -56,7 +56,7 @@ public:
 	}
 
 private:
-	const glm::ivec2 m_position;
+	const math::ivec2 m_position;
 };
 
 class WindowResizedEvent: public Event
@@ -66,7 +66,7 @@ public:
 	{
 	}
 
-	[[nodiscard]] auto get_size() const -> const glm::uvec2 &
+	[[nodiscard]] auto get_size() const -> const math::uvec2 &
 	{
 		return m_size;
 	}
@@ -89,7 +89,7 @@ public:
 	}
 
 private:
-	const glm::uvec2 m_size;
+	const math::uvec2 m_size;
 };
 
 class WindowLostFocusEvent: public Event
diff --git a/modules/input/include/input/input.hpp b/modules/input/include/input/input.hpp
index 78a0e4d..d612f19 100644
--- a/modules/input/include/input/input.hpp
+++ b/modules/input/include/input/input.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <array>
-#include <glm/glm.hpp>
+#include <math/vec2.hpp>
 
 namespace lt {
 
@@ -36,7 +36,7 @@ public:
 		return instance().m_mouse_buttons[code];
 	}
 
-	static auto get_mouse_position(int /*code*/) -> const glm::vec2 &
+	static auto get_mouse_position(int /*code*/) -> const math::vec2 &
 	{
 		return instance().m_mouse_position;
 	}
@@ -66,9 +66,9 @@ private:
 
 	std::array<bool, 8> m_mouse_buttons {};
 
-	glm::vec2 m_mouse_position;
+	math::vec2 m_mouse_position;
 
-	glm::vec2 m_mouse_delta;
+	math::vec2 m_mouse_delta;
 
 	float m_mouse_wheel_delta {};
 
diff --git a/modules/input/src/input.cpp b/modules/input/src/input.cpp
index 4524466..ffcc64f 100644
--- a/modules/input/src/input.cpp
+++ b/modules/input/src/input.cpp
@@ -36,8 +36,8 @@ void Input::restart_input_state()
 	m_keyboad_keys.fill(false);
 	m_mouse_buttons.fill(false);
 
-	m_mouse_position = glm::vec2(0.0f);
-	m_mouse_delta = glm::vec2(0.0f);
+	m_mouse_position = math::vec2(0.0f);
+	m_mouse_delta = math::vec2(0.0f);
 	m_mouse_wheel_delta = 0.0f;
 }
 
diff --git a/modules/math/CMakeLists.txt b/modules/math/CMakeLists.txt
new file mode 100644
index 0000000..4ad9498
--- /dev/null
+++ b/modules/math/CMakeLists.txt
@@ -0,0 +1 @@
+add_library_module(math)
diff --git a/modules/math/include/math/algebra.hpp b/modules/math/include/math/algebra.hpp
new file mode 100644
index 0000000..895bd67
--- /dev/null
+++ b/modules/math/include/math/algebra.hpp
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <math/mat4.hpp>
+
+namespace lt::math {
+
+
+/**
+ * let...
+ * a = h / w ==> for aspect ratio adjustment
+ * f = 1 / tan(fov / 2) ==> for field of view
+ *
+ * zdiff = zfar-znear
+ * A = (zfar / zdiff) - (zfar / zdiff * znear) ==> for normalization
+ *
+ * given a 3d position vector xyz, we need to do the following operations to achieve
+ * perspective projection:
+ * x        afx
+ * y -->    fy
+ * z     Az - Aznear
+ *
+ * such calculation can be embdedded in a matrix as:
+ *     [x]     [y]     [z]    [w]
+ *
+ *  |  af   |  0    |  0    | 0      |
+ *  ----------------------------------
+ *  |  0    |  f    |  0    | 0      |
+ *  ----------------------------------
+ *  |  0    |  0    |  A    | A*znear|
+ *  ----------------------------------
+ *  |  0    |  0    |  1    | 0      |
+ *
+ * the 1 at [z][3] is to save the Z axis into the resulting W for perspective division.
+ *
+ * thanks to pikuma: https://www.youtube.com/watch?v=EqNcqBdrNyI
+ */
+template<typename T>
+constexpr auto perspective(T field_of_view, T aspect_ratio, T z_near, T z_far)
+{
+	const T half_fov_tan = std::tan(field_of_view / static_cast<T>(2));
+
+	auto result = mat4_impl<T> { T { 0 } };
+
+	result[0][0] = T { 1 } / (aspect_ratio * half_fov_tan);
+
+	result[1][1] = T { 1 } / (half_fov_tan);
+
+	result[2][2] = -(z_far + z_near) / (z_far - z_near);
+
+	result[2][3] = -T { 1 };
+
+	result[3][2] = -(T { 2 } * z_far * z_near) / (z_far - z_near);
+
+	return result;
+}
+
+} // namespace lt::math
diff --git a/modules/math/include/math/mat4.hpp b/modules/math/include/math/mat4.hpp
new file mode 100644
index 0000000..499f471
--- /dev/null
+++ b/modules/math/include/math/mat4.hpp
@@ -0,0 +1,109 @@
+#pragma once
+
+#include <math/vec3.hpp>
+#include <math/vec4.hpp>
+
+namespace lt::math {
+
+template<typename T = float>
+struct mat4_impl
+{
+	using Column_T = vec4_impl<T>;
+	explicit mat4_impl(T scalar = 0)
+	    : values(
+	          {
+	              Column_T { scalar },
+	              Column_T { scalar },
+	              Column_T { scalar },
+	              Column_T { scalar },
+	          }
+	      )
+	{
+	}
+
+	// clang-format off
+    mat4_impl(
+        const T&  x0, const T&  y0, const T&  z0, const T&  w0,
+        const T&  x1, const T&  y1, const T&  z1, const T&  w1,
+        const T&  x2, const T&  y2, const T&  z2, const T&  w2,
+        const T&  x3, const T&  y3, const T&  z3, const T&  w3
+    )
+	    // clang-format on
+	    : values({ { x0, x1, x2, x3 }, { y0, y1, y2, y3 }, { z0, z1, z2, z3 }, { w0, w1, w2, w3 } })
+	{
+	}
+
+	mat4_impl(
+	    const Column_T &column_x,
+	    const Column_T &column_y,
+	    const Column_T &column_z,
+	    const Column_T &column_w
+	)
+	    : values({ column_x, column_y, column_z, column_w })
+	{
+	}
+
+	[[nodiscard]] constexpr auto identity() -> mat4_impl<T>
+	{
+		return mat4_impl<T> {
+			{ 1 }, {},    {},    {},    //
+			{},    { 1 }, {},    {},    //
+			{},    {},    { 1 }, {},    //
+			{},    {},    {},    { 1 }, //
+		};
+	}
+
+	[[nodiscard]] auto operator[](size_t idx) -> Column_T &
+	{
+		return values[idx];
+	}
+
+	[[nodiscard]] auto operator[](size_t idx) const -> const Column_T &
+	{
+		return values[idx];
+	}
+
+	[[nodiscard]] auto operator*(const mat4_impl<T> &other) const -> mat4_impl<T>
+	{
+		return mat4_impl<T> {};
+	}
+
+	[[nodiscard]] auto operator*(const vec4_impl<T> &other) const -> vec4_impl<T>
+	{
+		return vec4_impl<T> {};
+	}
+
+	std::array<Column_T, 4> values; // NOLINT
+};
+
+template<typename T>
+[[nodiscard]] inline auto translate(const vec3_impl<T> &value) -> mat4_impl<T>
+{
+	return mat4_impl<T> {};
+}
+
+template<typename T>
+[[nodiscard]] inline auto rotate(float value, const vec3_impl<T> &xyz) -> mat4_impl<T>
+{
+	return mat4_impl<T> {};
+}
+
+template<typename T>
+[[nodiscard]] inline auto scale(const vec3_impl<T> &value) -> mat4_impl<T>
+{
+	return mat4_impl<T> {};
+}
+
+template<typename T>
+[[nodiscard]] inline auto inverse(const mat4_impl<T> &value) -> mat4_impl<T>
+{
+	return mat4_impl<T> {};
+}
+
+using mat4 = mat4_impl<float>;
+
+using imat4 = mat4_impl<int32_t>;
+
+using umat4 = mat4_impl<uint32_t>;
+
+} // namespace lt::math
diff --git a/modules/math/include/math/trig.hpp b/modules/math/include/math/trig.hpp
new file mode 100644
index 0000000..9e5842b
--- /dev/null
+++ b/modules/math/include/math/trig.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+namespace lt::math {
+
+[[nodiscard]] constexpr auto radians(float degrees) -> float
+{
+	return degrees * 0.01745329251994329576923690768489f;
+}
+
+[[nodiscard]] constexpr auto radians(double degrees) -> double
+{
+	return degrees * 0.01745329251994329576923690768489;
+}
+
+[[nodiscard]] constexpr auto degrees(float radians) -> float
+{
+	return radians * 57.295779513082320876798154814105f;
+}
+
+[[nodiscard]] constexpr auto degrees(double radians) -> double
+{
+	return radians * 57.295779513082320876798154814105;
+}
+
+
+} // namespace lt::math
diff --git a/modules/math/include/math/vec2.hpp b/modules/math/include/math/vec2.hpp
new file mode 100644
index 0000000..694d97d
--- /dev/null
+++ b/modules/math/include/math/vec2.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+namespace lt::math {
+
+template<typename T = float>
+struct vec2_impl
+{
+	vec2_impl(): x(), y()
+	{
+	}
+
+	explicit vec2_impl(T scalar): x(scalar), y(scalar)
+	{
+	}
+
+	vec2_impl(T x, T y): x(x), y(y)
+	{
+	}
+
+	[[nodiscard]] auto operator*(const vec2_impl<T> &other) const -> vec2_impl
+	{
+		return {
+			x * other.x,
+			y * other.y,
+		};
+	}
+
+	[[nodiscard]] auto operator-(const vec2_impl<T> &other) const -> vec2_impl
+	{
+		return {
+			x - other.x,
+			y - other.y,
+		};
+	}
+
+	[[nodiscard]] auto operator*(float scalar) const -> vec2_impl
+	{
+		return {
+			x * scalar,
+			y * scalar,
+		};
+	}
+
+
+	T x; // NOLINT
+
+	T y; // NOLINT
+};
+
+using vec2 = vec2_impl<float>;
+
+using ivec2 = vec2_impl<int32_t>;
+
+using uvec2 = vec2_impl<uint32_t>;
+
+} // namespace lt::math
diff --git a/modules/math/include/math/vec3.hpp b/modules/math/include/math/vec3.hpp
new file mode 100644
index 0000000..685a0c3
--- /dev/null
+++ b/modules/math/include/math/vec3.hpp
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <math/vec2.hpp>
+
+namespace lt::math {
+
+template<typename T = float>
+struct vec3_impl
+{
+	vec3_impl(): x(), y(), z()
+	{
+	}
+
+	explicit vec3_impl(T scalar): x(scalar), y(scalar), z(scalar)
+	{
+	}
+
+	vec3_impl(T x, T y, T z): x(x), y(y), z(z)
+	{
+	}
+
+	[[nodiscard]] auto operator-(const vec3_impl<T> &other) const -> vec3_impl
+	{
+		return {
+			x - other.x,
+			y - other.y,
+			z - other.z,
+		};
+	}
+
+	[[nodiscard]] auto operator*(const vec3_impl<T> &other) const -> vec3_impl
+	{
+		return {
+			x * other.x,
+			y * other.y,
+			z * other.z,
+		};
+	}
+
+	T x; // NOLINT
+
+	T y; // NOLINT
+
+	T z; // NOLINT
+};
+
+using vec3 = vec3_impl<float>;
+
+using ivec3 = vec3_impl<int32_t>;
+
+using uvec3 = vec3_impl<uint32_t>;
+
+} // namespace lt::math
diff --git a/modules/math/include/math/vec4.hpp b/modules/math/include/math/vec4.hpp
new file mode 100644
index 0000000..d505446
--- /dev/null
+++ b/modules/math/include/math/vec4.hpp
@@ -0,0 +1,78 @@
+#pragma once
+
+#include <array>
+
+namespace lt::math {
+
+template<typename T = float>
+struct vec4_impl
+{
+	vec4_impl(): x(), y(), z(), w()
+	{
+	}
+
+	explicit vec4_impl(T scalar): x(scalar), y(scalar), z(scalar), w(scalar)
+	{
+	}
+
+	vec4_impl(T x, T y, T z, T w): x(x), y(y), z(z), w(w)
+	{
+	}
+
+	[[nodiscard]] auto operator-(const vec4_impl<T> &other) const -> vec4_impl
+	{
+		return {
+			x - other.x,
+			y - other.y,
+			z - other.z,
+			w - other.w,
+		};
+	}
+
+	[[nodiscard]] auto operator[](size_t idx) -> T &
+	{
+		return values[idx];
+	}
+
+	[[nodiscard]] auto operator[](size_t idx) const -> const T &
+	{
+		return values[idx];
+	}
+
+	// NOLINTNEXTLINE
+	union
+	{
+		struct
+		{
+			T x;
+
+			T y;
+
+			T z;
+
+			T w;
+		};
+		struct
+		{
+			T r;
+
+			T g;
+
+			T b;
+
+			T a;
+		};
+		struct
+		{
+			std::array<T, 4> values;
+		};
+	};
+};
+
+using vec4 = vec4_impl<float>;
+
+using ivec4 = vec4_impl<int32_t>;
+
+using uvec4 = vec4_impl<uint32_t>;
+
+} // namespace lt::math
diff --git a/modules/mirror/include/mirror/editor_layer.hpp b/modules/mirror/include/mirror/editor_layer.hpp
index 542585f..9d8bda9 100644
--- a/modules/mirror/include/mirror/editor_layer.hpp
+++ b/modules/mirror/include/mirror/editor_layer.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
 #include <app/layer.hpp>
-#include <glm/gtc/matrix_transform.hpp>
 #include <imgui.h>
+#include <math/vec2.hpp>
 #include <mirror/panel/asset_browser.hpp>
 #include <mirror/panel/properties.hpp>
 #include <mirror/panel/scene_hierarchy.hpp>
@@ -36,7 +36,7 @@ public:
 private:
 	std::string m_scene_dir;
 
-	glm::vec2 m_direction;
+	math::vec2 m_direction;
 
 	float m_speed = 1000.0f;
 
diff --git a/modules/mirror/include/mirror/panel/properties.hpp b/modules/mirror/include/mirror/panel/properties.hpp
index cde0039..8ea18df 100644
--- a/modules/mirror/include/mirror/panel/properties.hpp
+++ b/modules/mirror/include/mirror/panel/properties.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <ecs/entity.hpp>
+#include <math/vec3.hpp>
 #include <mirror/panel/panel.hpp>
 
 namespace lt {
@@ -17,7 +18,7 @@ public:
 private:
 	void draw_vec3_control(
 	    const std::string &label,
-	    glm::vec3 &values,
+	    math::vec3 &values,
 	    float reset_value = 0.0f,
 	    float column_width = 100.0f
 	);
diff --git a/modules/mirror/src/editor_layer.cpp b/modules/mirror/src/editor_layer.cpp
index d52a443..fc34262 100644
--- a/modules/mirror/src/editor_layer.cpp
+++ b/modules/mirror/src/editor_layer.cpp
@@ -6,6 +6,7 @@
 #include <ecs/serializer.hpp>
 #include <input/input.hpp>
 #include <input/key_codes.hpp>
+#include <math/vec4.hpp>
 #include <mirror/editor_layer.hpp>
 #include <renderer/framebuffer.hpp>
 #include <renderer/graphics_context.hpp>
@@ -44,7 +45,7 @@ EditorLayer::EditorLayer(const std::string &name)
 		auto entity = Entity { m_scene->create_entity("Awesomeface", {}) };
 		entity.add_component<SpriteRendererComponent>(
 		    AssetManager::get_texture("Awesomeface"),
-		    glm::vec4 { 0.0f, 1.0f, 1.0f, 1.0f }
+		    math::vec4 { 0.0f, 1.0f, 1.0f, 1.0f }
 		);
 	}
 	else
@@ -96,7 +97,8 @@ void EditorLayer::on_update(float delta_time)
 	}
 
 	auto &translation = m_camera_entity.get_component<TransformComponent>().translation;
-	translation += glm::vec3 { m_direction * m_speed * delta_time, 0.0f };
+	auto velocity = m_direction * m_speed * delta_time;
+	translation = translation * math::vec3 { velocity.x, velocity.y, 0.0f };
 
 	if (Input::get_keyboard_key(Key::Escape))
 	{
@@ -122,7 +124,12 @@ void EditorLayer::on_user_interface_update()
 		if (m_available_content_region_prev.x != available_region.x
 		    || m_available_content_region_prev.y != available_region.y)
 		{
-			m_framebuffer->resize({ available_region.x, available_region.y });
+			m_framebuffer->resize(
+			    math::uvec2 {
+			        static_cast<uint32_t>(available_region.x),
+			        static_cast<uint32_t>(available_region.y),
+			    }
+			);
 			auto &camera = m_camera_entity.get_component<CameraComponent>().camera;
 			camera.set_viewport_size(
 			    static_cast<uint32_t>(available_region.x),
diff --git a/modules/mirror/src/mirror.cpp b/modules/mirror/src/mirror.cpp
index 8b6c585..2c23c1d 100644
--- a/modules/mirror/src/mirror.cpp
+++ b/modules/mirror/src/mirror.cpp
@@ -1,6 +1,7 @@
 #include <app/application.hpp>
 #include <app/entrypoint.hpp>
 #include <app/layer_stack.hpp>
+#include <math/vec2.hpp>
 #include <mirror/editor_layer.hpp>
 #include <window/window.hpp>
 
@@ -14,7 +15,7 @@ public:
 		get_window().set_properties(
 		    Window::Properties {
 		        .title = "Mirror",
-		        .size = glm::uvec2(1280u, 720u),
+		        .size = math::uvec2(1280u, 720u),
 		        .vsync = true,
 		    }
 		);
diff --git a/modules/mirror/src/panel/properties.cpp b/modules/mirror/src/panel/properties.cpp
index 6efa901..782ba04 100644
--- a/modules/mirror/src/panel/properties.cpp
+++ b/modules/mirror/src/panel/properties.cpp
@@ -1,10 +1,9 @@
 #include <asset_manager/asset_manager.hpp>
 #include <camera/component.hpp>
 #include <ecs/components.hpp>
-#include <glm/glm.hpp>
-#include <glm/gtc/type_ptr.hpp>
 #include <imgui.h>
 #include <imgui_internal.h>
+#include <math/trig.hpp>
 #include <mirror/panel/properties.hpp>
 
 namespace lt {
@@ -21,7 +20,7 @@ void PropertiesPanel::on_user_interface_update()
 
 			auto buffer = std::array<char, 256> {};
 			memset(buffer.data(), 0, buffer.size());
-			std::strncpy(buffer.data(), tagComponent.tag.c_str(), buffer.size());
+			strncpy(buffer.data(), tagComponent.tag.c_str(), buffer.size());
 
 			if (ImGui::InputText("##Tag", buffer.data(), buffer.size()))
 			{
@@ -147,13 +146,13 @@ void PropertiesPanel::on_user_interface_update()
 				    auto near_plane = float {};
 				    auto far_plane = float {};
 
-				    vertical_fov = glm::degrees(camera.get_perspective_vertical_fov());
+				    vertical_fov = math::degrees(camera.get_perspective_vertical_fov());
 				    near_plane = camera.get_perspective_near_plane();
 				    far_plane = camera.get_perspective_far_plane();
 
 				    if (ImGui::DragFloat("Vertical FOV", &vertical_fov))
 				    {
-					    camera.set_perspective_vertical_fov(glm::radians(vertical_fov));
+					    camera.set_perspective_vertical_fov(math::radians(vertical_fov));
 				    }
 
 				    if (ImGui::DragFloat("Near Plane", &near_plane))
@@ -182,7 +181,7 @@ void PropertiesPanel::set_entity_context(const Entity &entity)
 
 void PropertiesPanel::draw_vec3_control(
     const std::string &label,
-    glm::vec3 &values,
+    math::vec3 &values,
     float reset_value,
     float column_width
 )
diff --git a/modules/renderer/include/renderer/framebuffer.hpp b/modules/renderer/include/renderer/framebuffer.hpp
index b4d3b0b..458b25e 100644
--- a/modules/renderer/include/renderer/framebuffer.hpp
+++ b/modules/renderer/include/renderer/framebuffer.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
-
-#include <glm/glm.hpp>
+#include <math/vec2.hpp>
+#include <math/vec4.hpp>
 
 namespace lt {
 
@@ -25,11 +25,11 @@ public:
 	    const Ref<SharedContext> &sharedContext
 	) -> Ref<Framebuffer>;
 
-	virtual void bind_as_target(const glm::vec4 &clearColor) = 0;
+	virtual void bind_as_target(const math::vec4 &clearColor) = 0;
 
 	virtual void bind_as_resource() = 0;
 
-	virtual void resize(const glm::uvec2 &size) = 0;
+	virtual void resize(const math::uvec2 &size) = 0;
 
 	virtual auto get_color_attachment() -> void * = 0;
 
diff --git a/modules/renderer/include/renderer/gl/framebuffers.hpp b/modules/renderer/include/renderer/gl/framebuffers.hpp
index fd18364..0ae08ac 100644
--- a/modules/renderer/include/renderer/gl/framebuffers.hpp
+++ b/modules/renderer/include/renderer/gl/framebuffers.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
-
+#include <math/vec2.hpp>
+#include <math/vec4.hpp>
 #include <renderer/framebuffer.hpp>
 
 namespace lt {
@@ -12,11 +13,11 @@ public:
 
 	~glFramebuffer() override;
 
-	void bind_as_target(const glm::vec4 &clearColor) override;
+	void bind_as_target(const math::vec4 &clearColor) override;
 
 	void bind_as_resource() override;
 
-	void resize(const glm::uvec2 &size) override;
+	void resize(const math::uvec2 &size) override;
 
 	auto get_color_attachment() -> void * override
 	{
diff --git a/modules/renderer/include/renderer/gl/render_command.hpp b/modules/renderer/include/renderer/gl/render_command.hpp
index 51e426b..86f78a4 100644
--- a/modules/renderer/include/renderer/gl/render_command.hpp
+++ b/modules/renderer/include/renderer/gl/render_command.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-
+#include <math/vec4.hpp>
 #include <renderer/render_command.hpp>
 
 struct GLFWwindow;
@@ -14,7 +14,7 @@ public:
 
 	void swap_buffers() override;
 
-	void clear_back_buffer(const glm::vec4 &clearColor) override;
+	void clear_back_buffer(const math::vec4 &clearColor) override;
 
 	void draw(unsigned int count) override;
 
diff --git a/modules/renderer/include/renderer/programs/quad.hpp b/modules/renderer/include/renderer/programs/quad.hpp
index 053282b..4f80750 100644
--- a/modules/renderer/include/renderer/programs/quad.hpp
+++ b/modules/renderer/include/renderer/programs/quad.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <glm/glm.hpp>
+#include <math/vec4.hpp>
 #include <renderer/programs/renderer_program.hpp>
 
 namespace lt {
@@ -19,9 +19,9 @@ public:
 	~QuadRendererProgram() override = default;
 	struct QuadVertexData
 	{
-		glm::vec4 position;
+		math::vec4 position;
 
-		glm::vec4 tint;
+		math::vec4 tint;
 	};
 
 	QuadRendererProgram(
diff --git a/modules/renderer/include/renderer/programs/texture.hpp b/modules/renderer/include/renderer/programs/texture.hpp
index e14573f..5a5686c 100644
--- a/modules/renderer/include/renderer/programs/texture.hpp
+++ b/modules/renderer/include/renderer/programs/texture.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
-#include <glm/glm.hpp>
+#include <math/vec2.hpp>
+#include <math/vec4.hpp>
 #include <renderer/programs/renderer_program.hpp>
 
 namespace lt {
@@ -19,9 +20,9 @@ public:
 
 	struct TextureVertexData
 	{
-		glm::vec4 position;
+		math::vec4 position;
 
-		glm::vec2 texcoord;
+		math::vec2 texcoord;
 	};
 
 	TextureRendererProgram(
diff --git a/modules/renderer/include/renderer/programs/tinted_texture.hpp b/modules/renderer/include/renderer/programs/tinted_texture.hpp
index 9b7682d..3598e1c 100644
--- a/modules/renderer/include/renderer/programs/tinted_texture.hpp
+++ b/modules/renderer/include/renderer/programs/tinted_texture.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
-#include <glm/glm.hpp>
+#include <math/vec2.hpp>
+#include <math/vec4.hpp>
 #include <renderer/programs/renderer_program.hpp>
 #include <span>
 
@@ -19,11 +20,11 @@ public:
 	~TintedTextureRendererProgram() override = default;
 	struct TintedTextureVertexData
 	{
-		glm::vec4 position;
+		math::vec4 position;
 
-		glm::vec4 tint;
+		math::vec4 tint;
 
-		glm::vec2 texcoord;
+		math::vec2 texcoord;
 	};
 
 	TintedTextureRendererProgram(
diff --git a/modules/renderer/include/renderer/render_command.hpp b/modules/renderer/include/renderer/render_command.hpp
index 6cefcb1..8908e3d 100644
--- a/modules/renderer/include/renderer/render_command.hpp
+++ b/modules/renderer/include/renderer/render_command.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
-
-#include <glm/glm.hpp>
+#include <math/vec4.hpp>
 
 struct GLFWwindow;
 
@@ -23,7 +22,7 @@ public:
 
 	virtual void swap_buffers() = 0;
 
-	virtual void clear_back_buffer(const glm::vec4 &clearColor) = 0;
+	virtual void clear_back_buffer(const math::vec4 &clearColor) = 0;
 
 	virtual void draw(unsigned int count) = 0;
 
diff --git a/modules/renderer/include/renderer/renderer.hpp b/modules/renderer/include/renderer/renderer.hpp
index ad694b9..5034afc 100644
--- a/modules/renderer/include/renderer/renderer.hpp
+++ b/modules/renderer/include/renderer/renderer.hpp
@@ -1,6 +1,9 @@
 #pragma once
 
 //
+#include <math/mat4.hpp>
+#include <math/vec3.hpp>
+#include <math/vec4.hpp>
 #include <renderer/blender.hpp>
 #include <renderer/buffers.hpp>
 #include <renderer/render_command.hpp>
@@ -48,47 +51,51 @@ public:
 	) -> Scope<Renderer>;
 
 	static void draw_quad(
-	    const glm::vec3 &position,
-	    const glm::vec2 &size,
-	    const glm::vec4 &tint,
+	    const math::vec3 &position,
+	    const math::vec2 &size,
+	    const math::vec4 &tint,
 	    Ref<Texture> texture
 	)
 	{
 		s_context->draw_quad_impl(position, size, tint, std::move(texture));
 	}
 
-	static void draw_quad(const glm::vec3 &position, const glm::vec2 &size, const glm::vec4 &tint)
+	static void draw_quad(
+	    const math::vec3 &position,
+	    const math::vec2 &size,
+	    const math::vec4 &tint
+	)
 	{
 		s_context->draw_quad_impl(position, size, tint);
 	}
 
-	static void draw_quad(const glm::vec3 &position, const glm::vec2 &size, Ref<Texture> texture)
+	static void draw_quad(const math::vec3 &position, const math::vec2 &size, Ref<Texture> texture)
 	{
 		s_context->draw_quad_impl(position, size, std::move(texture));
 	}
 
 	static void draw_quad(
-	    const glm::mat4 &transform,
-	    const glm::vec4 &tint,
+	    const math::mat4 &transform,
+	    const math::vec4 &tint,
 	    const Ref<Texture> &texture
 	)
 	{
 		s_context->draw_quad_impl(transform, tint, texture);
 	}
 
-	static void draw_quad(const glm::mat4 &transform, const glm::vec4 &tint)
+	static void draw_quad(const math::mat4 &transform, const math::vec4 &tint)
 	{
 		s_context->draw_quad_impl(transform, tint);
 	}
 
-	static void draw_quad(const glm::mat4 &transform, const Ref<Texture> &texture)
+	static void draw_quad(const math::mat4 &transform, const Ref<Texture> &texture)
 	{
 		s_context->draw_quad_impl(transform, texture);
 	}
 
 	static void begin_scene(
 	    Camera *camera,
-	    const glm::mat4 &cameraTransform,
+	    const math::mat4 &cameraTransform,
 	    const Ref<Framebuffer> &targetFrameBuffer = nullptr
 	)
 	{
@@ -134,29 +141,29 @@ private:
 	);
 
 	void draw_quad_impl(
-	    const glm::vec3 &position,
-	    const glm::vec2 &size,
-	    const glm::vec4 &tint,
+	    const math::vec3 &position,
+	    const math::vec2 &size,
+	    const math::vec4 &tint,
 	    Ref<Texture> texture
 	);
 
-	void draw_quad_impl(const glm::vec3 &position, const glm::vec2 &size, const glm::vec4 &tint);
+	void draw_quad_impl(const math::vec3 &position, const math::vec2 &size, const math::vec4 &tint);
 
-	void draw_quad_impl(const glm::vec3 &position, const glm::vec2 &size, Ref<Texture> texture);
+	void draw_quad_impl(const math::vec3 &position, const math::vec2 &size, Ref<Texture> texture);
 
 	void draw_quad_impl(
-	    const glm::mat4 &transform,
-	    const glm::vec4 &tint,
+	    const math::mat4 &transform,
+	    const math::vec4 &tint,
 	    const Ref<Texture> &texture
 	);
 
-	void draw_quad_impl(const glm::mat4 &transform, const glm::vec4 &tint);
+	void draw_quad_impl(const math::mat4 &transform, const math::vec4 &tint);
 
-	void draw_quad_impl(const glm::mat4 &transform, const Ref<Texture> &texture);
+	void draw_quad_impl(const math::mat4 &transform, const Ref<Texture> &texture);
 
 	void begin_scene_impl(
 	    Camera *camera,
-	    const glm::mat4 &cameraTransform,
+	    const math::mat4 &cameraTransform,
 	    const Ref<Framebuffer> &targetFrameBuffer = nullptr
 	);
 
diff --git a/modules/renderer/include/renderer/shader.hpp b/modules/renderer/include/renderer/shader.hpp
index 17d0e0a..7a1aa91 100644
--- a/modules/renderer/include/renderer/shader.hpp
+++ b/modules/renderer/include/renderer/shader.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <glm/glm.hpp>
-
 namespace Assets {
 
 class TextAsset;
diff --git a/modules/renderer/src/gl/framebuffers.cpp b/modules/renderer/src/gl/framebuffers.cpp
index 39ff6ea..68b0574 100644
--- a/modules/renderer/src/gl/framebuffers.cpp
+++ b/modules/renderer/src/gl/framebuffers.cpp
@@ -1,5 +1,4 @@
 #include <glad/gl.h>
-#include <glm/glm.hpp>
 #include <renderer/gl/framebuffers.hpp>
 
 namespace lt {
@@ -20,7 +19,7 @@ glFramebuffer::~glFramebuffer()
 	// glDeleteTextures(1, &m_depth_stencil_attachment_id);
 }
 
-void glFramebuffer::bind_as_target(const glm::vec4 &clearColor)
+void glFramebuffer::bind_as_target(const math::vec4 &clearColor)
 {
 	// #todo: use viewport instead of default x=0, y=0
 	glBindFramebuffer(GL_FRAMEBUFFER, m_buffer_id);
@@ -35,7 +34,7 @@ void glFramebuffer::bind_as_resource()
 	log_err("NO_IMPLEMENT!");
 }
 
-void glFramebuffer::resize(const glm::uvec2 &size)
+void glFramebuffer::resize(const math::uvec2 &size)
 {
 	if (m_buffer_id)
 	{
diff --git a/modules/renderer/src/gl/render_command.cpp b/modules/renderer/src/gl/render_command.cpp
index 6f762e4..6722902 100644
--- a/modules/renderer/src/gl/render_command.cpp
+++ b/modules/renderer/src/gl/render_command.cpp
@@ -15,7 +15,7 @@ void glRenderCommand::swap_buffers()
 	glfwSwapBuffers(m_window_handle);
 }
 
-void glRenderCommand::clear_back_buffer(const glm::vec4 &clearColor)
+void glRenderCommand::clear_back_buffer(const math::vec4 &clearColor)
 {
 	glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a);
 	glClear(GL_COLOR_BUFFER_BIT);
diff --git a/modules/renderer/src/gl/shader.cpp b/modules/renderer/src/gl/shader.cpp
index b2f12c8..2968892 100644
--- a/modules/renderer/src/gl/shader.cpp
+++ b/modules/renderer/src/gl/shader.cpp
@@ -1,8 +1,5 @@
 #include <asset_parser/assets/text.hpp>
 #include <glad/gl.h>
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/matrix.hpp>
 #include <renderer/gl/shader.hpp>
 
 namespace lt {
diff --git a/modules/renderer/src/renderer.cpp b/modules/renderer/src/renderer.cpp
index 4397e4c..77d9c6b 100644
--- a/modules/renderer/src/renderer.cpp
+++ b/modules/renderer/src/renderer.cpp
@@ -1,8 +1,5 @@
 #include <camera/scene.hpp>
 #include <debug/assertions.hpp>
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/matrix.hpp>
 #include <input/events/window.hpp>
 #include <renderer/blender.hpp>
 #include <renderer/buffers.hpp>
@@ -49,7 +46,7 @@ Renderer::Renderer(
 
 	m_view_projection_buffer = ConstantBuffer::create(
 	    ConstantBufferIndex::ViewProjection,
-	    sizeof(glm::mat4),
+	    sizeof(math::mat4),
 	    shared_context
 	);
 
@@ -77,69 +74,63 @@ void Renderer::on_window_resize(const WindowResizedEvent &event)
 //======================================== DRAW_QUAD ========================================//
 /* tinted textures */
 void Renderer::draw_quad_impl(
-    const glm::vec3 &position,
-    const glm::vec2 &size,
-    const glm::vec4 &tint,
+    const math::vec3 &position,
+    const math::vec2 &size,
+    const math::vec4 &tint,
     Ref<Texture> texture
 )
 {
 	draw_quad(
-	    glm::translate(glm::mat4(1.0f), position)
-	        * glm::scale(glm::mat4(1.0f), { size.x, size.y, 1.0f }),
+	    math::translate(position) * math::scale(math::vec3 { size.x, size.y, 1.0f }),
 	    tint,
-	    std::move(texture)
+	    texture
 	);
 }
 
 /* tint */
 void Renderer::draw_quad_impl(
-    const glm::vec3 &position,
-    const glm::vec2 &size,
-    const glm::vec4 &tint
+    const math::vec3 &position,
+    const math::vec2 &size,
+    const math::vec4 &tint
 )
 {
-	draw_quad(
-	    glm::translate(glm::mat4(1.0f), position)
-	        * glm::scale(glm::mat4(1.0f), { size.x, size.y, 1.0f }),
-	    tint
-	);
+	draw_quad(math::translate(position) * math::scale(math::vec3 { size.x, size.y, 1.0f }), tint);
 }
 
 /* texture */
 void Renderer::draw_quad_impl(
-    const glm::vec3 &position,
-    const glm::vec2 &size,
+    const math::vec3 &position,
+    const math::vec2 &size,
     Ref<Texture> texture
 )
 {
 	draw_quad(
-	    glm::translate(glm::mat4(1.0f), position)
-	        * glm::scale(glm::mat4(1.0f), { size.x, size.y, 1.0f }),
-	    std::move(texture)
+	    math::translate(position) * math::scale(math::vec3 { size.x, size.y, 1.0f }),
+	    texture
 	);
 }
 //======================================== DRAW_QUAD ========================================//
 
 //==================== DRAW_QUAD_TINT ====================//
-void Renderer::draw_quad_impl(const glm::mat4 &transform, const glm::vec4 &tint)
+void Renderer::draw_quad_impl(const math::mat4 &transform, const math::vec4 &tint)
 {
 	auto map = std::span<QuadRendererProgram::QuadVertexData> { m_quad_renderer.get_map_current(),
 		                                                        4 };
 
 	// top left
-	map[0].position = transform * glm::vec4(-0.5f, -0.5f, 0.0f, 1.0f);
+	map[0].position = transform * math::vec4(-0.5f, -0.5f, 0.0f, 1.0f);
 	map[0].tint = tint;
 
 	// top right
-	map[1].position = transform * glm::vec4(0.5f, -0.5f, 0.0f, 1.0f);
+	map[1].position = transform * math::vec4(0.5f, -0.5f, 0.0f, 1.0f);
 	map[1].tint = tint;
 
 	// bottom right
-	map[2].position = transform * glm::vec4(0.5f, 0.5f, 0.0f, 1.0f);
+	map[2].position = transform * math::vec4(0.5f, 0.5f, 0.0f, 1.0f);
 	map[2].tint = tint;
 
 	// bottom left
-	map[3].position = transform * glm::vec4(-0.5f, 0.5f, 0.0f, 1.0f);
+	map[3].position = transform * math::vec4(-0.5f, 0.5f, 0.0f, 1.0f);
 	map[3].tint = tint;
 
 	// advance
@@ -150,7 +141,7 @@ void Renderer::draw_quad_impl(const glm::mat4 &transform, const glm::vec4 &tint)
 	}
 }
 
-void Renderer::draw_quad_impl(const glm::mat4 &transform, const Ref<Texture> &texture)
+void Renderer::draw_quad_impl(const math::mat4 &transform, const Ref<Texture> &texture)
 {
 	ensure(texture, "Texture passed to renderer::draw_quad_impl");
 
@@ -161,19 +152,19 @@ void Renderer::draw_quad_impl(const glm::mat4 &transform, const Ref<Texture> &te
 	};
 
 	// top left
-	map[0].position = transform * glm::vec4(-0.5f, -0.5f, 0.0f, 1.0f);
+	map[0].position = transform * math::vec4(-0.5f, -0.5f, 0.0f, 1.0f);
 	map[0].texcoord = { 0.0f, 0.0f };
 
 	// top right
-	map[1].position = transform * glm::vec4(0.5f, -0.5f, 0.0f, 1.0f);
+	map[1].position = transform * math::vec4(0.5f, -0.5f, 0.0f, 1.0f);
 	map[1].texcoord = { 1.0f, 0.0f };
 
 	// bottom right
-	map[2].position = transform * glm::vec4(0.5f, 0.5f, 0.0f, 1.0f);
+	map[2].position = transform * math::vec4(0.5f, 0.5f, 0.0f, 1.0f);
 	map[2].texcoord = { 1.0f, 1.0f };
 
 	// bottom left
-	map[3].position = transform * glm::vec4(-0.5f, 0.5f, 0.0f, 1.0f);
+	map[3].position = transform * math::vec4(-0.5f, 0.5f, 0.0f, 1.0f);
 	map[3].texcoord = { 0.0f, 1.0f };
 
 	// advance
@@ -185,8 +176,8 @@ void Renderer::draw_quad_impl(const glm::mat4 &transform, const Ref<Texture> &te
 }
 
 void Renderer::draw_quad_impl(
-    const glm::mat4 &transform,
-    const glm::vec4 &tint,
+    const math::mat4 &transform,
+    const math::vec4 &tint,
     const Ref<Texture> &texture
 )
 {
@@ -199,22 +190,22 @@ void Renderer::draw_quad_impl(
 	};
 
 	// top left
-	map[0].position = transform * glm::vec4(-0.5f, -0.5f, 0.0f, 1.0f);
+	map[0].position = transform * math::vec4(-0.5f, -0.5f, 0.0f, 1.0f);
 	map[0].tint = tint;
 	map[0].texcoord = { 0.0f, 0.0f };
 
 	// top right
-	map[1].position = transform * glm::vec4(0.5f, -0.5f, 0.0f, 1.0f);
+	map[1].position = transform * math::vec4(0.5f, -0.5f, 0.0f, 1.0f);
 	map[1].tint = tint;
 	map[1].texcoord = { 1.0f, 0.0f };
 
 	// bottom right
-	map[2].position = transform * glm::vec4(0.5f, 0.5f, 0.0f, 1.0f);
+	map[2].position = transform * math::vec4(0.5f, 0.5f, 0.0f, 1.0f);
 	map[2].tint = tint;
 	map[2].texcoord = { 1.0f, 1.0f };
 
 	// bottom left
-	map[3].position = transform * glm::vec4(-0.5f, 0.5f, 0.0f, 1.0f);
+	map[3].position = transform * math::vec4(-0.5f, 0.5f, 0.0f, 1.0f);
 	map[3].tint = tint;
 	map[3].texcoord = { 0.0f, 1.0f };
 
@@ -234,7 +225,7 @@ void Renderer::end_frame()
 	m_render_command->swap_buffers();
 	m_render_command->clear_back_buffer(
 	    m_default_framebuffer_camera ? m_default_framebuffer_camera->get_background_color() :
-	                                   glm::vec4(0.0f)
+	                                   math::vec4(0.0f)
 	);
 
 	m_default_framebuffer_camera = nullptr;
@@ -242,7 +233,7 @@ void Renderer::end_frame()
 
 void Renderer::begin_scene_impl(
     Camera *camera,
-    const glm::mat4 &cameraTransform,
+    const math::mat4 &cameraTransform,
     const Ref<Framebuffer> &targetFrameBuffer /* = nullptr */
 )
 {
@@ -260,8 +251,8 @@ void Renderer::begin_scene_impl(
 	}
 
 	// update view projection buffer
-	auto *map = (glm::mat4 *)m_view_projection_buffer->map();
-	map[0] = camera->get_projection() * glm::inverse(cameraTransform);
+	auto *map = (math::mat4 *)m_view_projection_buffer->map();
+	map[0] = camera->get_projection() * math::inverse(cameraTransform);
 	m_view_projection_buffer->un_map();
 
 	// map renderers
diff --git a/modules/window/include/window/linux/window.hpp b/modules/window/include/window/linux/window.hpp
index d57420e..27f1c54 100644
--- a/modules/window/include/window/linux/window.hpp
+++ b/modules/window/include/window/linux/window.hpp
@@ -32,7 +32,7 @@ public:
 
 	void set_title(const std::string &title) override;
 
-	void set_size(const glm::uvec2 &size) override;
+	void set_size(const math::uvec2 &size) override;
 
 	void set_v_sync(bool vsync, bool toggle = false) override;
 
diff --git a/modules/window/include/window/window.hpp b/modules/window/include/window/window.hpp
index 168ce1e..0790fdb 100644
--- a/modules/window/include/window/window.hpp
+++ b/modules/window/include/window/window.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <glm/glm.hpp>
+#include <math/vec2.hpp>
 
 namespace lt {
 
@@ -14,7 +14,7 @@ public:
 	{
 		std::string title;
 
-		glm::uvec2 size;
+		math::uvec2 size;
 
 		bool vsync, visible;
 	};
@@ -41,7 +41,7 @@ public:
 
 	virtual void set_title(const std::string &title) = 0;
 
-	virtual void set_size(const glm::uvec2 &size) = 0;
+	virtual void set_size(const math::uvec2 &size) = 0;
 
 	void close()
 	{
@@ -62,7 +62,7 @@ public:
 		return m_properties.title;
 	}
 
-	[[nodiscard]] auto get_size() const -> const glm::uvec2 &
+	[[nodiscard]] auto get_size() const -> const math::uvec2 &
 	{
 		return m_properties.size;
 	}
diff --git a/modules/window/src/linux/window.cpp b/modules/window/src/linux/window.cpp
index 4261b9c..555910e 100644
--- a/modules/window/src/linux/window.cpp
+++ b/modules/window/src/linux/window.cpp
@@ -85,7 +85,7 @@ void lWindow::set_title(const std::string &title)
 	glfwSetWindowTitle(m_handle, title.c_str());
 }
 
-void lWindow::set_size(const glm::uvec2 &size)
+void lWindow::set_size(const math::uvec2 &size)
 {
 	m_properties.size = size;
 	glfwSetWindowSize(m_handle, static_cast<int>(size.x), static_cast<int>(size.y));