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

@@ -1,7 +1,10 @@
 
 ## TODO:
-- make hashmap grid type
+- restructure some entity/render_group stuffs
-	- find a better alternative to g_data_dir in scene_loader.cpp
+	- 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

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

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

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<Hex, hex_info, hex_hashfunc>();
-	// 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++) {
+	for (uint i = 0; i < gs->entity_count; i++)
-		meFreeMeshGroup(gs->entities[i].mesh_group);
+		entFree(gs->entities[i]);
-		rgFree(gs->entities[i].ren_group);
-	}
 
 	utilSafeFree(gs->entities);
 	utilSafeFree(g_render_state);

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);
+	rgInitGLFloatBuffer(&ro_f->vertex_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER);
-	rgBufferData(&ro_f->normal_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER);
+	rgInitGLFloatBuffer(&ro_f->normal_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER);
-	rgBufferData(&ro_f->uv_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER);
+	rgInitGLFloatBuffer(&ro_f->uv_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER);
-	rgBufferData(&ro_l->vertex_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER);
+	rgInitGLFloatBuffer(&ro_l->vertex_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER);
-	rgBufferData(&ro_l->normal_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER);
+	rgInitGLFloatBuffer(&ro_l->normal_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER);
-	rgBufferData(&ro_l->uv_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER);
+	rgInitGLFloatBuffer(&ro_l->uv_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER);
 
 	return true;
 }

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

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

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 rgInitGLIndexBuffer(gl_index_buffer* index_buffer, GLenum usage, GLenum target);
-void sendIndexBufferToGL(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);
-}
-
-

src/render_group.h

@@ -2,13 +2,11 @@
 #pragma once
 
 #include <GL/gl3w.h>
+#include <glm/glm.hpp>
 
-#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,

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);
+	rgInitGLFloatBuffer(&debug_vertex_buf, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER);
-	rgBufferData(&debug_normal_buf, GL_STATIC_DRAW, GL_ARRAY_BUFFER);
+	rgInitGLFloatBuffer(&debug_normal_buf, GL_STATIC_DRAW, GL_ARRAY_BUFFER);
 
 	return true;
 }

src/scene_loader.cpp

@@ -79,12 +79,7 @@ slFreeSceneDoc(slSceneDoc* sd)
 }
 
 bool
-slParseEntities(
+slParseEntities(slSceneDoc* sd,	Entity* entity_array, uint& entity_count, uint max_entities)
-		slSceneDoc* sd,
-		Entity* entity_array,
-		uint& entity_count,
-		uint max_entities,
-		const char* data_dir)
 {
 	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";
+		uint max_len = 256;	// TODO: make define for string property max_len
-			meFreeMeshGroup(mg);
+		std::string model_file_str(entities[i]["model_file"].GetString());
-			return false;
+		utilCopyCStr(e.model_filename,	model_file_str.c_str(), max_len);
-		}
 
 		entity_count++;
 	}

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(
+bool slParseEntities(slSceneDoc* sd, Entity* entity_array, uint& entity_count, uint max_entities);
-		slSceneDoc* sd,
-		Entity* entity_array,
-		uint& entity_count,
-		uint max_entities,
-		const char* data_dir
-	);
 
 void slParseCamera(slSceneDoc* sd, camera& cam);