replace instances of arenaAllocateBlock() with macro

src/asset.cpp

@@ -119,7 +119,7 @@ copyDiffuseTexture(texture_assets* textures,
 	dtex->bits_per_channel = t_img.bits;
 	dtex->num_channels = t_img.component;
 	dtex->data_len = t_img.image.size();
-	dtex->pixels = (u8*) arenaAllocateBlock(arena, dtex->data_len);
+	dtex->pixels = ARENA_ALLOC(arena, u8, dtex->data_len);
 	// FIXME: overwriting memory here... also fix in libTangerine
 	std::strncpy(dtex->file_path, t_img.uri.c_str(), t_img.uri.size());
 	dtex->filepath_hash = utilFNV64a_str(t_img.uri.c_str());
@@ -203,7 +203,7 @@ initModel(Assets* assets,
 	assets->num_models++;
 
 	uint buf_count = t_mdl.bufferViews.size();
-	mdl->meshes = (mesh*) arenaAllocateBlock(arena, buf_count * sizeof(mesh));
+	mdl->meshes = ARENA_ALLOC(arena, mesh, buf_count);
 	mdl->num_meshes = t_mdl.meshes.size();
 	mdl->filepath = arenaCopyCStr(arena, filename, MAX_PATH_SIZE);
 	mdl->filepath_hash = utilFNV64a_str(mdl->filepath);
@@ -235,7 +235,7 @@ copyBuffer(uint8_t*& buffer_ref,
 	}
 
 	assert(bv.byteStride == 0);
-	buffer_ref = (uint8_t*) arenaAllocateBlock(arena, bv.byteLength);
+	buffer_ref = ARENA_ALLOC(arena, u8, bv.byteLength);
 	std::memcpy(buffer_ref, &t_buf.data[bv.byteOffset], bv.byteLength);
 
 	return buffer_ref != nullptr;
@@ -249,8 +249,7 @@ parseNodeTransform(memory_arena* arena, const tinygltf::Node* node)
 		&& node->scale.size() == 3
 		&& node->translation.size() == 3)
 	{
-		glm::mat4* xform =
-			(glm::mat4*) arenaAllocateBlock(arena, sizeof(glm::mat4));
+		glm::mat4* xform = ARENA_ALLOC(arena, glm::mat4, 1);
 		*xform = glm::mat4(1.0f);
 		*xform = glm::rotate(*xform, (float) node->rotation[3],
 			glm::vec3((float) node->rotation[0],
@@ -301,7 +300,7 @@ parseMeshNode(mesh* m,
 	m->usage = GL_STATIC_DRAW; // TODO: logic for updating dynamic meshes
 	// FIXME: the node transforms from blender only work as part of a node tree
 #if 1
-	m->xform = (glm::mat4*) arenaAllocateBlock(arena, sizeof(glm::mat4));
+	m->xform = ARENA_ALLOC(arena, glm::mat4, 1);
 	*m->xform = glm::mat4(1.0f);
 #else
 	m->xform = parseNodeTransform(arena, &node);

src/main.cpp

@@ -121,16 +121,13 @@ getFreeGLMesh(RenderState* rs)
 GLContext*
 initGLContext(memory_arena* arena)
 {
-	GLContext* gl_ctx =
-		(GLContext*) arenaAllocateBlock(arena, sizeof(GLContext));
+	GLContext* gl_ctx = ARENA_ALLOC(arena, GLContext, 1);
 	gl_ctx->max_shaders = DEFAULT_SHADER_COUNT;
 	gl_ctx->num_shaders = 0;
-	gl_ctx->shaders = (shader_program*) arenaAllocateBlock(
-		arena, DEFAULT_SHADER_COUNT * sizeof(shader_program));
+	gl_ctx->shaders = ARENA_ALLOC(arena, shader_program, DEFAULT_SHADER_COUNT);
 	gl_ctx->max_ubos = DEFAULT_UBO_COUNT;
 	gl_ctx->num_ubos = 0;
-	gl_ctx->uniform_buffers = (gl_buffer*) arenaAllocateBlock(arena,
-		gl_ctx->max_ubos * sizeof(gl_buffer));
+	gl_ctx->uniform_buffers = ARENA_ALLOC(arena, gl_buffer, gl_ctx->max_ubos);
 	gl_ctx->binding_count = 0;
 
 	return gl_ctx;
@@ -143,35 +140,27 @@ initAssets(memory_arena* arena,
 	u32 num_models = DEFAULT_MODEL_COUNT,
 	u32 num_textures = DEFAULT_TEXTURE_COUNT)
 {
-	Assets* assets = (Assets*) arenaAllocateBlock(arena, sizeof(Assets));
+	Assets* assets = ARENA_ALLOC(arena, Assets, 1);
 	assets->max_models = num_models;
-	assets->models = (model*) arenaAllocateBlock(
-		arena, num_models * sizeof(model));
-
+	assets->models = ARENA_ALLOC(arena, model, num_models);
 	assets->max_textures = num_textures;
-	assets->textures = (util_image*) arenaAllocateBlock(
-		arena, num_textures * sizeof(util_image));
-
+	assets->textures = ARENA_ALLOC(arena, util_image, num_textures);
 	return assets;
 }
 
 RenderState*
 initRenderState(memory_arena* arena)
 {
-	RenderState* rs =
-		(RenderState*) arenaAllocateBlock(arena, sizeof(RenderState));
+	RenderState* rs = ARENA_ALLOC(arena, RenderState, 1);
 
 	if (rs) {
 		rs->arena = arena;
 		rs->assets = initAssets(arena);
 		rs->gl_ctx = initGLContext(arena);
-		rs->xforms =
-			(transforms*) arenaAllocateBlock(arena, sizeof(transforms));
-		rs->handles =
-			(SDLHandles*) arenaAllocateBlock(arena, sizeof(SDLHandles));
+		rs->xforms = ARENA_ALLOC(arena, transforms, 1);
+		rs->handles = ARENA_ALLOC(arena, SDLHandles, 1);
 		rs->max_gl_meshes = 256;
-		rs->gl_meshes = (GLmesh*) arenaAllocateBlock(
-			arena, rs->max_gl_meshes * sizeof(GLmesh));
+		rs->gl_meshes = ARENA_ALLOC(arena, GLmesh, rs->max_gl_meshes);
 	}
 
 	return rs;

src/shader.cpp

@@ -200,8 +200,7 @@ parseShaderUniforms(memory_arena* arena, shader_program* s, GLContext* gl_ctx)
 		}
 	}
 
-	s->uniforms = (gl_uniform*) arenaAllocateBlock(
-			arena, s->num_uniforms * sizeof(gl_uniform));
+	s->uniforms = ARENA_ALLOC(arena, gl_uniform, s->num_uniforms);
 
 	for (u32 i = 0; i < s->num_uniforms; i++) {
 		const gl_uniform unif = parseUniform(arena, s, indices[i]);
@@ -230,8 +229,7 @@ parseUniformBlocks(memory_arena* arena, shader_program* s, GLContext* gl_ctx)
 {
 	glGetProgramiv(s->prog_id, GL_ACTIVE_UNIFORM_BLOCKS,
 			(GLint*) &s->num_blocks);
-	s->uniform_blocks = (GLUniformBlock*) arenaAllocateBlock(arena,
-			s->num_blocks * sizeof(GLUniformBlock));
+	s->uniform_blocks = ARENA_ALLOC(arena, GLUniformBlock, s->num_blocks);
 
 	for (u32 i = 0; i < s->num_blocks; i++) {
 		GLUniformBlock& ub = s->uniform_blocks[i];
@@ -245,8 +243,7 @@ parseUniformBlocks(memory_arena* arena, shader_program* s, GLContext* gl_ctx)
 
 		glGetActiveUniformBlockiv(s->prog_id, i,
 				GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, (GLint*) &ub.num_uniforms);
-		ub.uniforms = (gl_uniform*)
-			arenaAllocateBlock(arena, ub.num_uniforms * sizeof(gl_uniform));
+		ub.uniforms = ARENA_ALLOC(arena, gl_uniform, ub.num_uniforms);
 		GLint indices[ub.num_uniforms] = {0};
 		glGetActiveUniformBlockiv(s->prog_id, i,
 				GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, (GLint*) &indices);