JCS-Prod/ProtoTank
1
0
Fork 0
Code Issues Pull Requests Projects Releases Activity

Enhanced mesh structure

Browse Source
This commit is contained in:
JackCarterSmith 2024-10-02 21:41:16 +02:00
parent 55ff78ee50
commit 9ff5d34908
Signed by: JackCarterSmith
GPG Key ID: 832E52F4E23F8F24
10 changed files with 389 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CMakeLists.txt
View File

@ -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

58
Engine/Graphics/3DRenderer.cpp
View File

@ -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);
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);
// Clipping (simple)
if (M3D_V4GetZ(projV) <= 0)
clipped = true;
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;
// Perspective divide
M3D_VECTOR _w = M3D_V4SplatW(projV);
projV = M3D_V4Divide(projV, _w);
if ((projVertices[indicePtr[i]]).z > 0 &&
(projVertices[indicePtr[i+1]]).z > 0 &&
(projVertices[indicePtr[i+2]]).z > 0) {
// 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];
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]]);
if (v_cnt++ >= 2) {
if (!clipped) {
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...)
}
}

39
Engine/Graphics/3DRenderer.hpp
View File

@ -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;
};

7
Engine/Utils/3DMaths.hpp
View File

@ -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;
//

221
Engine/Utils/3DMaths.inl
View File

@ -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
}
/* -------------------------------------------------------------------------------------------------------------------------- */

46
Engine/Utils/MeshHelper.hpp
View File

@ -1,23 +1,49 @@
#pragma once
#include <vector>
#include <SFML/Graphics/Color.hpp>
#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<unsigned int> indices = {};
M3D_F4X4 transform = M3D_MIdentity4x4();
std::vector<MeshPart> subparts;
};
struct Mesh {
std::vector<Vertex> vertices;
std::vector<MeshPart> parts;
};

36
Engine/World/DbgCube.cpp Normal file
View File

@ -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);
}

13
Engine/World/DbgCube.hpp Normal file
View File

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

33
Engine/World/WorldObject.hpp Normal file
View File

@ -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;
};
*/

3
srcs.list
View File

@ -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