From 0ba74753e621eade79bab0aa3876d26752fb91bc Mon Sep 17 00:00:00 2001 From: cinnaboot Date: Wed, 23 Jan 2019 21:10:20 -0500 Subject: [PATCH] consolidate entity initialization into new entity.cpp file also restructured render_group interface a bit to remove cyclic dependancy with entity and render_group --- TODO.md | 8 +- src/entity.cpp | 139 +++++++++++++++++++++++++++++ src/entity.h | 18 ++-- src/hexgame.cpp | 16 ++-- src/hexgrid.cpp | 12 +-- src/mesh.cpp | 2 +- src/mesh.h | 2 +- src/render_group.cpp | 205 +++++++++---------------------------------- src/render_group.h | 12 +-- src/renderer.cpp | 10 +-- src/scene_loader.cpp | 28 ++---- src/scene_loader.h | 8 +- 12 files changed, 236 insertions(+), 224 deletions(-) create mode 100644 src/entity.cpp diff --git a/TODO.md b/TODO.md index 5f15cda..ff71ea6 100644 --- a/TODO.md +++ b/TODO.md @@ -1,7 +1,10 @@ ## TODO: -- make hashmap grid type - - find a better alternative to g_data_dir in scene_loader.cpp +- restructure some entity/render_group stuffs + - add interface to render_group for glBindBuffer->glBufferSubData? + - hexgrid.cpp then wouldn't need to call gl functions directly +- init HexGrid render groups in hgInit and remove slCreateHexRenderGroups +- remove renCreateScene, and put initDebug renderGroup somewhere - position entities on grid hexes - pathfinding - assimp animation @@ -38,6 +41,7 @@ - use a storage pool for assimp meshes allowing reuse across entities - also cache textures from loaded meshes for re-use - remove v2i/v3f... etc from util.h and either use glm everywhere, or write a smaller linear math.h +- find a better alternative to g_data_dir in scene_loader.cpp ## LATER TODO: - add initial opengl constant for INT_MAX, and checks in render_group functions diff --git a/src/entity.cpp b/src/entity.cpp new file mode 100644 index 0000000..6eccbcc --- /dev/null +++ b/src/entity.cpp @@ -0,0 +1,139 @@ + +#include "aixlog.hpp" + +#include "entity.h" + + +bool convertMeshInfo(meMeshInfo* mesh, render_object* ro, bool use_normals, bool use_texture); + + +bool +entInit(Entity& e, const char* data_dir, rg_shader_program& shader) +{ + uint max_len = 256; // TODO: define max_len for property strings + char full_path[max_len]; + if (utilConcatPath(full_path, data_dir, e.model_filename, max_len)) { + if (meLoadFromFile(e.mesh_group, data_dir, full_path)) { + // initialize the entity's render group + render_group* rg = UTIL_ALLOC(1, render_group); + e.ren_group = rg; + e.ren_group->shader = shader; + rg->draw_indexed = true; + rg->draw_mode = GL_TRIANGLES; + rg->use_normals = e.mesh_group.use_normals; + uint num_meshes = rg->num_objects = e.mesh_group.num_meshes; + rg->render_objects = UTIL_ALLOC(num_meshes, render_object*); + + // apply translation/rotation/scaling + e.world_transform = glm::mat4(1.0); + entTranslate(e, e.translation); + entScale(e, e.scale); + + for (uint i = 0; i < num_meshes; i++) + { + meMeshInfo* mesh = e.mesh_group.meshes[i]; + uint buffer_len = mesh->num_vertices * 3; + uint index_len = mesh->num_indices; + + render_object* ro = rgAllocateRenderObject(buffer_len, index_len); + rg->render_objects[i] = ro; + + if (ro == nullptr) + return false; + + if (!convertMeshInfo(mesh, ro, rg->use_normals, mesh->use_texture)) { + rgFree(rg); + return false; + } + + if (mesh->use_texture) { + ro->use_texture = true; + if (!rgInitGLTexture(ro->tex_id, mesh->diffuse_texture)) { + LOG(ERROR) << "Error initializing GL texture\n"; + return false; + } + } + } + } else { + meFreeMeshGroup(e.mesh_group); + return false; + } + } else { + LOG(ERROR) << data_dir << " + " << e.model_filename << " is too long\n"; + return false; + } + + return true; +} + +void +entFree(Entity& e) +{ + meFreeMeshGroup(e.mesh_group); + rgFree(e.ren_group); +} + +bool +convertMeshInfo(meMeshInfo* mesh, render_object* ro, bool use_normals, bool use_texture) +{ + uint vertex_buf_len = mesh->num_vertices * 3; + GLfloat* vertex_buf = ro->vertex_buffer.buffer; + GLfloat* normal_buf = ro->normal_buffer.buffer; + GLfloat* uv_buf = ro->uv_buffer.buffer; + uint* index_buf = ro->index_buffer.buffer; + + if (!vertex_buf || !normal_buf || !index_buf) + return false; + + // dump vertices, colors, normals, and texture coords into render_group buffers + uint vertex_index = 0; + uint vertex_prop_index = 0; + + for (uint i = 0; i < vertex_buf_len; i++) { + const glm::vec3& vertex = mesh->vertices[vertex_index]; + + switch (vertex_prop_index) { + case 0: vertex_buf[i] = vertex.x; break; + case 1: vertex_buf[i] = vertex.y; break; + case 2: vertex_buf[i] = vertex.z; break; + } + + if (use_normals) { + const glm::vec3& normal = mesh->normals[vertex_index]; + switch (vertex_prop_index) { + case 0: normal_buf[i] = normal.x; break; + case 1: normal_buf[i] = normal.y; break; + case 2: normal_buf[i] = normal.z; break; + } + } + + if (use_texture) { + const glm::vec3& uv = mesh->texture_coords[vertex_index]; + switch (vertex_prop_index) { + case 0: uv_buf[i] = uv.x; break; + case 1: uv_buf[i] = uv.y; break; + case 2: uv_buf[i] = uv.z; break; + } + } + + vertex_prop_index++; + + if (vertex_prop_index == 3) { + vertex_prop_index = 0; + vertex_index++; + } + } + + // dump indices + for (uint i = 0; i < mesh->num_indices; i++) + index_buf[i] = mesh->indices[i]; + + rgInitGLFloatBuffer(&ro->vertex_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER); + if (use_normals) + rgInitGLFloatBuffer(&ro->normal_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER); + if (use_texture) + rgInitGLFloatBuffer(&ro->uv_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER); + rgInitGLIndexBuffer(&ro->index_buffer, GL_STATIC_DRAW, GL_ELEMENT_ARRAY_BUFFER); + + return true; +} diff --git a/src/entity.h b/src/entity.h index 8948968..7632f36 100644 --- a/src/entity.h +++ b/src/entity.h @@ -8,26 +8,30 @@ #include "render_group.h" -struct render_group; - struct Entity { glm::mat4 world_transform; glm::vec3 scale; glm::vec3 translation; - glm::vec4 rotation; // maybe use quaternion for this one + glm::vec4 rotation; meMeshGroup mesh_group; render_group* ren_group; + + char model_filename[256]; }; +bool entInit(Entity& e, const char* data_dir, rg_shader_program& shader); + +void entFree(Entity& e); + inline void -entityTranslate(Entity* e, int x, int y, int z) +entTranslate(Entity& e, glm::vec3 v) { - e->world_transform = glm::translate(e->world_transform, glm::vec3(x, y, z)); + e.world_transform = glm::translate(e.world_transform, v); } inline void -entityScale(Entity* e, float sx, float sy, float sz) +entScale(Entity& e, glm::vec3 v) { - //mi->model_transform = glm::scale(glm::mat4(1), glm::vec3(100, 100, 100)); + e.world_transform = glm::scale(e.world_transform, v); } diff --git a/src/hexgame.cpp b/src/hexgame.cpp index 9646dac..86e7749 100644 --- a/src/hexgame.cpp +++ b/src/hexgame.cpp @@ -54,7 +54,14 @@ loadSceneFromJson(game_state* s, render_state* rs) game_state* gs = g_game_state; render_state* rs = g_render_state; - if (!slParseEntities(sd, gs->entities, gs->entity_count, MAX_ENTITIES, DATA_DIR)) { + if (slParseEntities(sd, gs->entities, gs->entity_count, MAX_ENTITIES)) { + for (uint i = 0; i < gs->entity_count; i++) { + if (!entInit(gs->entities[i], DATA_DIR, rs->default_shader)) { + LOG(ERROR) << "Error initilaizing entity\n"; + return false; + } + } + } else { LOG(ERROR) << "Error loading Entities, exiting\n"; ret = false; } @@ -96,7 +103,6 @@ init() // TODO: I think this is necessary because we're using calloc to initialize gamestate // which contains the hashtable. g_game_state->grid.hex_map = std::unordered_map(); - // NOTE: testing hex_add g_game_state->grid.draw_mode = NONE; // TODO: maybe add this as an option to scene json? g_game_state->grid.normal = v3f(0.f, 0.f, 1.f); @@ -352,10 +358,8 @@ cleanUp(SDL_Handles &handles) game_state* gs = g_game_state; - for (uint i = 0; i < gs->entity_count; i++) { - meFreeMeshGroup(gs->entities[i].mesh_group); - rgFree(gs->entities[i].ren_group); - } + for (uint i = 0; i < gs->entity_count; i++) + entFree(gs->entities[i]); utilSafeFree(gs->entities); utilSafeFree(g_render_state); diff --git a/src/hexgrid.cpp b/src/hexgrid.cpp index 1d2fa3d..7dd28fc 100644 --- a/src/hexgrid.cpp +++ b/src/hexgrid.cpp @@ -51,12 +51,12 @@ hgInit(hexgrid& hg, render_group* rg_filled, render_group* rg_lines) } // send buffers to GL - rgBufferData(&ro_f->vertex_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER); - rgBufferData(&ro_f->normal_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER); - rgBufferData(&ro_f->uv_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER); - rgBufferData(&ro_l->vertex_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER); - rgBufferData(&ro_l->normal_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER); - rgBufferData(&ro_l->uv_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER); + rgInitGLFloatBuffer(&ro_f->vertex_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER); + rgInitGLFloatBuffer(&ro_f->normal_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER); + rgInitGLFloatBuffer(&ro_f->uv_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER); + rgInitGLFloatBuffer(&ro_l->vertex_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER); + rgInitGLFloatBuffer(&ro_l->normal_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER); + rgInitGLFloatBuffer(&ro_l->uv_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER); return true; } diff --git a/src/mesh.cpp b/src/mesh.cpp index 7c49e3c..00763d7 100644 --- a/src/mesh.cpp +++ b/src/mesh.cpp @@ -34,7 +34,7 @@ meInitAssimp() } bool -meLoadFromFile(const char* data_dir, const char* filename, meMeshGroup& mesh_group) +meLoadFromFile(meMeshGroup& mesh_group, const char* data_dir, const char* filename) { LOG(INFO) << "Loading file: " << filename << "\n"; const aiScene* scene = aiImportFile(filename, aiProcessPreset_TargetRealtime_MaxQuality); diff --git a/src/mesh.h b/src/mesh.h index 4775974..dde1486 100644 --- a/src/mesh.h +++ b/src/mesh.h @@ -35,7 +35,7 @@ struct meMeshGroup bool meInitAssimp(); -bool meLoadFromFile(const char* data_dir, const char* filename, meMeshGroup& mesh_group); +bool meLoadFromFile(meMeshGroup& mesh_group, const char* data_dir, const char* filename); void meFreeMeshGroup(meMeshGroup& mesh_group); diff --git a/src/render_group.cpp b/src/render_group.cpp index b2c0b38..76b3118 100644 --- a/src/render_group.cpp +++ b/src/render_group.cpp @@ -9,7 +9,6 @@ #include "aixlog.hpp" #include "render_group.h" -#include "mesh.h" #include "util.h" #define INFO_LOG_MAX_LENGTH 312 @@ -17,14 +16,43 @@ // forward declarations -render_object * allocateRenderObject(uint buffer_len, uint index_len = 0); void freeRenderObject(render_object* ro); -bool convertMeshInfo(meMeshInfo* mesh, render_object* ro, bool use_normals, bool use_texture); -void sendIndexBufferToGL(gl_index_buffer* index_buffer, GLenum usage, GLenum target); +void rgInitGLIndexBuffer(gl_index_buffer* index_buffer, GLenum usage, GLenum target); // interface +render_object * +rgAllocateRenderObject(uint buffer_len, uint index_len) +{ + render_object* ro = UTIL_ALLOC(1, render_object); + + if (ro == nullptr) + return nullptr; + + ro->vertex_buffer.buffer = UTIL_ALLOC(buffer_len, GLfloat); + ro->vertex_buffer.count = ro->vertex_buffer.max_count = buffer_len; + ro->normal_buffer.buffer = UTIL_ALLOC(buffer_len, GLfloat); + ro->normal_buffer.count = ro->normal_buffer.max_count = buffer_len; + ro->uv_buffer.buffer = UTIL_ALLOC(buffer_len, GLfloat); + ro->uv_buffer.count = ro->uv_buffer.max_count = buffer_len; + + if (index_len > 0) { + ro->index_buffer.buffer = UTIL_ALLOC(index_len, uint); + ro->index_buffer.count = index_len; + } + + if (ro->vertex_buffer.buffer == nullptr || + ro->normal_buffer.buffer == nullptr || + ((index_len > 0) && (ro->vertex_buffer.buffer == nullptr))) + { + freeRenderObject(ro); + return nullptr; + } + + return ro; +} + render_group* rgInitSingle(rg_shader_program& sp, uint vertex_buffer_len, bool use_normals, uint index_buffer_len, @@ -37,7 +65,7 @@ rgInitSingle(rg_shader_program& sp, uint vertex_buffer_len, rg->draw_mode = draw_mode; rg->render_objects = UTIL_ALLOC(1, render_object*); - rg->render_objects[0] = allocateRenderObject(vertex_buffer_len, index_buffer_len); + rg->render_objects[0] = rgAllocateRenderObject(vertex_buffer_len, index_buffer_len); rg->num_objects = 1; if (rg->render_objects[0] == nullptr) { @@ -115,63 +143,22 @@ rgInitGLTexture(GLuint& tex_id, util_image image) return (glGetError() == GL_NO_ERROR); } -// TODO: move Entity initialization to Entity.h/.cpp to fix circular dependancy -// then just call into convertMeshInfo directly -bool -rgInitEntity(Entity* e) -{ - render_group* rg = UTIL_ALLOC(1, render_group); - e->ren_group = rg; - rg->draw_indexed = true; - rg->draw_mode = GL_TRIANGLES; - rg->use_normals = e->mesh_group.use_normals; - uint num_meshes = rg->num_objects = e->mesh_group.num_meshes; - rg->render_objects = UTIL_ALLOC(num_meshes, render_object*); - - // apply translation/rotation/scaling - e->world_transform = glm::mat4(1.0); - e->world_transform = glm::translate(e->world_transform, e->translation); - e->world_transform = glm::scale(e->world_transform, e->scale); - - for (uint i = 0; i < num_meshes; i++) - { - meMeshInfo* mesh = e->mesh_group.meshes[i]; - uint buffer_len = mesh->num_vertices * 3; - uint index_len = mesh->num_indices; - rg->render_objects[i] = allocateRenderObject(buffer_len, index_len); - render_object* ro = rg->render_objects[i]; - - if (ro == nullptr) - return false; - - if (!convertMeshInfo(mesh, ro, rg->use_normals, mesh->use_texture)) { - rgFree(rg); - return false; - } - - if (mesh->use_texture) { - ro->use_texture = true; - if (!rgInitGLTexture(ro->tex_id, mesh->diffuse_texture)) { - LOG(ERROR) << "Error initializing GL texture\n"; - return false; - } - } - } - - return true; -} - -// TODO: this should be called more like, rgInitGLBuffer() -// NOTE: could also make internal by adding more utility function for eg) -// initHexGrid(), initDebugDraw()... void -rgBufferData(gl_buffer* buffer, GLenum usage, GLenum target) +rgInitGLFloatBuffer(gl_buffer* buffer, GLenum usage, GLenum target) { glGenBuffers(1, &buffer->buffer_id); glBindBuffer(target, buffer->buffer_id); glBufferData(target, buffer->max_count * sizeof(GLfloat), buffer->buffer, usage); } +void +rgInitGLIndexBuffer(gl_index_buffer* index_buffer, GLenum usage, GLenum target) +{ + glGenBuffers(1, &index_buffer->buffer_id); + glBindBuffer(target, index_buffer->buffer_id); + glBufferData(target, index_buffer->count * sizeof(uint), index_buffer->buffer, usage); +} + void rgDraw(render_group* rg, glm::mat4 model_matrix, glm::mat4 view_matrix, glm::mat4 projection_matrix, @@ -266,37 +253,6 @@ rgFree(render_group* rg) // internal -render_object * -allocateRenderObject(uint buffer_len, uint index_len) -{ - render_object* ro = UTIL_ALLOC(1, render_object); - - if (ro == nullptr) - return nullptr; - - ro->vertex_buffer.buffer = UTIL_ALLOC(buffer_len, GLfloat); - ro->vertex_buffer.count = ro->vertex_buffer.max_count = buffer_len; - ro->normal_buffer.buffer = UTIL_ALLOC(buffer_len, GLfloat); - ro->normal_buffer.count = ro->normal_buffer.max_count = buffer_len; - ro->uv_buffer.buffer = UTIL_ALLOC(buffer_len, GLfloat); - ro->uv_buffer.count = ro->uv_buffer.max_count = buffer_len; - - if (index_len > 0) { - ro->index_buffer.buffer = UTIL_ALLOC(index_len, uint); - ro->index_buffer.count = index_len; - } - - if (ro->vertex_buffer.buffer == nullptr || - ro->normal_buffer.buffer == nullptr || - ((index_len > 0) && (ro->vertex_buffer.buffer == nullptr))) - { - freeRenderObject(ro); - return nullptr; - } - - return ro; -} - void freeRenderObject(render_object* ro) { @@ -312,80 +268,3 @@ freeRenderObject(render_object* ro) utilSafeFree(ro->index_buffer.buffer); utilSafeFree(ro); } - -// TODO: might as well move this to mesh.cpp and use render_group commands there -// since we're doing the same with hexgrid now -bool -convertMeshInfo(meMeshInfo* mesh, render_object* ro, bool use_normals, bool use_texture) -{ - uint vertex_buf_len = mesh->num_vertices * 3; - GLfloat* vertex_buf = ro->vertex_buffer.buffer; - GLfloat* normal_buf = ro->normal_buffer.buffer; - GLfloat* uv_buf = ro->uv_buffer.buffer; - uint* index_buf = ro->index_buffer.buffer; - - if (!vertex_buf || !normal_buf || !index_buf) - return false; - - // dump vertices, colors, normals, and texture coords into render_group buffers - uint vertex_index = 0; - uint vertex_prop_index = 0; - - for (uint i = 0; i < vertex_buf_len; i++) { - const glm::vec3& vertex = mesh->vertices[vertex_index]; - - switch (vertex_prop_index) { - case 0: vertex_buf[i] = vertex.x; break; - case 1: vertex_buf[i] = vertex.y; break; - case 2: vertex_buf[i] = vertex.z; break; - } - - if (use_normals) { - const glm::vec3& normal = mesh->normals[vertex_index]; - switch (vertex_prop_index) { - case 0: normal_buf[i] = normal.x; break; - case 1: normal_buf[i] = normal.y; break; - case 2: normal_buf[i] = normal.z; break; - } - } - - if (use_texture) { - const glm::vec3& uv = mesh->texture_coords[vertex_index]; - switch (vertex_prop_index) { - case 0: uv_buf[i] = uv.x; break; - case 1: uv_buf[i] = uv.y; break; - case 2: uv_buf[i] = uv.z; break; - } - } - - vertex_prop_index++; - - if (vertex_prop_index == 3) { - vertex_prop_index = 0; - vertex_index++; - } - } - - // dump indices - for (uint i = 0; i < mesh->num_indices; i++) - index_buf[i] = mesh->indices[i]; - - rgBufferData(&ro->vertex_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER); - if (use_normals) - rgBufferData(&ro->normal_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER); - if (use_texture) - rgBufferData(&ro->uv_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER); - sendIndexBufferToGL(&ro->index_buffer, GL_STATIC_DRAW, GL_ELEMENT_ARRAY_BUFFER); - - return true; -} - -void -sendIndexBufferToGL(gl_index_buffer* index_buffer, GLenum usage, GLenum target) -{ - glGenBuffers(1, &index_buffer->buffer_id); - glBindBuffer(target, index_buffer->buffer_id); - glBufferData(target, index_buffer->count * sizeof(uint), index_buffer->buffer, usage); -} - - diff --git a/src/render_group.h b/src/render_group.h index 6e5df42..7cb08d1 100644 --- a/src/render_group.h +++ b/src/render_group.h @@ -2,13 +2,11 @@ #pragma once #include +#include -#include "entity.h" #include "util.h" -struct Entity; - // TODO: can these structs be used as opaque pointers? struct gl_buffer { @@ -71,6 +69,8 @@ struct rg_point_light float intensity; }; +render_object * rgAllocateRenderObject(uint buffer_len, uint index_len = 0); + // NOTE: initializes a render_group with 1 render_object allocated render_group* rgInitSingle(rg_shader_program& sp, uint vertex_buffer_len, bool use_normals = false, uint index_buffer_len = 0, @@ -78,11 +78,11 @@ render_group* rgInitSingle(rg_shader_program& sp, uint vertex_buffer_len, bool rgInitShaderProgram(rg_shader_program& sp, const char * vertex_code, const char * frag_code); -bool rgInitEntity(Entity* e); - bool rgInitGLTexture(GLuint& tex_id, util_image image); -void rgBufferData(gl_buffer* buffer, GLenum usage, GLenum target); +void rgInitGLFloatBuffer(gl_buffer* buffer, GLenum usage, GLenum target); + +void rgInitGLIndexBuffer(gl_index_buffer* index_buffer, GLenum usage, GLenum target); void rgDraw(render_group* rg, glm::mat4 model_matrix, glm::mat4 view_matrix, glm::mat4 projection_matrix, diff --git a/src/renderer.cpp b/src/renderer.cpp index eac32c6..2573ca2 100644 --- a/src/renderer.cpp +++ b/src/renderer.cpp @@ -13,7 +13,7 @@ #include "aixlog.hpp" -#include "hexlib.h" +//#include "hexlib.h" #include "renderer.h" #define DEFAULT_VERTEX_SHADER_FILE "../data/default.vs" @@ -151,12 +151,12 @@ bool renCreateScene(render_state* rs, Entity* entities, uint32 entity_count) { // entities - +#if 0 for (uint i = 0; i < entity_count; i++) { rgInitEntity(&entities[i]); entities[i].ren_group->shader = rs->default_shader; } - +#endif // debug draw vertices uint debug_buf_len = 12; // 4 vertices, 3 floats per vertex @@ -174,8 +174,8 @@ renCreateScene(render_state* rs, Entity* entities, uint32 entity_count) debug_normal_buf.buffer[i + 2] = 1.f; } - rgBufferData(&debug_vertex_buf, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER); - rgBufferData(&debug_normal_buf, GL_STATIC_DRAW, GL_ARRAY_BUFFER); + rgInitGLFloatBuffer(&debug_vertex_buf, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER); + rgInitGLFloatBuffer(&debug_normal_buf, GL_STATIC_DRAW, GL_ARRAY_BUFFER); return true; } diff --git a/src/scene_loader.cpp b/src/scene_loader.cpp index 7f9f10a..35a29c9 100644 --- a/src/scene_loader.cpp +++ b/src/scene_loader.cpp @@ -79,12 +79,7 @@ slFreeSceneDoc(slSceneDoc* sd) } bool -slParseEntities( - slSceneDoc* sd, - Entity* entity_array, - uint& entity_count, - uint max_entities, - const char* data_dir) +slParseEntities(slSceneDoc* sd, Entity* entity_array, uint& entity_count, uint max_entities) { const rapidjson::Value& entities = (*sd->doc)["entities"]; if (entities.Size() > max_entities) { @@ -94,20 +89,13 @@ slParseEntities( } for (uint i = 0; i < entities.Size(); i++) { - meMeshGroup mg; - std::string model_path; - model_path.append(data_dir).append("/").append(entities[i]["model_file"].GetString()); - - if (meLoadFromFile(data_dir, model_path.c_str(), mg)) { - Entity& e = entity_array[i]; - e.mesh_group = mg; - e.scale = parseVec3(entities[i]["scale"]); - e.translation = parseVec3(entities[i]["position"]); - } else { - LOG(ERROR) << "Error loading mesh file\n"; - meFreeMeshGroup(mg); - return false; - } + Entity& e = entity_array[i]; + e.scale = parseVec3(entities[i]["scale"]); + e.translation = parseVec3(entities[i]["position"]); + + uint max_len = 256; // TODO: make define for string property max_len + std::string model_file_str(entities[i]["model_file"].GetString()); + utilCopyCStr(e.model_filename, model_file_str.c_str(), max_len); entity_count++; } diff --git a/src/scene_loader.h b/src/scene_loader.h index d84560e..7442d6c 100644 --- a/src/scene_loader.h +++ b/src/scene_loader.h @@ -15,13 +15,7 @@ slSceneDoc* slLoadFile(const char* data_dir, const char* scene_file, const char* void slFreeSceneDoc(slSceneDoc* sd); -bool slParseEntities( - slSceneDoc* sd, - Entity* entity_array, - uint& entity_count, - uint max_entities, - const char* data_dir - ); +bool slParseEntities(slSceneDoc* sd, Entity* entity_array, uint& entity_count, uint max_entities); void slParseCamera(slSceneDoc* sd, camera& cam);