Enhanced mesh structure

CMakeLists.txt

@@ -11,7 +11,7 @@ if(NOT DEFINED PROJECT_BINARY_DIR)
 endif()
 
 if(NOT MSVC)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -march=native -mavx2 -mfma -msse4.2")
 else()
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Wall")
 endif()
@@ -56,8 +56,12 @@ if(MSVC)
 	# msvc does not append 'lib' - do it here to have consistent name
 	set_target_properties(${PROJECT_NAME} PROPERTIES IMPORT_PREFIX "lib")
 endif()
-if (DISABLE_CPU_OPTI)
+if(DISABLE_CPU_OPTI)
 	target_compile_definitions(${PROJECT_NAME} PUBLIC DISABLE_INTRINSICS)
+else()
+	target_compile_definitions(${PROJECT_NAME} PUBLIC FMA3_INTRINSICS)
+	target_compile_definitions(${PROJECT_NAME} PUBLIC AVX_INTRINSICS)
+	target_compile_definitions(${PROJECT_NAME} PUBLIC AVX2_INTRINSICS)
 endif()
 
 # GPG signature custom command

Engine/Graphics/3DRenderer.cpp

@@ -28,11 +28,9 @@ Graphic3DRenderer::~Graphic3DRenderer() {}
 void Graphic3DRenderer::Draw(sf::RenderTexture& context) {
     sf::BlendMode sBM = sf::BlendNone;
     sf::RenderStates sRS(sBM);
-    sf::Color yep[] = {sf::Color::White, sf::Color::Blue, sf::Color::Green, sf::Color::Red, sf::Color::Magenta, sf::Color::Cyan, sf::Color::Yellow};
 
     static float thetaAngle = 0.31f;
     thetaAngle = thetaAngle >= 6.283185f ? -6.283185f : thetaAngle + 0.004f;
-    bool clipped = false;
 
     M3D_MATRIX viewMat = mMainCamera->GetView();
     M3D_MATRIX projMat = mMainCamera->GetProj();
@@ -40,40 +38,44 @@ void Graphic3DRenderer::Draw(sf::RenderTexture& context) {
     M3D_MATRIX viewProjMat = (viewMat) * (projMat);
     M3D_MATRIX MVPMat = modelMat * viewProjMat;
     M3D_MATRIX viewportMat = M3D_TransformMatrixViewport(1280.0f, 324.f, 0.0f, 0.0f);
-    uint8_t v_cnt = 0, yep_cnt = 0;
     sf::Vertex v_tri[4];
-    M3D_F3 _2dCoord;
     
-    for (const auto _v : testObj.mMesh) {
+    auto cubeMesh = testObj.GetObjectMesh();
-        M3D_VECTOR _vV = M3D_V4LoadF3(&_v.pos);
+    M3D_F4 projVertices[cubeMesh.vertices.size()];
-        M3D_VECTOR projV = M3D_V3Transform(_vV, MVPMat);
+    M3D_V3Transform(projVertices, sizeof(M3D_F4), (M3D_F3*)cubeMesh.vertices.data(), sizeof(Vertex), cubeMesh.vertices.size(), MVPMat);
-        //projV = M3D_V3Transform(projV, viewProjMat);
-        
-        // Clipping (simple)
-        if (M3D_V4GetZ(projV) <= 0)
-            clipped = true;
 
-        // Perspective divide
+    auto indicePtr = (uint32_t*)cubeMesh.parts[0].indices.data();
-        M3D_VECTOR _w = M3D_V4SplatW(projV);
+    for (uint32_t i = 0; i < cubeMesh.parts[0].indices.size(); i += 3) {
-        projV = M3D_V4Divide(projV, _w);
+        // Misscontructed indices tree failsafe
+        if (i+2 > cubeMesh.parts[0].indices.size())
+            break;
 
-        // Viewport transform
+        if ((projVertices[indicePtr[i]]).z > 0 &&
-        projV = M3D_V3Transform(projV, (viewportMat));
+            (projVertices[indicePtr[i+1]]).z > 0 &&
-        M3D_V4StoreF3(&_2dCoord, projV);
+            (projVertices[indicePtr[i+2]]).z > 0) {
-        v_tri[v_cnt].position.x = _2dCoord.x;
-        v_tri[v_cnt].position.y = _2dCoord.y;
-        //v_tri[v_cnt].position.z = ((far+near)/2)+((far-near)/2)*_2dCoord.z;   //TODO: transform matrix is incomplete
-        v_tri[v_cnt].color = yep[yep_cnt % 5];
 
-        if (v_cnt++ >= 2) {
+                M3D_VECTOR V1 = M3D_V4LoadF4(&projVertices[indicePtr[i]]);
-            if (!clipped) {
+                M3D_VECTOR V2 = M3D_V4LoadF4(&projVertices[indicePtr[i+1]]);
+                M3D_VECTOR V3 = M3D_V4LoadF4(&projVertices[indicePtr[i+2]]);
+
+                V1 = M3D_V4Divide(V1, M3D_V4SplatW(V1));
+                V2 = M3D_V4Divide(V2, M3D_V4SplatW(V2));
+                V3 = M3D_V4Divide(V3, M3D_V4SplatW(V3));
+
+                V1 = M3D_V3Transform(V1, viewportMat);
+                V2 = M3D_V3Transform(V2, viewportMat);
+                V3 = M3D_V3Transform(V3, viewportMat);
+                //v_tri[v_cnt].position.z = ((far+near)/2)+((far-near)/2)*_2dCoord.z;   //TODO: transform matrix is incomplete
+
+                v_tri[0].position = sf::Vector2f(M3D_V4GetX(V1), M3D_V4GetY(V1));
+                v_tri[0].color = cubeMesh.vertices[indicePtr[i]].color;
                 v_tri[3] = v_tri[0];
+                v_tri[1].position = sf::Vector2f(M3D_V4GetX(V2), M3D_V4GetY(V2));
+                v_tri[1].color = cubeMesh.vertices[indicePtr[i+1]].color;
+                v_tri[2].position = sf::Vector2f(M3D_V4GetX(V3), M3D_V4GetY(V3));
+                v_tri[2].color = cubeMesh.vertices[indicePtr[i+2]].color;
                 context.draw(v_tri, 4, sf::LineStrip, sRS);
                 //context.draw(v_tri, 3, sf::Triangles, sRS);
-            }
+        } //TODO: else cut triangle to the window (need vector crossing math...)
-            v_cnt = 0;
-            yep_cnt++;
-            clipped = false;
-        }
     }
 }

Engine/Graphics/3DRenderer.hpp

@@ -7,44 +7,9 @@
 
 #include "Camera.hpp"
 #include "../Utils/MeshHelper.hpp"
+#include "../World/DbgCube.hpp"
 
 
-class MeshObjCube final {
-public:
-    MeshObjCube() {
-        mMesh = {
-            // RIGHT
-            {0.5f, 0.5f, -0.5f}, {0.5f, -0.5f, 0.5f}, {0.5f, 0.5f, 0.5f},
-			{0.5f, 0.5f, -0.5f}, {0.5f, -0.5f, 0.5f}, {0.5f, -0.5f, -0.5f},
-
-            // FRONT
-            {0.5f, 0.5f, 0.5f}, {0.5f, -0.5f, 0.5f}, {-0.5f, -0.5f, 0.5f},
-            {0.5f, 0.5f, 0.5f}, {-0.5f, -0.5f, 0.5f}, {-0.5f, 0.5f, 0.5f},
-			
-            // LEFT
-            {-0.5f, 0.5f, 0.5f}, {-0.5f, -0.5f, 0.5f}, {-0.5f, 0.5f, -0.5f},
-			{-0.5f, 0.5f, -0.5f}, {-0.5f, -0.5f, 0.5f}, {-0.5f, -0.5f, -0.5f},
-
-            // BACK
-            {0.5f, 0.5f, -0.5f}, {-0.5f, 0.5f, -0.5f}, {0.5f, -0.5f, -0.5f},
-			{-0.5f, 0.5f, -0.5f}, {-0.5f, -0.5f, -0.5f}, {0.5f, -0.5f, -0.5f},
-			
-            // TOP
-            {-0.5f, 0.5f, -0.5f}, {0.5f, 0.5f, -0.5f}, {-0.5f, 0.5f, 0.5f},
-			{0.5f, 0.5f, -0.5f}, {0.5f, 0.5f, 0.5f}, {-0.5f, 0.5f, 0.5f},
-			
-            // BOTTOM
-            {-0.5f, -0.5f, -0.5f}, {-0.5f, -0.5f, 0.5f}, {0.5f, -0.5f, 0.5f},
-			{0.5f, -0.5f, 0.5f}, {0.5f, -0.5f, -0.5f}, {-0.5f, -0.5f, -0.5f},
-        };
-    }
-    
-    std::vector<MeshVertex> mMesh;
-
-private:
-
-};
-
 class Graphic3DRenderer final {
 public:
     Graphic3DRenderer();
@@ -61,6 +26,6 @@ private:
     sf::RenderTexture mWorldRender;   // This is used to create the scene
     std::unique_ptr<Camera> mMainCamera;
 
-    MeshObjCube testObj;
+    ObjectDbgCube testObj;
 
 };

Engine/Utils/3DMaths.hpp

@@ -40,6 +40,12 @@
     #else
         #define M3D_PERMUTE_PS( v, c ) _mm_shuffle_ps((v), (v), c )
     #endif
+
+    #define M3D_UNPACK3INTO4(l1, l2, l3) \
+    M3D_VECTOR V3 = _mm_shuffle_ps(l2, l3, _MM_SHUFFLE(0, 0, 3, 2));\
+    M3D_VECTOR V2 = _mm_shuffle_ps(l2, l1, _MM_SHUFFLE(3, 3, 1, 0));\
+    V2 = M3D_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 0, 2));\
+    M3D_VECTOR V4 = _mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(L3), 32 / 8))
 #endif
 
 //
