Norbert's Game Engine v200
Loading...
Searching...
No Matches
eMesh Class Reference

#include <Mesh.hpp>

Inheritance diagram for eMesh:
eBase

Public Member Functions

void ShouldOptimize (const bool vl)
 Whether or not the mesh should be optimized using meshoptimizer.
 
bool IsOptimized ()
 
std::vector< eMeshContainer > & GetContainers ()
 
void Load (eString fileName)
 
void LoadMem (eString &mem)
 
void DrawContainer (uint id, eLayer *layer, eTransformation3D transformation, eMaterial *mat=nullptr)
 
void Draw (eLayer *layer, eTransformation3D transformation, eMaterial *mat=nullptr)
 
const int DrawInstances (eLayer *layer, std::vector< eTransformation3D > &transformations, eMaterial *mat=nullptr)
 
void DrawInstances (eLayer *layer, eIDB &idb, eMaterial *mat=nullptr)
 
const int DrawContainerInstances (uint id, eLayer *layer, std::vector< eTransformation3D > &transformations, eMaterial *mat=nullptr)
 
void DrawContainerInstances (uint id, eLayer *layer, eIDB &idb, eMaterial *mat=nullptr)
 
void SetDrawFnc (std::function< eShader *(eMeshContainer &, eLayer *, eTransformation3D, eMaterial *)> fnc)
 
- Public Member Functions inherited from eBase
template<typename T >
T * Cast (eBase *obj)
 Cast class to base.
 

Static Public Member Functions

static void InitIDB (std::vector< eTransformation3D > &transformations, eIDB &idb)
 
static void SetRenderer (eRenderer *renderer)
 
static eRenderer * GetRenderer ()
 

Protected Member Functions

void ProcessNode (aiNode *node, const aiScene *scene)
 
eMeshContainer ProcessMesh (aiMesh *mesh, const aiScene *scene)
 
eMeshContainer CreateMesh (std::vector< eMeshVertex > vertices, std::vector< uint16 > indices)
 
bool DrawSingleBegin (eMeshContainer &container, eLayer *layer, eTransformation3D transformation, eMaterial *mat)
 
void DrawSingleEnd (eShader *shader, eMeshContainer &container, eLayer *layer)
 
void DrawInsEnd (eMeshContainer &container, eTransformation3D &first, eLayer *layer, eMaterial *mat, bgfx::InstanceDataBuffer &idb)
 

Static Protected Member Functions

static const int DrawInsBegin (std::vector< eTransformation3D > &transformations, bgfx::InstanceDataBuffer &idb)
 

Protected Attributes

std::vector< eMeshContainer > mSubMeshes
 
bool bOptimize = true
 
std::function< eShader *(eMeshContainer &, eLayer *, eTransformation3D, eMaterial *)> mDrawFnc
 

Static Protected Attributes

static eRenderer * mRenderer = nullptr
 Public pointer to renderer.
 

Detailed Description

Mesh class for loading and rendering 3D geometry

Definition at line 20 of file Mesh.hpp.

Constructor & Destructor Documentation

◆ ~eMesh()

eMesh::~eMesh ( )

Definition at line 12 of file Mesh.cpp.

13{
14 for (auto& it : mSubMeshes)
15 {
16 it.mVertices.clear();
17 it.mIndices.clear();
18 eGraphics::Destroy(it.mVbh);
19 eGraphics::Destroy(it.mIbh);
20 }
21 mSubMeshes.clear();
22}

Member Function Documentation

◆ CreateMesh()

eMeshContainer eMesh::CreateMesh ( std::vector< eMeshVertex > vertices,
std::vector< uint16 > indices )
protected

Definition at line 154 of file Mesh.cpp.

