combine models and texture into new asset structure

src/asset.cpp

@@ -73,12 +73,11 @@ arenaAllocateBlock(memory_arena* arena, size_t block_size)
 
 // forward declarations
 void dumpNodes(tinygltf::Model t_mdl);
-model* initModel(model_assets* assets,
+model* initModel(Assets* assets,
 	memory_arena* arena,
 	tinygltf::Model t_mdl,
 	const char* filename);
 bool parseMeshNode(mesh* m,
-	texture_assets* textures,
 	memory_arena* arena,
 	const tinygltf::Node& node,
 	const tinygltf::Model& t_mdl);
@@ -86,31 +85,8 @@ bool parseMeshNode(mesh* m,
 
 // interface
 
-model_assets*
-assetInitModelBlock(memory_arena* arena, uint asset_count)
-{
-	model_assets* assets =
-		(model_assets*) arenaAllocateBlock(arena, sizeof(model_assets));
-	assets->models =
-		(model*) arenaAllocateBlock(arena, asset_count * sizeof(model));
-	assets->max = asset_count;
-
-	return assets;
-}
-
-texture_assets*
-assetInitTextureBlock(memory_arena* arena, uint asset_count)
-{
-	texture_assets* assets =
-		(texture_assets*) arenaAllocateBlock(arena, sizeof(texture_assets));
-	assets->images = (util_image*) arenaAllocateBlock(
-		arena, asset_count * sizeof(util_image));
-	assets->max = asset_count;
-
-	return assets;
-}
-
 // FIXME: move to internal when finished
+# if 0
 util_image*
 copyDiffuseTexture(texture_assets* textures,
 	memory_arena* arena,
@@ -141,10 +117,10 @@ copyDiffuseTexture(texture_assets* textures,
 
 	return dtex;
 }
+#endif
 
 model*
-assetLoadFromFile(model_assets* assets,
-	texture_assets* textures,
+assetLoadFromFile(Assets* assets,
 	memory_arena* arena,
 	const char* filename)
 {
@@ -180,9 +156,7 @@ assetLoadFromFile(model_assets* assets,
 
 	for (tinygltf::Node node : t_mdl.nodes) {
 		if (node.mesh >= 0) {
-			if (!parseMeshNode(&mdl->meshes[mesh_idx++],
-						textures, arena, node, t_mdl))
-			{
+			if (!parseMeshNode(&mdl->meshes[mesh_idx++], arena, node, t_mdl)) {
 				LOG(Error) << "Error parsing node\n";
 				return nullptr;
 			}
@@ -193,9 +167,9 @@ assetLoadFromFile(model_assets* assets,
 }
 
 model*
-assetGetCached(model_assets* assets, uint64_t path_hash)
+assetGetCached(Assets* assets, uint64_t path_hash)
 {
-	for (uint i = 0; i < assets->count; i++) {
+	for (uint i = 0; i < assets->num_models; i++) {
 		if (assets->models[i].filepath_hash == path_hash)
 			return &assets->models[i];
 	}
@@ -208,15 +182,15 @@ assetGetCached(model_assets* assets, uint64_t path_hash)
 // internal
 
 model*
-initModel(model_assets* assets,
+initModel(Assets* assets,
 	memory_arena* arena,
 	tinygltf::Model t_mdl,
 	const char* filename)
 {
 	// TODO: re-alloc array when out of space
-	assert(assets->count < assets->max && arena != nullptr);
-	model* mdl = &assets->models[assets->count];
-	assets->count++;
+	assert(assets->num_models < assets->max_models && arena != nullptr);
+	model* mdl = &assets->models[assets->num_models];
+	assets->num_models++;
 
 	uint buf_count = t_mdl.bufferViews.size();
 	mdl->meshes = (mesh*) arenaAllocateBlock(arena, buf_count * sizeof(mesh));
@@ -296,7 +270,6 @@ parseNodeTransform(memory_arena* arena, const tinygltf::Node* node)
 
 bool
 parseMeshNode(mesh* m,
-	texture_assets* textures,
 	memory_arena* arena,
 	const tinygltf::Node& node,
 	const tinygltf::Model& t_mdl)

src/asset.h

@@ -78,34 +78,23 @@ struct model
 	util_image* diffuse_texture;
 };
 
-struct model_assets
+struct Assets
 {
+	u32 num_models;
+	u32 max_models;
 	model* models;
-	uint count;
-	uint max;
-};
 
-struct texture_assets
-{
-	util_image* images;
-	uint count;
-	uint max;
+	u32 num_textures;
+	u32 max_textures;
+	util_image* textures;
 };
 
 
-// TODO: would be nice to make these init functions generic
-model_assets*
-assetInitModelBlock(memory_arena* arena, uint asset_count);
-
-texture_assets*
-assetInitTextureBlock(memory_arena* arena, uint asset_count);
-
 model*
-assetLoadFromFile(model_assets* assets,
-	texture_assets* textures,
+assetLoadFromFile(Assets* assets,
 	memory_arena* arena,
 	const char* filename);
 
 model*
-assetGetCached(model_assets* assets, u64 path_hash);
+assetGetCached(Assets* assets, u64 path_hash);
 

src/main.cpp

@@ -22,14 +22,12 @@ struct SDLHandles
 struct RenderState
 {
 	memory_arena* arena;
-	// FIXME: revert back to num_/max_(models|textures)
-	model_assets* assets;
-	texture_assets* textures;
-
 	transforms* xforms; // NOTE: would be part of camera in libTangerine
 	SDLHandles* handles;
 	GLContext* gl_ctx;
 
+	Assets* assets;
+
 	u32 num_gl_meshes;
 	u32 max_gl_meshes;
 	GLmesh* gl_meshes;
@@ -102,7 +100,7 @@ getModel(RenderState* rs, const char* filepath)
 	model* mdl = assetGetCached(rs->assets, utilFNV64a_str(filepath));
 
 	if (!mdl)
-		mdl = assetLoadFromFile(rs->assets, rs->textures, rs->arena, filepath);
+		mdl = assetLoadFromFile(rs->assets, rs->arena, filepath);
 
 	return mdl;
 }
@@ -137,6 +135,25 @@ initGLContext(memory_arena* arena)
 	return gl_ctx;
 }
 
+#define DEFAULT_MODEL_COUNT 256
+#define DEFAULT_TEXTURE_COUNT 64
+Assets*
+initAssets(memory_arena* arena,
+	u32 num_models = DEFAULT_MODEL_COUNT,
+	u32 num_textures = DEFAULT_TEXTURE_COUNT)
+{
+	Assets* assets = (Assets*) arenaAllocateBlock(arena, sizeof(Assets));
+	assets->max_models = num_models;
+	assets->models = (model*) arenaAllocateBlock(
+		arena, num_models * sizeof(model));
+
+	assets->max_textures = num_textures;
+	assets->textures = (util_image*) arenaAllocateBlock(
+		arena, num_textures * sizeof(util_image));
+
+	return assets;
+}
+
 RenderState*
 initRenderState(memory_arena* arena)
 {
@@ -145,8 +162,7 @@ initRenderState(memory_arena* arena)
 
 	if (rs) {
 		rs->arena = arena;
-		rs->assets = assetInitModelBlock(arena, 256);
-		rs->textures = assetInitTextureBlock(arena, 256);
+		rs->assets = initAssets(arena);
 		rs->gl_ctx = initGLContext(arena);
 		rs->xforms =
 			(transforms*) arenaAllocateBlock(arena, sizeof(transforms));
@@ -226,15 +242,29 @@ loadScene(RenderState* rs)
 		glm::vec3( 10, -10,  0),
 	};
 
-	// TODO: full lighting model
-	//model* tex_cube = getModel(rs, "data/textured_cube.gltf");
-
 	// TODO: load debug shader from libTangerine for textured_cube
 	shader_program* s = getShaderByName("default", rs->gl_ctx);
 
 	if (!s)
 		return false;
 
+	// TODO: full lighting model
+	model* tex_cube = getModel(rs, "../data/textured_cube.gltf");
+	assert(tex_cube != nullptr && tex_cube->num_meshes > 0);
+	GLmesh* texmesh = getFreeGLMesh(rs);
+
+	if (texmesh) {
+		*texmesh = loadGLMesh(s, tex_cube->meshes[0],
+					GL_TRIANGLES, glm::vec3(0, 0, 0));
+		*texmesh->model_xform = glm::mat4(1.f);
+
+		if (texmesh->vao_id == 0)
+			return false;
+
+	} else {
+		return false;
+	}
+
 	for (u32 i = 0; i < NUM_CUBES; i++) {
 		GLmesh* gmesh = getFreeGLMesh(rs);