@@ -333,6 +339,7 @@ M3D_MATRIX M3D_MTranspose(M3D_MATRIX M) noexcept;
 //  Vector/Matrix operation
 //
 M3D_VECTOR M3D_V3Transform(M3D_VECTOR V, M3D_MATRIX M) noexcept;
+M3D_F4* M3D_V3Transform(M3D_F4* pOutputStream, size_t OutputStride, const M3D_F3* pInputStream, size_t InputStride, size_t VectorCount, M3D_MATRIX M) noexcept;
 
 
 //

Engine/Utils/3DMaths.inl

@@ -1130,6 +1130,227 @@ inline M3D_VECTOR M3D_V3Transform(M3D_VECTOR V, M3D_MATRIX M) noexcept {
 #endif
 }
 
+inline M3D_F4* M3D_V3Transform(
+    M3D_F4* pOutputStream,
+    size_t OutputStride,
+    const M3D_F3* pInputStream,
+    size_t InputStride,
+    size_t VectorCount,
+    M3D_MATRIX M
+) noexcept {
+    auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
+    auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
+
+    const M3D_VECTOR row0 = M.rows[0];
+    const M3D_VECTOR row1 = M.rows[1];
+    const M3D_VECTOR row2 = M.rows[2];
+    const M3D_VECTOR row3 = M.rows[3];
+
+#ifdef DISABLE_INTRINSICS
+    for (size_t i = 0; i < VectorCount; i++) {
+        M3D_VECTOR V = M3D_V4LoadF3(reinterpret_cast<const M3D_F3*>(pInputVector));
+        M3D_VECTOR Z = M3D_V4SplatZ(V);
+        M3D_VECTOR Y = M3D_V4SplatY(V);
+        M3D_VECTOR X = M3D_V4SplatX(V);
+
+        M3D_VECTOR Result = M3D_V4MultiplyAdd(Z, row2, row3);
+        Result = M3D_V4MultiplyAdd(Y, row1, Result);
+        Result = M3D_V4MultiplyAdd(X, row0, Result);
+
+        M3D_V4StoreF4(reinterpret_cast<M3D_F4*>(pOutputVector), Result);
+
+        pInputVector += InputStride;
+        pOutputVector += OutputStride;
+    }
+
+    return pOutputStream;
+#else
+    size_t i = 0;
+    size_t four = VectorCount >> 2;
+    if (four > 0) {
+        if (InputStride == sizeof(M3D_F3)) {
+            if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) && !(OutputStride & 0xF)) {
+                // Packed input, aligned output
+                for (size_t j = 0; j < four; ++j) {
+                    __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
+                    __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
+                    __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
+                    pInputVector += sizeof(M3D_F3) * 4;
+
+                    // Unpack the 4 vectors (.w components are junk)
+                    M3D_UNPACK3INTO4(V1, L2, L3);
+
+                    // Result 1
+                    M3D_VECTOR Z = M3D_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
+                    M3D_VECTOR Y = M3D_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
+                    M3D_VECTOR X = M3D_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
+
+                    M3D_VECTOR vTemp = M3D_FMADD_PS(Z, row2, row3);
+                    M3D_VECTOR vTemp2 = _mm_mul_ps(Y, row1);
+                    M3D_VECTOR vTemp3 = _mm_mul_ps(X, row0);
+                    vTemp = _mm_add_ps(vTemp, vTemp2);
+                    vTemp = _mm_add_ps(vTemp, vTemp3);
+                    M3D_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
+                    pOutputVector += OutputStride;
+
+                    // Result 2
+                    Z = M3D_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
+                    Y = M3D_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
+                    X = M3D_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
+
+                    vTemp = M3D_FMADD_PS(Z, row2, row3);
+                    vTemp2 = _mm_mul_ps(Y, row1);
+                    vTemp3 = _mm_mul_ps(X, row0);
+                    vTemp = _mm_add_ps(vTemp, vTemp2);
+                    vTemp = _mm_add_ps(vTemp, vTemp3);
+                    M3D_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
+                    pOutputVector += OutputStride;
+
+                    // Result 3
+                    Z = M3D_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
+                    Y = M3D_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
+                    X = M3D_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
+
+                    vTemp = M3D_FMADD_PS(Z, row2, row3);
+                    vTemp2 = _mm_mul_ps(Y, row1);
+                    vTemp3 = _mm_mul_ps(X, row0);
+                    vTemp = _mm_add_ps(vTemp, vTemp2);
+                    vTemp = _mm_add_ps(vTemp, vTemp3);
+                    M3D_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
+                    pOutputVector += OutputStride;
+
+                    // Result 4
+                    Z = M3D_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
+                    Y = M3D_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
+                    X = M3D_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
+
+                    vTemp = M3D_FMADD_PS(Z, row2, row3);
+                    vTemp2 = _mm_mul_ps(Y, row1);
+                    vTemp3 = _mm_mul_ps(X, row0);
+                    vTemp = _mm_add_ps(vTemp, vTemp2);
+                    vTemp = _mm_add_ps(vTemp, vTemp3);
+                    M3D_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
+                    pOutputVector += OutputStride;
+
+                    i += 4;
+                }
+            } else {
+                // Packed input, unaligned output
+                for (size_t j = 0; j < four; ++j)
+                {
+                    __m128 V1 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector));
+                    __m128 L2 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 16));
+                    __m128 L3 = _mm_loadu_ps(reinterpret_cast<const float*>(pInputVector + 32));
+                    pInputVector += sizeof(M3D_F3) * 4;
+
+                    // Unpack the 4 vectors (.w components are junk)
+                    M3D_UNPACK3INTO4(V1, L2, L3);
+
+                    // Result 1
+                    M3D_VECTOR Z = M3D_PERMUTE_PS(V1, _MM_SHUFFLE(2, 2, 2, 2));
+                    M3D_VECTOR Y = M3D_PERMUTE_PS(V1, _MM_SHUFFLE(1, 1, 1, 1));
+                    M3D_VECTOR X = M3D_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 0));
+
+                    M3D_VECTOR vTemp = M3D_FMADD_PS(Z, row2, row3);
+                    M3D_VECTOR vTemp2 = _mm_mul_ps(Y, row1);
+                    M3D_VECTOR vTemp3 = _mm_mul_ps(X, row0);
+                    vTemp = _mm_add_ps(vTemp, vTemp2);
+                    vTemp = _mm_add_ps(vTemp, vTemp3);
+                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
+                    pOutputVector += OutputStride;
+
+                    // Result 2
+                    Z = M3D_PERMUTE_PS(V2, _MM_SHUFFLE(2, 2, 2, 2));
+                    Y = M3D_PERMUTE_PS(V2, _MM_SHUFFLE(1, 1, 1, 1));
+                    X = M3D_PERMUTE_PS(V2, _MM_SHUFFLE(0, 0, 0, 0));
+
+                    vTemp = M3D_FMADD_PS(Z, row2, row3);
+                    vTemp2 = _mm_mul_ps(Y, row1);
+                    vTemp3 = _mm_mul_ps(X, row0);
+                    vTemp = _mm_add_ps(vTemp, vTemp2);
+                    vTemp = _mm_add_ps(vTemp, vTemp3);
+                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
+                    pOutputVector += OutputStride;
+
+                    // Result 3
+                    Z = M3D_PERMUTE_PS(V3, _MM_SHUFFLE(2, 2, 2, 2));
+                    Y = M3D_PERMUTE_PS(V3, _MM_SHUFFLE(1, 1, 1, 1));
+                    X = M3D_PERMUTE_PS(V3, _MM_SHUFFLE(0, 0, 0, 0));
+
+                    vTemp = M3D_FMADD_PS(Z, row2, row3);
+                    vTemp2 = _mm_mul_ps(Y, row1);
+                    vTemp3 = _mm_mul_ps(X, row0);
+                    vTemp = _mm_add_ps(vTemp, vTemp2);
+                    vTemp = _mm_add_ps(vTemp, vTemp3);
+                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
+                    pOutputVector += OutputStride;
+
+                    // Result 4
+                    Z = M3D_PERMUTE_PS(V4, _MM_SHUFFLE(2, 2, 2, 2));
+                    Y = M3D_PERMUTE_PS(V4, _MM_SHUFFLE(1, 1, 1, 1));
+                    X = M3D_PERMUTE_PS(V4, _MM_SHUFFLE(0, 0, 0, 0));
+
+                    vTemp = M3D_FMADD_PS(Z, row2, row3);
+                    vTemp2 = _mm_mul_ps(Y, row1);
+                    vTemp3 = _mm_mul_ps(X, row0);
+                    vTemp = _mm_add_ps(vTemp, vTemp2);
+                    vTemp = _mm_add_ps(vTemp, vTemp3);
+                    _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
+                    pOutputVector += OutputStride;
+
+                    i += 4;
+                }
+            }
+        }
+    }
+
+    if (!(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) && !(OutputStride & 0xF)) {
+        // Aligned output
+        for (; i < VectorCount; ++i) {
+            M3D_VECTOR V = M3D_V4LoadF3(reinterpret_cast<const M3D_F3*>(pInputVector));
+            pInputVector += InputStride;
+
+            M3D_VECTOR Z = M3D_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
+            M3D_VECTOR Y = M3D_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
+            M3D_VECTOR X = M3D_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
+
+            M3D_VECTOR vTemp = M3D_FMADD_PS(Z, row2, row3);
+            M3D_VECTOR vTemp2 = _mm_mul_ps(Y, row1);
+            M3D_VECTOR vTemp3 = _mm_mul_ps(X, row0);
+            vTemp = _mm_add_ps(vTemp, vTemp2);
+            vTemp = _mm_add_ps(vTemp, vTemp3);
+
+            M3D_STREAM_PS(reinterpret_cast<float*>(pOutputVector), vTemp);
+            pOutputVector += OutputStride;
+        }
+    } else {
+        // Unaligned output
+        for (; i < VectorCount; ++i)
+        {
+            M3D_VECTOR V = M3D_V4LoadF3(reinterpret_cast<const M3D_F3*>(pInputVector));
+            pInputVector += InputStride;
+
+            M3D_VECTOR Z = M3D_PERMUTE_PS(V, _MM_SHUFFLE(2, 2, 2, 2));
+            M3D_VECTOR Y = M3D_PERMUTE_PS(V, _MM_SHUFFLE(1, 1, 1, 1));
+            M3D_VECTOR X = M3D_PERMUTE_PS(V, _MM_SHUFFLE(0, 0, 0, 0));
+
+            M3D_VECTOR vTemp = M3D_FMADD_PS(Z, row2, row3);
+            M3D_VECTOR vTemp2 = _mm_mul_ps(Y, row1);
+            M3D_VECTOR vTemp3 = _mm_mul_ps(X, row0);
+            vTemp = _mm_add_ps(vTemp, vTemp2);
+            vTemp = _mm_add_ps(vTemp, vTemp3);
+
+            _mm_storeu_ps(reinterpret_cast<float*>(pOutputVector), vTemp);
+            pOutputVector += OutputStride;
+        }
+    }
+
+    M3D_SFENCE();
+
+    return pOutputStream;
+#endif
+}
+
 
 /* -------------------------------------------------------------------------------------------------------------------------- */
 