155{
156 //Meshoptimizer code
157 std::vector<eMeshVertex> _rt_vertices = vertices;
158 std::vector<uint16> _rt_indices = indices;
159
160 if (bOptimize)
161 {
162 meshopt_optimizeVertexCache(&_rt_indices[0], &_rt_indices[0], _rt_indices.size(), _rt_vertices.size());
163 meshopt_optimizeVertexFetch(&_rt_vertices[0], &_rt_indices[0], _rt_indices.size(), &_rt_vertices[0], _rt_vertices.size(), sizeof(eMeshVertex));
164 }
165
166 eMeshContainer rtVl;
167 rtVl.mVertices = _rt_vertices;
168 rtVl.mIndices = _rt_indices;
169
170 eVertexLayout vlayout;
171 vlayout.begin()
172 .add(bgfx::Attrib::Position, 3, bgfx::AttribType::Float)
173 .add(bgfx::Attrib::Normal, 3, bgfx::AttribType::Float)
174 .add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float)
175 .add(bgfx::Attrib::Tangent, 3, bgfx::AttribType::Float)
176 .add(bgfx::Attrib::Bitangent, 3, bgfx::AttribType::Float)
177 .end();
178
179 rtVl.mVbh = eShader::CreateVertexBuffer(&vertices[0], vertices.size() * sizeof(eMeshVertex), vlayout);
180 if (!bgfx::isValid(rtVl.mVbh))
181 {
182 eConsole::PrintLog("eMesh::CreateMesh", "Failed to create vbh.");
184 return {};
185 }
186
187 rtVl.mIbh = eShader::CreateIndexBuffer(&indices[0], indices.size() * sizeof(uint16));
188 if (!bgfx::isValid(rtVl.mIbh))
189 {
190 eConsole::PrintLog("eMesh::CreateMesh", "Failed to create ibh.");
192 return {};
193 }
194 return rtVl;
195}
static void WriteToDisk()
Write the console text to a crash file called 'CRASH.log'.
Definition Console.cpp:40
static void PrintLog(eString head, eString msg)
Print a log.
Definition Console.cpp:22

◆ Draw()

void eMesh::Draw ( eLayer * layer,
eTransformation3D transformation,
eMaterial * mat = nullptr )

Definition at line 214 of file Mesh.cpp.

215{
216 for (auto& it : mSubMeshes)
217 {
218 if (!DrawSingleBegin(it, layer, transformation, mat))
219 continue;
220 eShader* shader = mDrawFnc(it, layer, transformation, mat);
221 DrawSingleEnd(shader, it, layer);
222 }
223}

◆ DrawContainer()

void eMesh::DrawContainer ( uint id,
eLayer * layer,
eTransformation3D transformation,
eMaterial * mat = nullptr )

Definition at line 204 of file Mesh.cpp.

205{
206 eMeshContainer& container = mSubMeshes[id];
207 if (!DrawSingleBegin(container, layer, transformation, mat))
208 return;
209 eShader* shader = mDrawFnc(container, layer, transformation, mat);
210 DrawSingleEnd(shader, container, layer);
211}

◆ DrawContainerInstances() [1/2]

void eMesh::DrawContainerInstances ( uint id,
eLayer * layer,
eIDB & idb,
eMaterial * mat = nullptr )

Definition at line 309 of file Mesh.cpp.

310{
311 eViewport3D* viewport = layer->GetViewport();
312 if (viewport == nullptr) return;
313
314 eMeshContainer& cont = mSubMeshes[id];
315
316 eMaterial* useMat = cont.mMat;
317
318 eTransformation3D empt = {};
319
320 bool noMat = true;
321 if (mat != nullptr)
322 {
323 noMat = false;
324 useMat = mat;
325 }
326 else if (cont.mMat != nullptr)
327 noMat = false;
328
329 if (!noMat)
330 DrawInsEnd(cont, empt, layer, useMat, idb.mBuffer);
331}

◆ DrawContainerInstances() [2/2]

const int eMesh::DrawContainerInstances ( uint id,
eLayer * layer,
std::vector< eTransformation3D > & transformations,
eMaterial * mat = nullptr )

Definition at line 281 of file Mesh.cpp.

282{
283 eViewport3D* viewport = layer->GetViewport();
284 if (viewport == nullptr) return -1;
285
286 bgfx::InstanceDataBuffer idb;
287 const int rtVl = DrawInsBegin(transformations, idb);
288
289 eMeshContainer& cont = mSubMeshes[id];
290
291 eMaterial* useMat = cont.mMat;
292
293 bool noMat = true;
294 if (mat != nullptr)
295 {
296 noMat = false;
297 useMat = mat;
298 }
299 else if (cont.mMat != nullptr)
300 noMat = false;
301
302 if (!noMat)
303 DrawInsEnd(cont, transformations[0], layer, useMat, idb);
304
305 return rtVl;
306}

