From ba267cbcb8fa896d8fb074549c3980cd601ed4d2 Mon Sep 17 00:00:00 2001
From: Orange <orange-cpp@yandex.ru>
Date: Sat, 29 Nov 2025 16:28:06 +0300
Subject: [PATCH 1/6] improved mesh class

---
 .idea/editor.xml                             |  4 +-
 include/omath/3d_primitives/mesh.hpp         | 40 +++++++++++++++-----
 include/omath/collision/epa_algorithm.hpp    | 32 ++++++++--------
 include/omath/collision/gjk_algorithm.hpp    | 16 ++++----
 include/omath/collision/mesh_collider.hpp    | 22 +++++++----
 include/omath/engines/source_engine/mesh.hpp |  2 +-
 source/utility/pe_pattern_scan.cpp           |  2 +-
 tests/general/unit_test_colider.cpp          | 20 ++++++++--
 tests/general/unit_test_epa.cpp              | 24 ++++++++++--
 tests/general/unit_test_gjk.cpp              | 21 +++++-----
 10 files changed, 120 insertions(+), 63 deletions(-)

diff --git a/.idea/editor.xml b/.idea/editor.xml
index 373c50f..fde5348 100644
--- a/.idea/editor.xml
+++ b/.idea/editor.xml
@@ -201,7 +201,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticDataMemberInUnnamedStruct/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticSpecifierOnAnonymousNamespaceMember/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStringLiteralToCharPointerConversion/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateArgumentsCanBeDeduced/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterNeverUsed/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterShadowing/@EntryIndexedValue" value="WARNING" type="string" />
@@ -215,7 +215,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaEndRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnamedNamespaceInHeaderFile/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnsignedZeroComparison/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnusedIncludeDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUseAlgorithmWithCount/@EntryIndexedValue" value="SUGGESTION" type="string" />
diff --git a/include/omath/3d_primitives/mesh.hpp b/include/omath/3d_primitives/mesh.hpp
index 3779776..311b10f 100644
--- a/include/omath/3d_primitives/mesh.hpp
+++ b/include/omath/3d_primitives/mesh.hpp
@@ -6,25 +6,44 @@
 #include <omath/linear_algebra/mat.hpp>
 #include <omath/linear_algebra/vector3.hpp>
 #include <utility>