Engine/Utils/MeshHelper.hpp

@@ -1,23 +1,49 @@
 #pragma once
 
+#include <vector>
+
+#include <SFML/Graphics/Color.hpp>
+
 #include "../Utils/3DMaths.hpp"
 
 
-struct MeshVertex {
+#define MHELPER_INDICES_TRI_ADD(array, i1, i2, i3)	\
-    MeshVertex() = default;
+	array.push_back(i1); \
+	array.push_back(i2); \
+	array.push_back(i3);
 
-	MeshVertex(const MeshVertex&) = default;
+struct Vertex {
-	MeshVertex& operator=(const MeshVertex&) = default;
+    Vertex() = default;
-	MeshVertex(MeshVertex&&) = default;
-	MeshVertex& operator=(MeshVertex&&) = default;
 
-    MeshVertex(M3D_F3 const& _pos) noexcept : pos(_pos) {}
+    Vertex(const Vertex&) = default;
-    MeshVertex(const float _x, const float _y, const float _z) noexcept : pos(M3D_F3(_x,_y,_z)) {}
+	Vertex& operator=(const Vertex&) = default;
-    MeshVertex(M3D_VECTOR const _pos) noexcept { 
+	Vertex(Vertex&&) = default;
+	Vertex& operator=(Vertex&&) = default;
+
+    Vertex(M3D_F3 const& _pos) noexcept : pos(_pos) {}
+    Vertex(M3D_F3 const& _pos, sf::Color const& _color) noexcept : pos(_pos), color(_color) {}
+    Vertex(const float _x, const float _y, const float _z) noexcept : pos(M3D_F3(_x,_y,_z)) {}
+    Vertex(M3D_VECTOR const _pos) noexcept { 
         M3D_V4StoreF3(&this->pos, _pos);
     }
 
     M3D_F3 pos = {0.0f, 0.0f, 0.0f};
-    M3D_F4 color = {255.0f, 255.0f, 255.0f, 255.f};
+    sf::Color color = {255, 255, 255, 255};
+
+};
+
+struct MeshPart{
+    MeshPart() = default;
+
+    std::vector<unsigned int> indices = {};
+    M3D_F4X4 transform = M3D_MIdentity4x4();
+    std::vector<MeshPart> subparts;
+
+};
+
+struct Mesh {
+    std::vector<Vertex> vertices;
+    std::vector<MeshPart> parts;
+
+};
 
-};

Engine/World/DbgCube.cpp

@@ -0,0 +1,36 @@
+#include "DbgCube.hpp"
+
+#include <stdexcept>
+
+
+ObjectDbgCube::ObjectDbgCube() {
+    try {
+        mMesh.vertices.resize(8);
+    } catch (const std::length_error& ex) {
+        throw ex;
+    }
+
+    mMesh.vertices[0] = { M3D_F3(0.5f, 0.5f, 0.5f), sf::Color::White};
+    mMesh.vertices[1] = { M3D_F3(0.5f, -0.5f, 0.5f), sf::Color::Green};
+    mMesh.vertices[2] = { M3D_F3(-0.5f, 0.5f, 0.5f), sf::Color::Yellow};
+    mMesh.vertices[3] = { M3D_F3(-0.5f, -0.5f, 0.5f), sf::Color::Cyan};
+    mMesh.vertices[4] = { M3D_F3(0.5f, 0.5f, -0.5f), sf::Color::Blue};
+    mMesh.vertices[5] = { M3D_F3(0.5f, -0.5f, -0.5f), sf::Color::Red};
+    mMesh.vertices[6] = { M3D_F3(-0.5f, 0.5f, -0.5f), sf::Color::Magenta};
+    mMesh.vertices[7] = { M3D_F3(-0.5f, -0.5f, -0.5f), sf::Color::Black};
+
+    MeshPart basePart;
+    MHELPER_INDICES_TRI_ADD(basePart.indices, 4, 2, 0);
+    MHELPER_INDICES_TRI_ADD(basePart.indices, 2, 7, 3);
+    MHELPER_INDICES_TRI_ADD(basePart.indices, 6, 5, 7);
+    MHELPER_INDICES_TRI_ADD(basePart.indices, 1, 7, 5);
+    MHELPER_INDICES_TRI_ADD(basePart.indices, 0, 3, 1);
+    MHELPER_INDICES_TRI_ADD(basePart.indices, 4, 1, 5);
+    MHELPER_INDICES_TRI_ADD(basePart.indices, 4, 6, 2);
+    MHELPER_INDICES_TRI_ADD(basePart.indices, 2, 6, 7);
+    MHELPER_INDICES_TRI_ADD(basePart.indices, 6, 4, 5);
+    MHELPER_INDICES_TRI_ADD(basePart.indices, 1, 3, 7);
+    MHELPER_INDICES_TRI_ADD(basePart.indices, 0, 2, 3);
+    MHELPER_INDICES_TRI_ADD(basePart.indices, 4, 0, 1);
+    mMesh.parts.push_back(basePart);
+}

Engine/World/DbgCube.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "WorldObject.hpp"
+
+
+class ObjectDbgCube final : public WorldObjectAbstract<ObjectDbgCube> {
+public:
+    ObjectDbgCube();
+    ~ObjectDbgCube() {}
+
+private:
+
+};

Engine/World/WorldObject.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <vector>
+
+#include "../Utils/MeshHelper.hpp"
+
+
+class WorldObject {};
+
+template<class D>
+class WorldObjectAbstract : public WorldObject {
+public:
+    virtual ~WorldObjectAbstract() = 0;
+    
+    const Mesh& GetObjectMesh() const noexcept { return mMesh; }
+
+protected:
+    inline static Mesh mMesh;
+
+};
+
+template<class D>
+inline WorldObjectAbstract<D>::~WorldObjectAbstract() {}
+
+/*
+class WorldObject {
+public:
+    virtual ~WorldObjectAbstract() = 0;
+    
+    virtual std::vector<MeshVertex>& GetObjectMesh() const = 0;
+
+};
+*/

srcs.list

@@ -20,6 +20,9 @@ set(MISC_SCRS
     Engine/Misc/Fonts.hpp
 )
 set(GAME_SCRS
+    Engine/World/WorldObject.hpp
+    Engine/World/DbgCube.cpp
+    Engine/World/DbgCube.hpp
     Engine/World/Arena.cpp
     Engine/World/Player.cpp
     Engine/World/Tank.cpp