◆ DrawInsBegin()

const int eMesh::DrawInsBegin ( std::vector< eTransformation3D > & transformations,
bgfx::InstanceDataBuffer & idb )
staticprotected

Definition at line 334 of file Mesh.cpp.

335{
336 const int insCnt = transformations.size();
337 const uint16 insStride = 64;
338 uint32 drawnIns = bgfx::getAvailInstanceDataBuffer(insCnt, insStride);
339
340 const int couldNotDraw = insCnt - drawnIns;
341
342 bgfx::allocInstanceDataBuffer(&idb, drawnIns, insStride);
343
344 uint8* data = idb.data;
345
346 for (uint32 i = 0; i < drawnIns; i++)
347 {
348 const mat4 mtx = eTools::Transform(transformations[i]);
349 const float* _mtx = eMath::value_ptr(mtx);
350 memcpy(data, _mtx, insStride);
351 data += insStride;
352 }
353
354 return couldNotDraw;
355}

◆ DrawInsEnd()

void eMesh::DrawInsEnd ( eMeshContainer & container,
eTransformation3D & first,
eLayer * layer,
eMaterial * mat,
bgfx::InstanceDataBuffer & idb )
protected

Definition at line 358 of file Mesh.cpp.

359{
360 eShader* shader = mDrawFnc(container, layer, first, mat);
361
362 shader->ApplyVertexBuffer(0, container.mVbh);
363 shader->ApplyIndexBuffer(container.mIbh);
364
365 bgfx::setInstanceDataBuffer(&idb);
366
367 eMaterialPrp* matPrp = mat->GetProperties();
368 if (matPrp->bTwoSides)
369 {
370 eGraphics::SetState(BGFX_STATE_BLEND_ALPHA
371 | BGFX_STATE_WRITE_RGB
372 | BGFX_STATE_WRITE_A
373 | BGFX_STATE_WRITE_Z
374 | BGFX_STATE_DEPTH_TEST_LESS
375 | BGFX_STATE_MSAA);
376 }
377 else
378 eGraphics::SetState();
379
380 shader->Submit(layer->GetProperties().mViewId, false);
381}

◆ DrawInstances() [1/2]

void eMesh::DrawInstances ( eLayer * layer,
eIDB & idb,
eMaterial * mat = nullptr )

Definition at line 255 of file Mesh.cpp.

256{
257 eViewport3D* viewport = layer->GetViewport();
258 if (viewport == nullptr) return;
259
260 eTransformation3D empt = {};
261
262 for (auto& it : mSubMeshes)
263 {
264 eMaterial* useMat = it.mMat;
265
266 bool noMat = true;
267 if (mat != nullptr)
268 {
269 noMat = false;
270 useMat = mat;
271 }
272 else if (it.mMat != nullptr)
273 noMat = false;
274
275 if (!noMat)
276 DrawInsEnd(it, empt, layer, useMat, idb.mBuffer);
277 }
278}

◆ DrawInstances() [2/2]

const int eMesh::DrawInstances ( eLayer * layer,
std::vector< eTransformation3D > & transformations,
eMaterial * mat = nullptr )

Definition at line 226 of file Mesh.cpp.

227{
228 eViewport3D* viewport = layer->GetViewport();
229 if (viewport == nullptr) return -1;
230
231 bgfx::InstanceDataBuffer idb;
232 const int rtVl = DrawInsBegin(transformations, idb);
233
234 for (auto& it : mSubMeshes)
235 {
236 eMaterial* useMat = it.mMat;
237
238 bool noMat = true;
239 if (mat != nullptr)
240 {
241 noMat = false;
242 useMat = mat;
243 }
244 else if (it.mMat != nullptr)
245 noMat = false;
246
247 if(!noMat)
248 DrawInsEnd(it, transformations[0], layer, useMat, idb);
249 }
250
251 return rtVl;
252}

