From 9ff5d34908ca3bdaf79ebc2d6726b2d49ea340fc Mon Sep 17 00:00:00 2001 From: JackCarterSmith Date: Wed, 2 Oct 2024 21:41:16 +0200 Subject: [PATCH] Enhanced mesh structure --- CMakeLists.txt | 8 +- Engine/Graphics/3DRenderer.cpp | 60 ++++----- Engine/Graphics/3DRenderer.hpp | 39 +----- Engine/Utils/3DMaths.hpp | 7 ++ Engine/Utils/3DMaths.inl | 221 +++++++++++++++++++++++++++++++++ Engine/Utils/MeshHelper.hpp | 48 +++++-- Engine/World/DbgCube.cpp | 36 ++++++ Engine/World/DbgCube.hpp | 13 ++ Engine/World/WorldObject.hpp | 33 +++++ srcs.list | 3 + 10 files changed, 389 insertions(+), 79 deletions(-) create mode 100644 Engine/World/DbgCube.cpp create mode 100644 Engine/World/DbgCube.hpp create mode 100644 Engine/World/WorldObject.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 94f321f..e07ae48 100644 --- a/CMakeLists.txt +++ b/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 diff --git a/Engine/Graphics/3DRenderer.cpp b/Engine/Graphics/3DRenderer.cpp index 5dc1c13..cee615c 100644 --- a/Engine/Graphics/3DRenderer.cpp +++ b/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) { - M3D_VECTOR _vV = M3D_V4LoadF3(&_v.pos); - M3D_VECTOR projV = M3D_V3Transform(_vV, MVPMat); - //projV = M3D_V3Transform(projV, viewProjMat); - - // Clipping (simple) - if (M3D_V4GetZ(projV) <= 0) - clipped = true; + auto cubeMesh = testObj.GetObjectMesh(); + M3D_F4 projVertices[cubeMesh.vertices.size()]; + M3D_V3Transform(projVertices, sizeof(M3D_F4), (M3D_F3*)cubeMesh.vertices.data(), sizeof(Vertex), cubeMesh.vertices.size(), MVPMat); - // Perspective divide - M3D_VECTOR _w = M3D_V4SplatW(projV); - projV = M3D_V4Divide(projV, _w); + auto indicePtr = (uint32_t*)cubeMesh.parts[0].indices.data(); + for (uint32_t i = 0; i < cubeMesh.parts[0].indices.size(); i += 3) { + // Misscontructed indices tree failsafe + if (i+2 > cubeMesh.parts[0].indices.size()) + break; - // Viewport transform - projV = M3D_V3Transform(projV, (viewportMat)); - M3D_V4StoreF3(&_2dCoord, projV); - 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 ((projVertices[indicePtr[i]]).z > 0 && + (projVertices[indicePtr[i+1]]).z > 0 && + (projVertices[indicePtr[i+2]]).z > 0) { - if (v_cnt++ >= 2) { - if (!clipped) { + M3D_VECTOR V1 = M3D_V4LoadF4(&projVertices[indicePtr[i]]); + 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); - } - v_cnt = 0; - yep_cnt++; - clipped = false; - } + } //TODO: else cut triangle to the window (need vector crossing math...) } } \ No newline at end of file diff --git a/Engine/Graphics/3DRenderer.hpp b/Engine/Graphics/3DRenderer.hpp index 226b77d..a237a22 100644 --- a/Engine/Graphics/3DRenderer.hpp +++ b/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 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 mMainCamera; - MeshObjCube testObj; + ObjectDbgCube testObj; }; \ No newline at end of file diff --git a/Engine/Utils/3DMaths.hpp b/Engine/Utils/3DMaths.hpp index 53d0830..03bd424 100644 --- a/Engine/Utils/3DMaths.hpp +++ b/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; // diff --git a/Engine/Utils/3DMaths.inl b/Engine/Utils/3DMaths.inl index 02d73a0..3736a03 100644 --- a/Engine/Utils/3DMaths.inl +++ b/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(pInputStream); + auto pOutputVector = reinterpret_cast(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(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(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(pOutputStream) & 0xF) && !(OutputStride & 0xF)) { + // Packed input, aligned output + for (size_t j = 0; j < four; ++j) { + __m128 V1 = _mm_loadu_ps(reinterpret_cast(pInputVector)); + __m128 L2 = _mm_loadu_ps(reinterpret_cast(pInputVector + 16)); + __m128 L3 = _mm_loadu_ps(reinterpret_cast(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(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(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(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(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(pInputVector)); + __m128 L2 = _mm_loadu_ps(reinterpret_cast(pInputVector + 16)); + __m128 L3 = _mm_loadu_ps(reinterpret_cast(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(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(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(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(pOutputVector), vTemp); + pOutputVector += OutputStride; + + i += 4; + } + } + } + } + + if (!(reinterpret_cast(pOutputStream) & 0xF) && !(OutputStride & 0xF)) { + // Aligned output + for (; i < VectorCount; ++i) { + M3D_VECTOR V = M3D_V4LoadF3(reinterpret_cast(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(pOutputVector), vTemp); + pOutputVector += OutputStride; + } + } else { + // Unaligned output + for (; i < VectorCount; ++i) + { + M3D_VECTOR V = M3D_V4LoadF3(reinterpret_cast(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(pOutputVector), vTemp); + pOutputVector += OutputStride; + } + } + + M3D_SFENCE(); + + return pOutputStream; +#endif +} + /* -------------------------------------------------------------------------------------------------------------------------- */ diff --git a/Engine/Utils/MeshHelper.hpp b/Engine/Utils/MeshHelper.hpp index 2ffd58b..37450ea 100644 --- a/Engine/Utils/MeshHelper.hpp +++ b/Engine/Utils/MeshHelper.hpp @@ -1,23 +1,49 @@ #pragma once +#include + +#include + #include "../Utils/3DMaths.hpp" -struct MeshVertex { - MeshVertex() = default; +#define MHELPER_INDICES_TRI_ADD(array, i1, i2, i3) \ + array.push_back(i1); \ + array.push_back(i2); \ + array.push_back(i3); - MeshVertex(const MeshVertex&) = default; - MeshVertex& operator=(const MeshVertex&) = default; - MeshVertex(MeshVertex&&) = default; - MeshVertex& operator=(MeshVertex&&) = default; +struct Vertex { + Vertex() = default; - MeshVertex(M3D_F3 const& _pos) noexcept : pos(_pos) {} - MeshVertex(const float _x, const float _y, const float _z) noexcept : pos(M3D_F3(_x,_y,_z)) {} - MeshVertex(M3D_VECTOR const _pos) noexcept { + Vertex(const Vertex&) = default; + Vertex& operator=(const Vertex&) = default; + 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 indices = {}; + M3D_F4X4 transform = M3D_MIdentity4x4(); + std::vector subparts; + +}; + +struct Mesh { + std::vector vertices; + std::vector parts; + +}; -}; \ No newline at end of file diff --git a/Engine/World/DbgCube.cpp b/Engine/World/DbgCube.cpp new file mode 100644 index 0000000..6b30db3 --- /dev/null +++ b/Engine/World/DbgCube.cpp @@ -0,0 +1,36 @@ +#include "DbgCube.hpp" + +#include + + +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); +} \ No newline at end of file diff --git a/Engine/World/DbgCube.hpp b/Engine/World/DbgCube.hpp new file mode 100644 index 0000000..1f52eca --- /dev/null +++ b/Engine/World/DbgCube.hpp @@ -0,0 +1,13 @@ +#pragma once + +#include "WorldObject.hpp" + + +class ObjectDbgCube final : public WorldObjectAbstract { +public: + ObjectDbgCube(); + ~ObjectDbgCube() {} + +private: + +}; \ No newline at end of file diff --git a/Engine/World/WorldObject.hpp b/Engine/World/WorldObject.hpp new file mode 100644 index 0000000..85854e8 --- /dev/null +++ b/Engine/World/WorldObject.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include + +#include "../Utils/MeshHelper.hpp" + + +class WorldObject {}; + +template +class WorldObjectAbstract : public WorldObject { +public: + virtual ~WorldObjectAbstract() = 0; + + const Mesh& GetObjectMesh() const noexcept { return mMesh; } + +protected: + inline static Mesh mMesh; + +}; + +template +inline WorldObjectAbstract::~WorldObjectAbstract() {} + +/* +class WorldObject { +public: + virtual ~WorldObjectAbstract() = 0; + + virtual std::vector& GetObjectMesh() const = 0; + +}; +*/ \ No newline at end of file diff --git a/srcs.list b/srcs.list index ceb8172..803b912 100644 --- a/srcs.list +++ b/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