+#include <variant>
 #include <vector>
 
 namespace omath::primitives
 {
-    template<class Mat4X4, class RotationAngles, class MeshTypeTrait, class Type = float>
+    struct Vertex
+    {
+        using VectorType = Vector3<float>;
+        Vector3<float> position;
+        Vector3<float> normal;
+        Vector3<float> uv;
+    };
+
+    template<typename T> concept HasPosition = requires(T vertex) { vertex.position; };
+    template<typename T> concept HasNormal = requires(T vertex) { vertex.normal; };
+    template<typename T> concept HasUv = requires(T vertex) { vertex.uv; };
+
+    template<class Mat4X4, class RotationAngles, class MeshTypeTrait, class VertType = Vertex>
     class Mesh final
     {
     public:
-        using NumericType = Type;
-
+        using NumericType = float;
+        using VertexType = Vertex;
     private:
-        using Vbo = std::vector<Vector3<NumericType>>;
+        using Vbo = std::vector<VertexType>;
         using Vao = std::vector<Vector3<std::size_t>>;
 
     public:
         Vbo m_vertex_buffer;
         Vao m_vertex_array_object;
 
-        Mesh(Vbo vbo, Vao vao, const Vector3<NumericType> scale = {1, 1, 1,})
+        Mesh(Vbo vbo, Vao vao,
+             const Vector3<NumericType> scale =
+                     {
+                             1,
+                             1,
+                             1,
+                     })
             : m_vertex_buffer(std::move(vbo)), m_vertex_array_object(std::move(vao)), m_scale(std::move(scale))
         {
         }
@@ -76,19 +95,20 @@ namespace omath::primitives
         }
 
         [[nodiscard]]
-        Vector3<float> vertex_to_world_space(const Vector3<float>& vertex) const
+        Vector3<float> vertex_to_world_space(const Vector3<float>& vertex_position) const
         {
-            auto abs_vec = get_to_world_matrix() * mat_column_from_vector(vertex);
+            auto abs_vec = get_to_world_matrix() * mat_column_from_vector(vertex_position);
 
             return {abs_vec.at(0, 0), abs_vec.at(1, 0), abs_vec.at(2, 0)};
         }
 
         [[nodiscard]]
         Triangle<Vector3<float>> make_face_in_world_space(const Vao::const_iterator vao_iterator) const
+        requires HasPosition<VertexType>
         {
-            return {vertex_to_world_space(m_vertex_buffer.at(vao_iterator->x)),
-                    vertex_to_world_space(m_vertex_buffer.at(vao_iterator->y)),
-                    vertex_to_world_space(m_vertex_buffer.at(vao_iterator->z))};
+            return {vertex_to_world_space(m_vertex_buffer.at(vao_iterator->x).position),
+                    vertex_to_world_space(m_vertex_buffer.at(vao_iterator->y).position),
+                    vertex_to_world_space(m_vertex_buffer.at(vao_iterator->z).position)};
         }
 
     private:
diff --git a/include/omath/collision/epa_algorithm.hpp b/include/omath/collision/epa_algorithm.hpp
index f8bc3db..c7eac7e 100644
--- a/include/omath/collision/epa_algorithm.hpp
+++ b/include/omath/collision/epa_algorithm.hpp
@@ -24,13 +24,13 @@ namespace omath::collision
     class Epa final
     {
     public:
-        using Vertex = typename ColliderType::VertexType;
-        static_assert(EpaVector<Vertex>, "VertexType must satisfy EpaVector concept");
+        using VectorType = typename ColliderType::VectorType;
+        static_assert(EpaVector<VectorType>, "VertexType must satisfy EpaVector concept");
 
         struct Result final
         {
-            Vertex normal{}; // outward normal (from B to A)
-            Vertex penetration_vector;
+            VectorType normal{}; // outward normal (from B to A)
+            VectorType penetration_vector;
             float depth{0.0f};
             int iterations{0};
             int num_vertices{0};
@@ -45,11 +45,11 @@ namespace omath::collision
 
         // Precondition: simplex.size()==4 and contains the origin.
         [[nodiscard]]
-        static std::optional<Result> solve(const ColliderType& a, const ColliderType& b, const Simplex<Vertex>& simplex,
+        static std::optional<Result> solve(const ColliderType& a, const ColliderType& b, const Simplex<VectorType>& simplex,
                                            const Params params = {})
         {
             // --- Build initial polytope from simplex (4 points) ---
-            std::vector<Vertex> vertexes;
+            std::vector<VectorType> vertexes;
             vertexes.reserve(64);
             for (std::size_t i = 0; i < simplex.size(); ++i)
                 vertexes.push_back(simplex[i]);
@@ -84,7 +84,7 @@ namespace omath::collision
                 const Face f = faces[fidx];
 
                 // Get farthest point in face normal direction
-                const Vertex p = support_point(a, b, f.n);
+                const VectorType p = support_point(a, b, f.n);
                 const float p_dist = f.n.dot(p);
 
                 // Converged if we can’t push the face closer than tolerance
@@ -172,7 +172,7 @@ namespace omath::collision
         struct Face final
         {
             int i0, i1, i2;
-            Vertex n; // unit outward normal
+            VectorType n; // unit outward normal
             float d; // n · v0  (>=0 ideally because origin is inside)
         };
 
@@ -205,7 +205,7 @@ namespace omath::collision
         }
 
         [[nodiscard]]
-        static bool visible_from(const Face& f, const Vertex& p)
+        static bool visible_from(const Face& f, const VectorType& p)
         {
             // positive if p is in front of the face
             return (f.n.dot(p) - f.d) > 1e-7f;
@@ -223,12 +223,12 @@ namespace omath::collision
         }
 
         [[nodiscard]]
-        static Face make_face(const std::vector<Vertex>& vertexes, int i0, int i1, int i2)
+        static Face make_face(const std::vector<VectorType>& vertexes, int i0, int i1, int i2)
         {
-            const Vertex& a0 = vertexes[i0];
-            const Vertex& a1 = vertexes[i1];
-            const Vertex& a2 = vertexes[i2];
-            Vertex n = (a1 - a0).cross(a2 - a0);
+            const VectorType& a0 = vertexes[i0];
+            const VectorType& a1 = vertexes[i1];
+            const VectorType& a2 = vertexes[i2];
+            VectorType n = (a1 - a0).cross(a2 - a0);
             if (n.dot(n) <= 1e-30f)
             {
                 n = any_perp_vec(a1 - a0); // degenerate guard
@@ -246,9 +246,9 @@ namespace omath::collision
         }
 
         [[nodiscard]]
-        static Vertex support_point(const ColliderType& a, const ColliderType& b, const Vertex& dir)
+        static VectorType support_point(const ColliderType& a, const ColliderType& b, const VectorType& dir)
         {
-            return a.find_abs_furthest_vertex(dir) - b.find_abs_furthest_vertex(-dir);
+            return a.find_abs_furthest_vertex(dir).position - b.find_abs_furthest_vertex(-dir).position;
         }
 
         template<class V>
diff --git a/include/omath/collision/gjk_algorithm.hpp b/include/omath/collision/gjk_algorithm.hpp
index 81a648c..c3db4ea 100644
--- a/include/omath/collision/gjk_algorithm.hpp
+++ b/include/omath/collision/gjk_algorithm.hpp
@@ -17,14 +17,14 @@ namespace omath::collision
     template<class ColliderType>
     class GjkAlgorithm final
     {
-        using VertexType = typename ColliderType::VertexType;
-
+        using VertexType = ColliderType::VertexType;
+        using VectorType = VertexType::VectorType;
     public:
         [[nodiscard]]
-        static VertexType find_support_vertex(const ColliderType& collider_a, const ColliderType& collider_b,
-                                              const VertexType& direction)
+        static VectorType find_support_vertex(const ColliderType& collider_a, const ColliderType& collider_b,
+                                              const VectorType& direction)
         {
-            return collider_a.find_abs_furthest_vertex(direction) - collider_b.find_abs_furthest_vertex(-direction);
+            return collider_a.find_abs_furthest_vertex(direction).position - collider_b.find_abs_furthest_vertex(-direction).position;
         }
 
         [[nodiscard]]
@@ -34,12 +34,12 @@ namespace omath::collision
         }
 
         [[nodiscard]]
-        static GjkHitInfo<VertexType> is_collide_with_simplex_info(const ColliderType& collider_a,
+        static GjkHitInfo<VectorType> is_collide_with_simplex_info(const ColliderType& collider_a,
                                                                    const ColliderType& collider_b)
         {
-            auto support = find_support_vertex(collider_a, collider_b, {1, 0, 0});
+            auto support = find_support_vertex(collider_a, collider_b, VectorType{1, 0, 0});
 
-            Simplex<VertexType> simplex;
+            Simplex<VectorType> simplex;
             simplex.push_front(support);
 
             auto direction = -support;
diff --git a/include/omath/collision/mesh_collider.hpp b/include/omath/collision/mesh_collider.hpp
index 247b652..8603e44 100644
--- a/include/omath/collision/mesh_collider.hpp
+++ b/include/omath/collision/mesh_collider.hpp
@@ -11,31 +11,37 @@ namespace omath::collision
     class MeshCollider
     {
     public:
-        using NumericType = typename MeshType::NumericType;
+        using NumericType = MeshType::NumericType;
 
-        using VertexType = Vector3<NumericType>;
+        using VertexType = MeshType::VertexType;
+        using VectorType = VertexType::VectorType;
         explicit MeshCollider(MeshType mesh): m_mesh(std::move(mesh))
         {
         }
 
         [[nodiscard]]
-        const VertexType& find_furthest_vertex(const VertexType& direction) const
+        const VertexType& find_furthest_vertex(const VectorType& direction) const
         {
-            return *std::ranges::max_element(m_mesh.m_vertex_buffer, [&direction](const auto& first, const auto& second)
-                                             { return first.dot(direction) < second.dot(direction); });
+            return *std::ranges::max_element(
+                    m_mesh.m_vertex_buffer, [&direction](const auto& first, const auto& second)
+                    { return first.position.dot(direction) < second.position.dot(direction); });
         }
 
         [[nodiscard]]
-        VertexType find_abs_furthest_vertex(const VertexType& direction) const
+        VertexType find_abs_furthest_vertex(const VectorType& direction) const
         {
-            return m_mesh.vertex_to_world_space(find_furthest_vertex(direction));
+            const auto& vertex = find_furthest_vertex(direction);
+            auto new_vertex = vertex;
+            new_vertex.position = m_mesh.vertex_to_world_space(find_furthest_vertex(direction).position);
+            return new_vertex;
         }
 
         [[nodiscard]]
-        const VertexType& get_origin() const
+        const VectorType& get_origin() const
         {
             return m_mesh.get_origin();
         }
+
     private:
         MeshType m_mesh;
     };
diff --git a/include/omath/engines/source_engine/mesh.hpp b/include/omath/engines/source_engine/mesh.hpp
index 31956b3..a8b2ef3 100644
--- a/include/omath/engines/source_engine/mesh.hpp
+++ b/include/omath/engines/source_engine/mesh.hpp
@@ -8,5 +8,5 @@
 
 namespace omath::source_engine
 {
-    using Mesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait, float>;
+    using Mesh = primitives::Mesh<Mat4X4, ViewAngles, MeshTrait>;
 }
\ No newline at end of file
diff --git a/source/utility/pe_pattern_scan.cpp b/source/utility/pe_pattern_scan.cpp
index 931f241..23edc90 100644
--- a/source/utility/pe_pattern_scan.cpp
+++ b/source/utility/pe_pattern_scan.cpp
@@ -320,7 +320,7 @@ namespace omath
         return std::visit(
                 [base_address, &pattern](const auto& nt_header) -> std::optional<std::uintptr_t>
                 {
-                    // Define .code segment as scan area
+                    // Define .text segment as scan area
                     const auto start = nt_header.optional_header.base_of_code;
                     const auto scan_size = nt_header.optional_header.size_code;
 
diff --git a/tests/general/unit_test_colider.cpp b/tests/general/unit_test_colider.cpp
index 57d8b08..e5d08e6 100644
--- a/tests/general/unit_test_colider.cpp
+++ b/tests/general/unit_test_colider.cpp
@@ -7,20 +7,32 @@
 
 TEST(UnitTestColider, CheckToWorld)
 {
-    omath::source_engine::Mesh mesh = {std::vector<omath::Vector3<float>>{{1.f, 1.f, 1.f}, {-1.f, -1.f, -1.f}}, {}};
+    omath::source_engine::Mesh mesh = {
+        std::vector<omath::primitives::Vertex>{
+            { { 1.f,  1.f,  1.f }, {}, {} },
+            { {-1.f, -1.f, -1.f }, {}, {} }
+        },
+        {}
+    };
     mesh.set_origin({0, 2, 0});
     const omath::source_engine::MeshCollider collider(mesh);
 
-    const auto vertex = collider.find_abs_furthest_vertex({1.f, 0.f, 0.f});
+    const auto vertex = collider.find_abs_furthest_vertex({1.f, 0.f, 0.f}).position;
 
     EXPECT_EQ(vertex, omath::Vector3<float>(1.f, 3.f, 1.f));
 }
 
 TEST(UnitTestColider, FindFurthestVertex)
 {
-    const omath::source_engine::Mesh mesh = {{{1.f, 1.f, 1.f}, {-1.f, -1.f, -1.f}}, {}};
+    const omath::source_engine::Mesh mesh = {
+        {
+            { { 1.f,  1.f,  1.f }, {}, {} },   // position, normal, uv
+            { {-1.f, -1.f, -1.f }, {}, {} }
+        },
+        {}
+    };
     const omath::source_engine::MeshCollider collider(mesh);
-    const auto vertex = collider.find_furthest_vertex({1.f, 0.f, 0.f});
+    const auto vertex = collider.find_furthest_vertex({1.f, 0.f, 0.f}).position;
     EXPECT_EQ(vertex, omath::Vector3<float>(1.f, 1.f, 1.f));
 }
 
diff --git a/tests/general/unit_test_epa.cpp b/tests/general/unit_test_epa.cpp
index 30f02ae..5131405 100644
--- a/tests/general/unit_test_epa.cpp
+++ b/tests/general/unit_test_epa.cpp
@@ -14,8 +14,16 @@ using EPA = omath::collision::Epa<Collider>;
 TEST(UnitTestEpa, TestCollisionTrue)
 {
     // Unit cube [-1,1]^3
-    std::vector<omath::Vector3<float>> vbo = {{-1, -1, -1}, {-1, -1, 1}, {-1, 1, -1}, {-1, 1, 1},
-                                              {1, 1, 1},    {1, 1, -1},  {1, -1, 1},  {1, -1, -1}};
+    std::vector<omath::primitives::Vertex> vbo = {
+        { {-1.f, -1.f, -1.f}, {}, {} },
+        { {-1.f, -1.f,  1.f}, {}, {} },
+        { {-1.f,  1.f, -1.f}, {}, {} },
+        { {-1.f,  1.f,  1.f}, {}, {} },
+        { { 1.f,  1.f,  1.f}, {}, {} },
+        { { 1.f,  1.f, -1.f}, {}, {} },
+        { { 1.f, -1.f,  1.f}, {}, {} },
+        { { 1.f, -1.f, -1.f}, {}, {} }
+    };
     std::vector<omath::Vector3<std::size_t>> vao; // not needed
 
     Mesh a(vbo, vao, {1, 1, 1});
@@ -80,8 +88,16 @@ TEST(UnitTestEpa, TestCollisionTrue)
 }
 TEST(UnitTestEpa, TestCollisionTrue2)
 {
-    std::vector<omath::Vector3<float>> vbo = {{-1, -1, -1}, {-1, -1, 1}, {-1, 1, -1}, {-1, 1, 1},
-                                              {1, 1, 1},    {1, 1, -1},  {1, -1, 1},  {1, -1, -1}};
+    std::vector<omath::primitives::Vertex> vbo = {
+        { { -1.f, -1.f, -1.f }, {}, {} },
+        { { -1.f, -1.f,  1.f }, {}, {} },
+        { { -1.f,  1.f, -1.f }, {}, {} },
+        { { -1.f,  1.f,  1.f }, {}, {} },
+        { {  1.f,  1.f,  1.f }, {}, {} },
+        { {  1.f,  1.f, -1.f }, {}, {} },
+        { {  1.f, -1.f,  1.f }, {}, {} },
+        { {  1.f, -1.f, -1.f }, {}, {} }
+    };
     std::vector<omath::Vector3<std::size_t>> vao; // not needed
 
     Mesh a(vbo, vao, {1, 1, 1});
diff --git a/tests/general/unit_test_gjk.cpp b/tests/general/unit_test_gjk.cpp
index ea29f78..722fae7 100644
--- a/tests/general/unit_test_gjk.cpp
+++ b/tests/general/unit_test_gjk.cpp
@@ -8,15 +8,18 @@
 namespace
 {
     const omath::source_engine::Mesh mesh = {
-            {{-1.f, -1.f, -1.f},
-             {-1.f, -1.f, 1.f},
-             {-1.f, 1.f, -1.f},
-             {-1.f, 1.f, 1.f},
-             {1.f, 1.f, 1.f},
-             {1.f, 1.f, -1.f},
-             {1.f, -1.f, 1.f},
-             {1.f, -1.f, -1.f}},
-            {}};
+        {
+            { {-1.f, -1.f, -1.f}, {}, {} },
+            { {-1.f, -1.f,  1.f}, {}, {} },
+            { {-1.f,  1.f, -1.f}, {}, {} },
+            { {-1.f,  1.f,  1.f}, {}, {} },
+            { { 1.f,  1.f,  1.f}, {}, {} },
+            { { 1.f,  1.f, -1.f}, {}, {} },
+            { { 1.f, -1.f,  1.f}, {}, {} },
+            { { 1.f, -1.f, -1.f}, {}, {} }
+        },
+        {}
+    };
 }
 TEST(UnitTestGjk, TestCollisionTrue)
 {

From 99ebdeb18850af30a42b66675bf1d582cb1aae90 Mon Sep 17 00:00:00 2001
From: Orange <orange-cpp@yandex.ru>
Date: Sat, 29 Nov 2025 16:31:24 +0300
Subject: [PATCH 2/6] added template arg to Vertex struct

---
 include/omath/3d_primitives/mesh.hpp | 15 ++++++++-------
 tests/general/unit_test_colider.cpp  |  2 +-
 tests/general/unit_test_epa.cpp      |  4 ++--
 3 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/include/omath/3d_primitives/mesh.hpp b/include/omath/3d_primitives/mesh.hpp
index 311b10f..2c82e6f 100644
--- a/include/omath/3d_primitives/mesh.hpp
+++ b/include/omath/3d_primitives/mesh.hpp
@@ -11,24 +11,25 @@
 
 namespace omath::primitives
 {
-    struct Vertex
+    template<class T = Vector3<float>>
+    struct Vertex final
     {
-        using VectorType = Vector3<float>;
-        Vector3<float> position;
-        Vector3<float> normal;
-        Vector3<float> uv;
+        using VectorType = T;
+        VectorType position;
+        VectorType normal;
+        VectorType uv;
     };
 
     template<typename T> concept HasPosition = requires(T vertex) { vertex.position; };
     template<typename T> concept HasNormal = requires(T vertex) { vertex.normal; };
     template<typename T> concept HasUv = requires(T vertex) { vertex.uv; };
 
-    template<class Mat4X4, class RotationAngles, class MeshTypeTrait, class VertType = Vertex>
+    template<class Mat4X4, class RotationAngles, class MeshTypeTrait, class VertType = Vertex<>>
     class Mesh final
     {
     public:
         using NumericType = float;
-        using VertexType = Vertex;
+        using VertexType = VertType;
     private:
         using Vbo = std::vector<VertexType>;
         using Vao = std::vector<Vector3<std::size_t>>;
diff --git a/tests/general/unit_test_colider.cpp b/tests/general/unit_test_colider.cpp
index e5d08e6..4800ea2 100644
--- a/tests/general/unit_test_colider.cpp
+++ b/tests/general/unit_test_colider.cpp
@@ -8,7 +8,7 @@
 TEST(UnitTestColider, CheckToWorld)
 {
     omath::source_engine::Mesh mesh = {
-        std::vector<omath::primitives::Vertex>{
+        std::vector<omath::primitives::Vertex<>>{
             { { 1.f,  1.f,  1.f }, {}, {} },
             { {-1.f, -1.f, -1.f }, {}, {} }
         },
diff --git a/tests/general/unit_test_epa.cpp b/tests/general/unit_test_epa.cpp
index 5131405..c0b8464 100644
--- a/tests/general/unit_test_epa.cpp
+++ b/tests/general/unit_test_epa.cpp
@@ -14,7 +14,7 @@ using EPA = omath::collision::Epa<Collider>;
 TEST(UnitTestEpa, TestCollisionTrue)
 {
     // Unit cube [-1,1]^3
-    std::vector<omath::primitives::Vertex> vbo = {
+    std::vector<omath::primitives::Vertex<>> vbo = {
         { {-1.f, -1.f, -1.f}, {}, {} },
         { {-1.f, -1.f,  1.f}, {}, {} },
         { {-1.f,  1.f, -1.f}, {}, {} },
@@ -88,7 +88,7 @@ TEST(UnitTestEpa, TestCollisionTrue)
 }
 TEST(UnitTestEpa, TestCollisionTrue2)
 {
-    std::vector<omath::primitives::Vertex> vbo = {
+    std::vector<omath::primitives::Vertex<>> vbo = {
         { { -1.f, -1.f, -1.f }, {}, {} },
         { { -1.f, -1.f,  1.f }, {}, {} },
         { { -1.f,  1.f, -1.f }, {}, {} },

From 8feddf872a885e5652ce156c38d0d2495bcea441 Mon Sep 17 00:00:00 2001
From: Orange <orange-cpp@yandex.ru>
Date: Sat, 29 Nov 2025 16:33:31 +0300
Subject: [PATCH 3/6] added conecpt to method

---
 include/omath/3d_primitives/mesh.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/omath/3d_primitives/mesh.hpp b/include/omath/3d_primitives/mesh.hpp
index 2c82e6f..aa2f4d3 100644
--- a/include/omath/3d_primitives/mesh.hpp
+++ b/include/omath/3d_primitives/mesh.hpp
@@ -30,6 +30,7 @@ namespace omath::primitives
     public:
         using NumericType = float;
         using VertexType = VertType;
+
     private:
         using Vbo = std::vector<VertexType>;
         using Vao = std::vector<Vector3<std::size_t>>;
@@ -97,6 +98,7 @@ namespace omath::primitives
 
         [[nodiscard]]
         Vector3<float> vertex_to_world_space(const Vector3<float>& vertex_position) const
+        requires HasPosition<VertexType>
         {
             auto abs_vec = get_to_world_matrix() * mat_column_from_vector(vertex_position);
 

From 48bf06f69c25dede68fbd722674a6baf95dda048 Mon Sep 17 00:00:00 2001
From: Orange <orange-cpp@yandex.ru>
Date: Sat, 29 Nov 2025 16:35:43 +0300
Subject: [PATCH 4/6] refactored using stuff

---
 include/omath/3d_primitives/mesh.hpp      | 16 ++++++++--------
 include/omath/collision/mesh_collider.hpp |  1 -
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/include/omath/3d_primitives/mesh.hpp b/include/omath/3d_primitives/mesh.hpp
index aa2f4d3..f5f47b7 100644
--- a/include/omath/3d_primitives/mesh.hpp
+++ b/include/omath/3d_primitives/mesh.hpp
@@ -28,7 +28,7 @@ namespace omath::primitives
     class Mesh final
     {
     public:
-        using NumericType = float;
+        using VectorType = VertType::VectorType;
         using VertexType = VertType;
 
     private:
@@ -40,7 +40,7 @@ namespace omath::primitives
         Vao m_vertex_array_object;
 
         Mesh(Vbo vbo, Vao vao,
-             const Vector3<NumericType> scale =
+             const VectorType scale =
                      {
                              1,
                              1,
@@ -49,13 +49,13 @@ namespace omath::primitives
             : m_vertex_buffer(std::move(vbo)), m_vertex_array_object(std::move(vao)), m_scale(std::move(scale))
         {
         }
-        void set_origin(const Vector3<NumericType>& new_origin)
+        void set_origin(const VectorType& new_origin)
         {
             m_origin = new_origin;
             m_to_world_matrix = std::nullopt;
         }
 
-        void set_scale(const Vector3<NumericType>& new_scale)
+        void set_scale(const VectorType& new_scale)
         {
             m_scale = new_scale;
             m_to_world_matrix = std::nullopt;
@@ -68,13 +68,13 @@ namespace omath::primitives
         }
 
         [[nodiscard]]
-        const Vector3<NumericType>& get_origin() const
+        const VectorType& get_origin() const
         {
             return m_origin;
         }
 
         [[nodiscard]]
-        const Vector3<NumericType>& get_scale() const
+        const VectorType& get_scale() const
         {
             return m_scale;
         }
@@ -115,8 +115,8 @@ namespace omath::primitives
         }
 
     private:
-        Vector3<NumericType> m_origin;
-        Vector3<NumericType> m_scale;
+        VectorType m_origin;
+        VectorType m_scale;
 
         RotationAngles m_rotation_angles;
 
diff --git a/include/omath/collision/mesh_collider.hpp b/include/omath/collision/mesh_collider.hpp
index 8603e44..cfe9c1c 100644
--- a/include/omath/collision/mesh_collider.hpp
+++ b/include/omath/collision/mesh_collider.hpp
@@ -11,7 +11,6 @@ namespace omath::collision
     class MeshCollider
     {
     public:
-        using NumericType = MeshType::NumericType;
 
         using VertexType = MeshType::VertexType;
         using VectorType = VertexType::VectorType;

From 9a89e2467eaf7c765414b0e098967f55558177cf Mon Sep 17 00:00:00 2001
From: Orange <orange-cpp@yandex.ru>
Date: Sat, 29 Nov 2025 16:37:30 +0300
Subject: [PATCH 5/6] fix

---
 include/omath/collision/mesh_collider.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/include/omath/collision/mesh_collider.hpp b/include/omath/collision/mesh_collider.hpp
index cfe9c1c..96b4d7a 100644
--- a/include/omath/collision/mesh_collider.hpp
+++ b/include/omath/collision/mesh_collider.hpp
@@ -11,7 +11,6 @@ namespace omath::collision
     class MeshCollider
     {
     public:
-
         using VertexType = MeshType::VertexType;
         using VectorType = VertexType::VectorType;
         explicit MeshCollider(MeshType mesh): m_mesh(std::move(mesh))

From e54d5e7388dcbbf5f0f821fda2665fc8a066e076 Mon Sep 17 00:00:00 2001
From: Orange <orange-cpp@yandex.ru>
Date: Sat, 29 Nov 2025 16:49:19 +0300
Subject: [PATCH 6/6] changed ebo type

---
 include/omath/3d_primitives/mesh.hpp | 10 +++++-----
 tests/general/unit_test_epa.cpp      |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/omath/3d_primitives/mesh.hpp b/include/omath/3d_primitives/mesh.hpp
index f5f47b7..bd89733 100644
--- a/include/omath/3d_primitives/mesh.hpp
+++ b/include/omath/3d_primitives/mesh.hpp
@@ -33,13 +33,13 @@ namespace omath::primitives
 
     private:
         using Vbo = std::vector<VertexType>;
-        using Vao = std::vector<Vector3<std::size_t>>;
+        using Ebo = std::vector<Vector3<std::uint32_t>>;
 
     public:
         Vbo m_vertex_buffer;
-        Vao m_vertex_array_object;
+        Ebo m_vertex_array_object;
 
-        Mesh(Vbo vbo, Vao vao,
+        Mesh(Vbo vbo, Ebo vao,
              const VectorType scale =
                      {
                              1,
@@ -97,7 +97,7 @@ namespace omath::primitives
         }
 
         [[nodiscard]]
-        Vector3<float> vertex_to_world_space(const Vector3<float>& vertex_position) const
+        VectorType vertex_to_world_space(const Vector3<float>& vertex_position) const
         requires HasPosition<VertexType>
         {
             auto abs_vec = get_to_world_matrix() * mat_column_from_vector(vertex_position);
@@ -106,7 +106,7 @@ namespace omath::primitives
         }
 
         [[nodiscard]]
-        Triangle<Vector3<float>> make_face_in_world_space(const Vao::const_iterator vao_iterator) const
+        Triangle<VectorType> make_face_in_world_space(const Ebo::const_iterator vao_iterator) const
         requires HasPosition<VertexType>
         {
             return {vertex_to_world_space(m_vertex_buffer.at(vao_iterator->x).position),
diff --git a/tests/general/unit_test_epa.cpp b/tests/general/unit_test_epa.cpp
index c0b8464..10287a3 100644
--- a/tests/general/unit_test_epa.cpp
+++ b/tests/general/unit_test_epa.cpp
@@ -24,7 +24,7 @@ TEST(UnitTestEpa, TestCollisionTrue)
         { { 1.f, -1.f,  1.f}, {}, {} },
         { { 1.f, -1.f, -1.f}, {}, {} }
     };
-    std::vector<omath::Vector3<std::size_t>> vao; // not needed
+    std::vector<omath::Vector3<std::uint32_t>> vao; // not needed
 
     Mesh a(vbo, vao, {1, 1, 1});
     Mesh b(vbo, vao, {1, 1, 1});
@@ -98,7 +98,7 @@ TEST(UnitTestEpa, TestCollisionTrue2)
         { {  1.f, -1.f,  1.f }, {}, {} },
         { {  1.f, -1.f, -1.f }, {}, {} }
     };
-    std::vector<omath::Vector3<std::size_t>> vao; // not needed
+    std::vector<omath::Vector3<std::uint32_t>> vao; // not needed
 
     Mesh a(vbo, vao, {1, 1, 1});
     Mesh b(vbo, vao, {1, 1, 1});