◆ DrawSingleBegin()

bool eMesh::DrawSingleBegin ( eMeshContainer & container,
eLayer * layer,
eTransformation3D transformation,
eMaterial * mat )
protected

Definition at line 390 of file Mesh.cpp.

391{
392 eViewport3D* viewport = layer->GetViewport();
393 if (viewport == nullptr)
394 return false;
395
396 eMaterial* useMat = container.mMat;
397
398 bool noMat = true;
399 if (mat != nullptr)
400 {
401 noMat = false;
402 useMat = mat;
403 }
404 else if (container.mMat != nullptr)
405 noMat = false;
406
407 eMaterialPrp* matPrp = useMat->GetProperties();
408
409 if (matPrp->bTwoSides)
410 {
411 eGraphics::SetState(BGFX_STATE_BLEND_ALPHA
412 | BGFX_STATE_WRITE_RGB
413 | BGFX_STATE_WRITE_A
414 | BGFX_STATE_WRITE_Z
415 | BGFX_STATE_DEPTH_TEST_LESS
416 | BGFX_STATE_MSAA);
417 }
418 else
419 eGraphics::SetState();
420
421 mat4 mdl = eTools::Transform(transformation);
422 bgfx::setTransform(eMath::value_ptr(mdl));
423
424 return !noMat;
425}

◆ DrawSingleEnd()

void eMesh::DrawSingleEnd ( eShader * shader,
eMeshContainer & container,
eLayer * layer )
protected

Definition at line 428 of file Mesh.cpp.

429{
430 shader->ApplyVertexBuffer(0, container.mVbh);
431 shader->ApplyIndexBuffer(container.mIbh);
432 shader->Submit(layer->GetProperties().mViewId, false);
433}

◆ GetContainers()

std::vector< eMeshContainer > & eMesh::GetContainers ( )

Definition at line 37 of file Mesh.cpp.

38{
39 return mSubMeshes;
40}

◆ GetRenderer()

eRenderer * eMesh::GetRenderer ( )
static

Definition at line 441 of file Mesh.cpp.

442{
443 return mRenderer;
444}
static eRenderer * mRenderer
Public pointer to renderer.
Definition Mesh.hpp:49

◆ InitIDB()

void eMesh::InitIDB ( std::vector< eTransformation3D > & transformations,
eIDB & idb )
static

Definition at line 198 of file Mesh.cpp.

199{
200 idb.mCouldNotDraw = DrawInsBegin(transformations, idb.mBuffer);
201}

◆ IsOptimized()

bool eMesh::IsOptimized ( )

Definition at line 31 of file Mesh.cpp.

32{
33 return bOptimize;
34}

◆ Load()

void eMesh::Load ( eString fileName)

Definition at line 43 of file Mesh.cpp.

44{
45 Assimp::Importer importer;
46 uint flags = aiProcess_FlipUVs
47 | aiProcess_Triangulate
48 | aiProcess_GenSmoothNormals
49 | aiProcess_CalcTangentSpace
50 | aiProcess_SplitLargeMeshes
51 | aiProcess_OptimizeMeshes;
52
53 const aiScene* scene = importer.ReadFile(fileName.Get(), flags);
54
55 if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
56 {
57 eConsole::PrintLog("eMesh::Load", "Failed to load model at '" + fileName.GetStrg() + "'!");
59 return;
60 }
61
62 ProcessNode(scene->mRootNode, scene);
63}
const strg & GetStrg() const
Return text as std::string.
Definition String.cpp:70
const char * Get()
Return text as c-string.
Definition String.cpp:64

◆ LoadMem()

void eMesh::LoadMem ( eString & mem)

Definition at line 66 of file Mesh.cpp.

67{
68 Assimp::Importer importer;
69 uint flags = aiProcess_FlipUVs
70 | aiProcess_Triangulate
71 | aiProcess_GenSmoothNormals
72 | aiProcess_CalcTangentSpace
73 | aiProcess_SplitLargeMeshes
74 | aiProcess_OptimizeMeshes;
75
76 const aiScene* scene = importer.ReadFileFromMemory(mem.GetStrg().data(), mem.Lenght(), flags);
77
78 if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
79 {
80 eConsole::PrintLog("eMesh::LoadMem", "Failed to load model from memory!");
82 return;
83 }
84
85 ProcessNode(scene->mRootNode, scene);
86}
uint64 Lenght()
Returns text lenght.
Definition String.cpp:95

