rename memory_arena struct to MemoryArena

src/asset.cpp

@@ -12,14 +12,14 @@
 // forward declarations
 void dumpNodes(tinygltf::Model t_mdl);
 model* initModel(Assets* assets,
-	memory_arena* arena,
+	MemoryArena* arena,
 	tinygltf::Model t_mdl,
 	const char* filename);
 util_image* copyDiffuseTexture(Assets* assets,
-	memory_arena* arena,
+	MemoryArena* arena,
 	const tinygltf::Model& t_mdl);
 bool parseMeshNode(mesh* m,
-	memory_arena* arena,
+	MemoryArena* arena,
 	const tinygltf::Node& node,
 	const tinygltf::Model& t_mdl);
 
@@ -28,7 +28,7 @@ bool parseMeshNode(mesh* m,
 
 model*
 assetLoadFromFile(Assets* assets,
-	memory_arena* arena,
+	MemoryArena* arena,
 	const char* filename)
 {
 	tinygltf::Model t_mdl;
@@ -88,7 +88,7 @@ assetGetCachedModel(Assets* assets, uint64_t path_hash)
 
 model*
 initModel(Assets* assets,
-	memory_arena* arena,
+	MemoryArena* arena,
 	tinygltf::Model t_mdl,
 	const char* filename)
 {
@@ -108,7 +108,7 @@ initModel(Assets* assets,
 
 bool
 copyBuffer(uint8_t*& buffer_ref,
-	memory_arena* arena,
+	MemoryArena* arena,
 	int acc_idx,
 	const tinygltf::Model& t_mdl)
 {
@@ -138,7 +138,7 @@ copyBuffer(uint8_t*& buffer_ref,
 
 // FIXME: need to implement tree structure for blender models to work properly
 glm::mat4*
-parseNodeTransform(memory_arena* arena, const tinygltf::Node* node)
+parseNodeTransform(MemoryArena* arena, const tinygltf::Node* node)
 {
 	if (node->rotation.size() == 4
 		&& node->scale.size() == 3
@@ -171,7 +171,7 @@ parseNodeTransform(memory_arena* arena, const tinygltf::Node* node)
 
 bool
 parseMeshNode(mesh* m,
-	memory_arena* arena,
+	MemoryArena* arena,
 	const tinygltf::Node& node,
 	const tinygltf::Model& t_mdl)
 {
@@ -227,7 +227,7 @@ getFreeTexture(Assets* assets)
 
 util_image*
 copyDiffuseTexture(Assets* assets,
-	memory_arena* arena,
+	MemoryArena* arena,
 	const tinygltf::Model& t_mdl)
 {
 	// NOTE: assuming material[0] since we're using pallete texture

src/asset.h

@@ -59,9 +59,7 @@ struct Assets
 
 
 model*
-assetLoadFromFile(Assets* assets,
-	memory_arena* arena,
-	const char* filename);
+assetLoadFromFile(Assets* assets, MemoryArena* arena, const char* filename);
 
 model*
 assetGetCachedModel(Assets* assets, u64 path_hash);

src/main.cpp

@@ -49,10 +49,10 @@ struct RenderState
 	SDLHandles* handles;
 	GLContext* gl_ctx;
 
-	memory_arena* asset_arena;
+	MemoryArena* asset_arena;
 	Assets* assets;
 
-	memory_arena* rg_arena;
+	MemoryArena* rg_arena;
 	u32 num_render_groups;
 	u32 max_render_groups;
 	RenderGroup* render_groups;
@@ -66,7 +66,7 @@ struct RenderState
 #define DEFAULT_ENTITY_COUNT 256
 void
 initRenderGroup(RenderGroup* rg,
-		memory_arena* arena,
+		MemoryArena* arena,
 		shader_program* shader,
 		u32 num_entities = DEFAULT_ENTITY_COUNT,
 		const char* name = "")
@@ -78,7 +78,7 @@ initRenderGroup(RenderGroup* rg,
 }
 
 void
-freeRenderGroup(RenderGroup* rg, memory_arena* arena)
+freeRenderGroup(RenderGroup* rg, MemoryArena* arena)
 {
 	printf("%s(), should probably look into freeing arena memory?\n",
 			__FUNCTION__);
@@ -97,7 +97,7 @@ getFreeEntity(RenderGroup* rg)
 
 bool
 initEntity(Entity* e,
-	memory_arena* arena,
+	MemoryArena* arena,
 	model* mdl,
 	u32 num_attrib_mappings,
 	GLBufferToAttribMapping* attrib_mappings,
@@ -160,7 +160,7 @@ getFreeRenderGroup(RenderState* rs)
 #define DEFAULT_MODEL_COUNT 256
 #define DEFAULT_TEXTURE_COUNT 64
 Assets*
-initAssets(memory_arena* arena,
+initAssets(MemoryArena* arena,
 	u32 num_models = DEFAULT_MODEL_COUNT,
 	u32 num_textures = DEFAULT_TEXTURE_COUNT)
 {
@@ -175,7 +175,7 @@ initAssets(memory_arena* arena,
 #define DEFAULT_SHADER_COUNT 64
 #define DEFAULT_UBO_COUNT 32
 GLContext*
-initGLContext(memory_arena* arena)
+initGLContext(MemoryArena* arena)
 {
 	GLContext* gl_ctx = ARENA_ALLOC(arena, GLContext, 1);
 	gl_ctx->max_shaders = DEFAULT_SHADER_COUNT;

src/shader.cpp

@@ -19,7 +19,7 @@
 // NOTE: forward declarations
 
 const std::string dumpTextFile(const char* filepath);
-bool parseShader(memory_arena* arena, GLContext* gl_ctx, shader_program* s);
+bool parseShader(MemoryArena* arena, GLContext* gl_ctx, shader_program* s);
 void initCTXSizes(GLContext* gl_ctx);
 bool compileAndLinkShader(shader_program* shader,
 	const char* vert_src,
@@ -55,7 +55,7 @@ getShaderByHash(GLContext* gl_ctx, u64 hash)
 }
 
 bool
-addShaderProgram(memory_arena* arena,
+addShaderProgram(MemoryArena* arena,
 	GLContext* gl_ctx,
 	const char* vs,
 	const char* fs,
@@ -144,7 +144,7 @@ renderVAO(GLmesh* glmesh, glm::mat4* model_xform, shader_program* shader)
 }
 
 void
-initTransforms(memory_arena* arena,
+initTransforms(MemoryArena* arena,
 	transforms* xforms,
 	gl_buffer* xform_ubo,
 	GLContext* gl_ctx,
@@ -354,7 +354,7 @@ getGLTypeSizeStd140(GLenum e)
 }
 
 const gl_uniform
-parseUniform(memory_arena* arena, shader_program* s, u32 uniform_idx)
+parseUniform(MemoryArena* arena, shader_program* s, u32 uniform_idx)
 {
 	gl_uniform unif = {0};
 	GLchar unif_name[256] = {0};
@@ -378,7 +378,7 @@ parseUniform(memory_arena* arena, shader_program* s, u32 uniform_idx)
 }
 
 bool
-parseShaderUniforms(memory_arena* arena, shader_program* s, GLContext* gl_ctx)
+parseShaderUniforms(MemoryArena* arena, shader_program* s, GLContext* gl_ctx)
 {
 	// NOTE: only add uniforms in the default block to the base uniform array
 	GLint num_uniforms_total = 0;
@@ -417,6 +417,7 @@ initCTXSizes(GLContext* gl_ctx)
 		glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_BLOCKS,
 				&gl_ctx->max_fragment_blocks);
 		glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &gl_ctx->max_ublock_size);
+		glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &gl_ctx->max_vertex_attribs);
 
 #if 1
 		printf("%s(), context size info set\n", __FUNCTION__);
@@ -451,7 +452,7 @@ ctxGetUniformBlockBinding(GLContext* gl_ctx, const char* name)
 }
 
 bool
-parseUniformBlocks(memory_arena* arena, shader_program* s, GLContext* gl_ctx)
+parseUniformBlocks(MemoryArena* arena, shader_program* s, GLContext* gl_ctx)
 {
 	glGetProgramiv(s->prog_id, GL_ACTIVE_UNIFORM_BLOCKS,
 			(GLint*) &s->num_blocks);
@@ -516,7 +517,7 @@ getAttribComponentType(GLenum type)
 }
 
 bool
-parseAttributes(memory_arena* arena, shader_program* s, GLContext* gl_ctx)
+parseAttributes(MemoryArena* arena, shader_program* s, GLContext* gl_ctx)
 {
 	GLint num_attribs;
 	glGetProgramiv(s->prog_id, GL_ACTIVE_ATTRIBUTES, &num_attribs);
@@ -546,7 +547,7 @@ parseAttributes(memory_arena* arena, shader_program* s, GLContext* gl_ctx)
 }
 
 bool
-parseShader(memory_arena* arena, GLContext* gl_ctx, shader_program* s)
+parseShader(MemoryArena* arena, GLContext* gl_ctx, shader_program* s)
 {
 	if (parseShaderUniforms(arena, s, gl_ctx)
 		&& parseUniformBlocks(arena, s, gl_ctx)

src/shader.h

@@ -151,7 +151,7 @@ const glm::vec3 DEFAULT_LOOK_POS = { 0, 0, 0 };
 // NOTE: every shader program is assumed to have one uniform block named
 // 	"matrices" that contains the projection and view matrices, and one uniform
 // 	named "model_xform" for the model matrix
-bool addShaderProgram(memory_arena* arena,
+bool addShaderProgram(MemoryArena* arena,
 	GLContext* gl_ctx,
 	const char* vs,
 	const char* fs,
@@ -167,7 +167,7 @@ GLmesh loadGLMesh(const mesh& m,
 	const glm::vec3& pos,
 	u32 num_mappings,
 	GLBufferToAttribMapping mappings[]);
-void initTransforms(memory_arena* arena,
+void initTransforms(MemoryArena* arena,
 	transforms* xforms,
 	gl_buffer* xform_ubo,
 	GLContext* gl_ctx,

src/util.h

@@ -19,7 +19,7 @@ u64 utilFNV64a_str(const char *str, u64 hval = FNV1_64_INIT);
 //-----------------
 // Memory allocation
 
-struct memory_arena
+struct MemoryArena
 {
 	size_t max_size;
 	void* head;
@@ -27,17 +27,17 @@ struct memory_arena
 };
 
 #define DEFAULT_ARENA_SIZE 10 * 1024 * 1024 // 10MB
-memory_arena* arenaInit(size_t initial_size = DEFAULT_ARENA_SIZE);
+MemoryArena* arenaInit(size_t initial_size = DEFAULT_ARENA_SIZE);
 
-void arenaFree(memory_arena*& arena);
-uint arenaGetFreeSize(memory_arena* arena);
+void arenaFree(MemoryArena*& arena);
+uint arenaGetFreeSize(MemoryArena* arena);
 
 #define ARENA_ALLOC(arena, type, count) \
 	(type*) arenaAllocateBlock(arena, sizeof(type) * count)
-void* arenaAllocateBlock(memory_arena* arena, size_t block_size);
+void* arenaAllocateBlock(MemoryArena* arena, size_t block_size);
 
 #define MAX_NAME_LENGTH 256
-char* arenaCopyCStr(memory_arena* arena,
+char* arenaCopyCStr(MemoryArena* arena,
 	const char* input,
 	u32 max_len = MAX_NAME_LENGTH);
 
@@ -73,19 +73,19 @@ utilFNV64a_str(const char* str, uint64_t hval)
 //-----------------
 // Memory allocation
 
-memory_arena*
+MemoryArena*
 arenaInit(size_t initial_size)
 {
-	uint sz = sizeof(memory_arena);
-	memory_arena* arena =
-		(memory_arena*) std::calloc(initial_size + sz, sizeof(u8));
+	uint sz = sizeof(MemoryArena);
+	MemoryArena* arena =
+		(MemoryArena*) std::calloc(initial_size + sz, sizeof(u8));
 	arena->head = arena->next_free = (uint8_t*) arena + sz;
 	arena->max_size = initial_size;
 	return arena;
 }
 
 void
-arenaFree(memory_arena*& arena)
+arenaFree(MemoryArena*& arena)
 {
 	if (arena != nullptr) {
 		std::free(arena);
@@ -94,7 +94,7 @@ arenaFree(memory_arena*& arena)
 }
 
 uint
-arenaGetFreeSize(memory_arena* arena)
+arenaGetFreeSize(MemoryArena* arena)
 {
 	return (uint8_t*) arena->head
 		+ arena->max_size
@@ -102,7 +102,7 @@ arenaGetFreeSize(memory_arena* arena)
 }
 
 void*
-arenaAllocateBlock(memory_arena* arena, size_t block_size)
+arenaAllocateBlock(MemoryArena* arena, size_t block_size)
 {
 	// TODO: resizable memory arena
 	assert(arenaGetFreeSize(arena) >= block_size);
@@ -113,7 +113,7 @@ arenaAllocateBlock(memory_arena* arena, size_t block_size)
 }
 
 char*
-arenaCopyCStr(memory_arena* arena, const char* input, u32 max_len)
+arenaCopyCStr(MemoryArena* arena, const char* input, u32 max_len)
 {
 	u32 name_len = std::strlen(input) + 1;
 	assert(name_len < max_len);