◆ ProcessMesh()

eMeshContainer eMesh::ProcessMesh ( aiMesh * mesh,
const aiScene * scene )
protected

Definition at line 102 of file Mesh.cpp.

103{
104 std::vector<eMeshVertex> vertices;
105 std::vector<uint16> indices;
106
107 for (uint i = 0; i < mesh->mNumVertices; i++)
108 {
109 eMeshVertex vertex;
110
111 vertex.x = mesh->mVertices[i].x;
112 vertex.y = mesh->mVertices[i].y;
113 vertex.z = mesh->mVertices[i].z;
114
115 if (mesh->HasNormals())
116 {
117 vertex.nx = mesh->mNormals[i].x;
118 vertex.ny = mesh->mNormals[i].y;
119 vertex.nz = mesh->mNormals[i].z;
120 }
121
122 if (mesh->mTextureCoords[0])
123 {
124 vertex.u = mesh->mTextureCoords[0][i].x;
125 vertex.v = mesh->mTextureCoords[0][i].y;
126
127 vertex.tx = mesh->mTangents[i].x;
128 vertex.ty = mesh->mTangents[i].y;
129 vertex.tz = mesh->mTangents[i].z;
130
131 vertex.bx = mesh->mBitangents[i].x;
132 vertex.by = mesh->mBitangents[i].y;
133 vertex.bz = mesh->mBitangents[i].z;
134 }
135 else
136 {
137 vertex.u = 0.0f;
138 vertex.v = 0.0f;
139 }
140 vertices.push_back(vertex);
141 }
142
143 for (uint i = 0; i < mesh->mNumFaces; i++)
144 {
145 aiFace face = mesh->mFaces[i];
146 for (uint j = 0; j < face.mNumIndices; j++)
147 indices.push_back(face.mIndices[j]);
148 }
149
150 return CreateMesh(vertices, indices);
151}

◆ ProcessNode()

void eMesh::ProcessNode ( aiNode * node,
const aiScene * scene )
protected

Definition at line 89 of file Mesh.cpp.

90{
91 for (uint i = 0; i < node->mNumMeshes; i++)
92 {
93 aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
94 mSubMeshes.push_back(ProcessMesh(mesh, scene));
95 }
96
97 for (uint i = 0; i < node->mNumChildren; i++)
98 ProcessNode(node->mChildren[i], scene);
99}

◆ SetDrawFnc()

void eMesh::SetDrawFnc ( std::function< eShader *(eMeshContainer &, eLayer *, eTransformation3D, eMaterial *)> fnc)

Definition at line 384 of file Mesh.cpp.

385{
386 mDrawFnc = fnc;
387}

◆ SetRenderer()

void eMesh::SetRenderer ( eRenderer * renderer)
static

Definition at line 435 of file Mesh.cpp.

436{
437 mRenderer = renderer;
438}

◆ ShouldOptimize()

void eMesh::ShouldOptimize ( const bool vl)

Whether or not the mesh should be optimized using meshoptimizer.

Definition at line 25 of file Mesh.cpp.

26{
27 bOptimize = vl;
28}

Member Data Documentation

◆ bOptimize

bool eMesh::bOptimize = true
protected

Definition at line 47 of file Mesh.hpp.

◆ mDrawFnc

std::function<eShader*(eMeshContainer&, eLayer*, eTransformation3D, eMaterial*)> eMesh::mDrawFnc
protected

Definition at line 48 of file Mesh.hpp.

◆ mRenderer

eRenderer * eMesh::mRenderer = nullptr
staticprotected

Public pointer to renderer.

Definition at line 49 of file Mesh.hpp.

◆ mSubMeshes

std::vector<eMeshContainer> eMesh::mSubMeshes
protected

Definition at line 46 of file Mesh.hpp.


The documentation for this class was generated from the following files: