GWN: Port to GPU module: Replace GWN prefix by GPU

2018-07-18 00:12:21 +02:00
parent 247ad2034d
commit 8cd7828792
196 changed files with 4664 additions and 4694 deletions
--- a/source/blender/gpu/intern/gpu_batch.c
+++ b/source/blender/gpu/intern/gpu_batch.c
@@ -23,10 +23,10 @@
 * ***** END GPL LICENSE BLOCK *****
 */

-/** \file blender/gpu/intern/gwn_batch.c
+/** \file blender/gpu/intern/gpu_batch.c
 *  \ingroup gpu
 *
- * Gawain geometry batch
+ * GPU geometry batch
 * Contains VAOs + VBOs + Shader representing a drawable entity.
 */

@@ -44,9 +44,9 @@
 #include <stdlib.h>
 #include <string.h>

-static void batch_update_program_bindings(Gwn_Batch* batch, uint v_first);
+static void batch_update_program_bindings(GPUBatch* batch, uint v_first);

-void gwn_batch_vao_cache_clear(Gwn_Batch* batch)
+void GPU_batch_vao_cache_clear(GPUBatch* batch)
 {
 	if (batch->context == NULL) {
 		return;
@@ -54,45 +54,45 @@ void gwn_batch_vao_cache_clear(Gwn_Batch* batch)
 	if (batch->is_dynamic_vao_count) {
 		for (int i = 0; i < batch->dynamic_vaos.count; ++i) {
 			if (batch->dynamic_vaos.vao_ids[i]) {
-				GWN_vao_free(batch->dynamic_vaos.vao_ids[i], batch->context);
+				GPU_vao_free(batch->dynamic_vaos.vao_ids[i], batch->context);
 			}
 			if (batch->dynamic_vaos.interfaces[i]) {
-				GWN_shaderinterface_remove_batch_ref((Gwn_ShaderInterface *)batch->dynamic_vaos.interfaces[i], batch);
+				GPU_shaderinterface_remove_batch_ref((GPUShaderInterface *)batch->dynamic_vaos.interfaces[i], batch);
 			}
 		}
 		free(batch->dynamic_vaos.interfaces);
 		free(batch->dynamic_vaos.vao_ids);
 	}
 	else {
-		for (int i = 0; i < GWN_BATCH_VAO_STATIC_LEN; ++i) {
+		for (int i = 0; i < GPU_BATCH_VAO_STATIC_LEN; ++i) {
 			if (batch->static_vaos.vao_ids[i]) {
-				GWN_vao_free(batch->static_vaos.vao_ids[i], batch->context);
+				GPU_vao_free(batch->static_vaos.vao_ids[i], batch->context);
 			}
 			if (batch->static_vaos.interfaces[i]) {
-				GWN_shaderinterface_remove_batch_ref((Gwn_ShaderInterface *)batch->static_vaos.interfaces[i], batch);
+				GPU_shaderinterface_remove_batch_ref((GPUShaderInterface *)batch->static_vaos.interfaces[i], batch);
 			}
 		}
 	}
 	batch->is_dynamic_vao_count = false;
-	for (int i = 0; i < GWN_BATCH_VAO_STATIC_LEN; ++i) {
+	for (int i = 0; i < GPU_BATCH_VAO_STATIC_LEN; ++i) {
 		batch->static_vaos.vao_ids[i] = 0;
 		batch->static_vaos.interfaces[i] = NULL;
 	}
-	gwn_context_remove_batch(batch->context, batch);
+	gpu_context_remove_batch(batch->context, batch);
 	batch->context = NULL;
 }

-Gwn_Batch* GWN_batch_create_ex(
-        Gwn_PrimType prim_type, Gwn_VertBuf* verts, Gwn_IndexBuf* elem,
+GPUBatch* GPU_batch_create_ex(
+        GPUPrimType prim_type, GPUVertBuf* verts, GPUIndexBuf* elem,
        uint owns_flag)
 {
-	Gwn_Batch* batch = calloc(1, sizeof(Gwn_Batch));
-	GWN_batch_init_ex(batch, prim_type, verts, elem, owns_flag);
+	GPUBatch* batch = calloc(1, sizeof(GPUBatch));
+	GPU_batch_init_ex(batch, prim_type, verts, elem, owns_flag);
 	return batch;
 }

-void GWN_batch_init_ex(
-        Gwn_Batch* batch, Gwn_PrimType prim_type, Gwn_VertBuf* verts, Gwn_IndexBuf* elem,
+void GPU_batch_init_ex(
+        GPUBatch* batch, GPUPrimType prim_type, GPUVertBuf* verts, GPUIndexBuf* elem,
        uint owns_flag)
 {
 #if TRUST_NO_ONE
@@ -100,49 +100,49 @@ void GWN_batch_init_ex(
 #endif

 	batch->verts[0] = verts;
-	for (int v = 1; v < GWN_BATCH_VBO_MAX_LEN; ++v) {
+	for (int v = 1; v < GPU_BATCH_VBO_MAX_LEN; ++v) {
 		batch->verts[v] = NULL;
 	}
 	batch->inst = NULL;
 	batch->elem = elem;
 	batch->gl_prim_type = convert_prim_type_to_gl(prim_type);
-	batch->phase = GWN_BATCH_READY_TO_DRAW;
+	batch->phase = GPU_BATCH_READY_TO_DRAW;
 	batch->is_dynamic_vao_count = false;
 	batch->owns_flag = owns_flag;
 	batch->free_callback = NULL;
 }

 /* This will share the VBOs with the new batch. */
-Gwn_Batch* GWN_batch_duplicate(Gwn_Batch* batch_src)
+GPUBatch* GPU_batch_duplicate(GPUBatch* batch_src)
 {
-	Gwn_Batch* batch = GWN_batch_create_ex(GWN_PRIM_POINTS, batch_src->verts[0], batch_src->elem, 0);
+	GPUBatch* batch = GPU_batch_create_ex(GPU_PRIM_POINTS, batch_src->verts[0], batch_src->elem, 0);

 	batch->gl_prim_type = batch_src->gl_prim_type;
-	for (int v = 1; v < GWN_BATCH_VBO_MAX_LEN; ++v) {
+	for (int v = 1; v < GPU_BATCH_VBO_MAX_LEN; ++v) {
 		batch->verts[v] = batch_src->verts[v];
 	}
 	return batch;
 }

-void GWN_batch_discard(Gwn_Batch* batch)
+void GPU_batch_discard(GPUBatch* batch)
 {
-	if (batch->owns_flag & GWN_BATCH_OWNS_INDEX) {
-		GWN_indexbuf_discard(batch->elem);
+	if (batch->owns_flag & GPU_BATCH_OWNS_INDEX) {
+		GPU_indexbuf_discard(batch->elem);
 	}
-	if (batch->owns_flag & GWN_BATCH_OWNS_INSTANCES) {
-		GWN_vertbuf_discard(batch->inst);
+	if (batch->owns_flag & GPU_BATCH_OWNS_INSTANCES) {
+		GPU_vertbuf_discard(batch->inst);
 	}
-	if ((batch->owns_flag & ~GWN_BATCH_OWNS_INDEX) != 0) {
-		for (int v = 0; v < GWN_BATCH_VBO_MAX_LEN; ++v) {
+	if ((batch->owns_flag & ~GPU_BATCH_OWNS_INDEX) != 0) {
+		for (int v = 0; v < GPU_BATCH_VBO_MAX_LEN; ++v) {
 			if (batch->verts[v] == NULL) {
 				break;
 			}
 			if (batch->owns_flag & (1 << v)) {
-				GWN_vertbuf_discard(batch->verts[v]);
+				GPU_vertbuf_discard(batch->verts[v]);
 			}
 		}
 	}
-	gwn_batch_vao_cache_clear(batch);
+	GPU_batch_vao_cache_clear(batch);

 	if (batch->free_callback) {
 		batch->free_callback(batch, batch->callback_data);
@@ -150,42 +150,42 @@ void GWN_batch_discard(Gwn_Batch* batch)
 	free(batch);
 }

-void GWN_batch_callback_free_set(Gwn_Batch* batch, void (*callback)(Gwn_Batch*, void*), void* user_data)
+void GPU_batch_callback_free_set(GPUBatch* batch, void (*callback)(GPUBatch*, void*), void* user_data)
 {
 	batch->free_callback = callback;
 	batch->callback_data = user_data;
 }

-void GWN_batch_instbuf_set(Gwn_Batch* batch, Gwn_VertBuf* inst, bool own_vbo)
+void GPU_batch_instbuf_set(GPUBatch* batch, GPUVertBuf* inst, bool own_vbo)
 {
 #if TRUST_NO_ONE
 	assert(inst != NULL);
 #endif
 	/* redo the bindings */
-	gwn_batch_vao_cache_clear(batch);
+	GPU_batch_vao_cache_clear(batch);

-	if (batch->inst != NULL && (batch->owns_flag & GWN_BATCH_OWNS_INSTANCES)) {
-		GWN_vertbuf_discard(batch->inst);
+	if (batch->inst != NULL && (batch->owns_flag & GPU_BATCH_OWNS_INSTANCES)) {
+		GPU_vertbuf_discard(batch->inst);
 	}
 	batch->inst = inst;

 	if (own_vbo) {
-		batch->owns_flag |= GWN_BATCH_OWNS_INSTANCES;
+		batch->owns_flag |= GPU_BATCH_OWNS_INSTANCES;
 	}
 	else {
-		batch->owns_flag &= ~GWN_BATCH_OWNS_INSTANCES;
+		batch->owns_flag &= ~GPU_BATCH_OWNS_INSTANCES;
 	}
 }

 /* Returns the index of verts in the batch. */
-int GWN_batch_vertbuf_add_ex(
-        Gwn_Batch* batch, Gwn_VertBuf* verts,
+int GPU_batch_vertbuf_add_ex(
+        GPUBatch* batch, GPUVertBuf* verts,
        bool own_vbo)
 {
 	/* redo the bindings */
-	gwn_batch_vao_cache_clear(batch);
+	GPU_batch_vao_cache_clear(batch);

-	for (uint v = 0; v < GWN_BATCH_VBO_MAX_LEN; ++v) {
+	for (uint v = 0; v < GPU_BATCH_VBO_MAX_LEN; ++v) {
 		if (batch->verts[v] == NULL) {
 #if TRUST_NO_ONE
 			/* for now all VertexBuffers must have same vertex_len */
@@ -199,14 +199,14 @@ int GWN_batch_vertbuf_add_ex(
 		}
 	}

-	/* we only make it this far if there is no room for another Gwn_VertBuf */
+	/* we only make it this far if there is no room for another GPUVertBuf */
 #if TRUST_NO_ONE
 	assert(false);
 #endif
 	return -1;
 }

-static GLuint batch_vao_get(Gwn_Batch *batch)
+static GLuint batch_vao_get(GPUBatch *batch)
 {
 	/* Search through cache */
 	if (batch->is_dynamic_vao_count) {
@@ -215,22 +215,22 @@ static GLuint batch_vao_get(Gwn_Batch *batch)
 				return batch->dynamic_vaos.vao_ids[i];
 	}
 	else {
-		for (int i = 0; i < GWN_BATCH_VAO_STATIC_LEN; ++i)
+		for (int i = 0; i < GPU_BATCH_VAO_STATIC_LEN; ++i)
 			if (batch->static_vaos.interfaces[i] == batch->interface)
 				return batch->static_vaos.vao_ids[i];
 	}

 	/* Set context of this batch.
-	 * It will be bound to it until gwn_batch_vao_cache_clear is called.
+	 * It will be bound to it until GPU_batch_vao_cache_clear is called.
 	 * Until then it can only be drawn with this context. */
 	if (batch->context == NULL) {
-		batch->context = GWN_context_active_get();
-		gwn_context_add_batch(batch->context, batch);
+		batch->context = GPU_context_active_get();
+		gpu_context_add_batch(batch->context, batch);
 	}
 #if TRUST_NO_ONE
 	else {
 		/* Make sure you are not trying to draw this batch in another context. */
-		assert(batch->context == GWN_context_active_get());
+		assert(batch->context == GPU_context_active_get());
 	}
 #endif

@@ -238,25 +238,25 @@ static GLuint batch_vao_get(Gwn_Batch *batch)
 	GLuint new_vao = 0;
 	if (!batch->is_dynamic_vao_count) {
 		int i; /* find first unused slot */
-		for (i = 0; i < GWN_BATCH_VAO_STATIC_LEN; ++i) 
+		for (i = 0; i < GPU_BATCH_VAO_STATIC_LEN; ++i) 
 			if (batch->static_vaos.vao_ids[i] == 0)
 				break;

-		if (i < GWN_BATCH_VAO_STATIC_LEN) {
+		if (i < GPU_BATCH_VAO_STATIC_LEN) {
 			batch->static_vaos.interfaces[i] = batch->interface;
-			batch->static_vaos.vao_ids[i] = new_vao = GWN_vao_alloc();
+			batch->static_vaos.vao_ids[i] = new_vao = GPU_vao_alloc();
 		}
 		else {
 			/* Not enough place switch to dynamic. */
 			batch->is_dynamic_vao_count = true;
 			/* Erase previous entries, they will be added back if drawn again. */
-			for (int j = 0; j < GWN_BATCH_VAO_STATIC_LEN; ++j) {
-				GWN_shaderinterface_remove_batch_ref((Gwn_ShaderInterface*)batch->static_vaos.interfaces[j], batch);
-				GWN_vao_free(batch->static_vaos.vao_ids[j], batch->context);
+			for (int j = 0; j < GPU_BATCH_VAO_STATIC_LEN; ++j) {
+				GPU_shaderinterface_remove_batch_ref((GPUShaderInterface*)batch->static_vaos.interfaces[j], batch);
+				GPU_vao_free(batch->static_vaos.vao_ids[j], batch->context);
 			}
 			/* Init dynamic arrays and let the branch below set the values. */
-			batch->dynamic_vaos.count = GWN_BATCH_VAO_DYN_ALLOC_COUNT;
-			batch->dynamic_vaos.interfaces = calloc(batch->dynamic_vaos.count, sizeof(Gwn_ShaderInterface*));
+			batch->dynamic_vaos.count = GPU_BATCH_VAO_DYN_ALLOC_COUNT;
+			batch->dynamic_vaos.interfaces = calloc(batch->dynamic_vaos.count, sizeof(GPUShaderInterface*));
 			batch->dynamic_vaos.vao_ids = calloc(batch->dynamic_vaos.count, sizeof(GLuint));
 		}
 	}
@@ -270,17 +270,17 @@ static GLuint batch_vao_get(Gwn_Batch *batch)
 		if (i == batch->dynamic_vaos.count) {
 			/* Not enough place, realloc the array. */
 			i = batch->dynamic_vaos.count;
-			batch->dynamic_vaos.count += GWN_BATCH_VAO_DYN_ALLOC_COUNT;
-			batch->dynamic_vaos.interfaces = realloc(batch->dynamic_vaos.interfaces, sizeof(Gwn_ShaderInterface*) * batch->dynamic_vaos.count);
+			batch->dynamic_vaos.count += GPU_BATCH_VAO_DYN_ALLOC_COUNT;
+			batch->dynamic_vaos.interfaces = realloc(batch->dynamic_vaos.interfaces, sizeof(GPUShaderInterface*) * batch->dynamic_vaos.count);
 			batch->dynamic_vaos.vao_ids = realloc(batch->dynamic_vaos.vao_ids, sizeof(GLuint) * batch->dynamic_vaos.count);
-			memset(batch->dynamic_vaos.interfaces + i, 0, sizeof(Gwn_ShaderInterface*) * GWN_BATCH_VAO_DYN_ALLOC_COUNT);
-			memset(batch->dynamic_vaos.vao_ids + i, 0, sizeof(GLuint) * GWN_BATCH_VAO_DYN_ALLOC_COUNT);
+			memset(batch->dynamic_vaos.interfaces + i, 0, sizeof(GPUShaderInterface*) * GPU_BATCH_VAO_DYN_ALLOC_COUNT);
+			memset(batch->dynamic_vaos.vao_ids + i, 0, sizeof(GLuint) * GPU_BATCH_VAO_DYN_ALLOC_COUNT);
 		}
 		batch->dynamic_vaos.interfaces[i] = batch->interface;
-		batch->dynamic_vaos.vao_ids[i] = new_vao = GWN_vao_alloc();
+		batch->dynamic_vaos.vao_ids[i] = new_vao = GPU_vao_alloc();
 	}

-	GWN_shaderinterface_add_batch_ref((Gwn_ShaderInterface*)batch->interface, batch);
+	GPU_shaderinterface_add_batch_ref((GPUShaderInterface*)batch->interface, batch);

 #if TRUST_NO_ONE
 	assert(new_vao != 0);
@@ -294,7 +294,7 @@ static GLuint batch_vao_get(Gwn_Batch *batch)
 	return new_vao;
 }

-void GWN_batch_program_set_no_use(Gwn_Batch* batch, uint32_t program, const Gwn_ShaderInterface* shaderface)
+void GPU_batch_program_set_no_use(GPUBatch* batch, uint32_t program, const GPUShaderInterface* shaderface)
 {
 #if TRUST_NO_ONE
 	assert(glIsProgram(shaderface->program));
@@ -305,18 +305,18 @@ void GWN_batch_program_set_no_use(Gwn_Batch* batch, uint32_t program, const Gwn_
 	batch->vao_id = batch_vao_get(batch);
 }

-void GWN_batch_program_set(Gwn_Batch* batch, uint32_t program, const Gwn_ShaderInterface* shaderface)
+void GPU_batch_program_set(GPUBatch* batch, uint32_t program, const GPUShaderInterface* shaderface)
 {
-	GWN_batch_program_set_no_use(batch, program, shaderface);
-	GWN_batch_program_use_begin(batch); /* hack! to make Batch_Uniform* simpler */
+	GPU_batch_program_set_no_use(batch, program, shaderface);
+	GPU_batch_program_use_begin(batch); /* hack! to make Batch_Uniform* simpler */
 }

-void gwn_batch_remove_interface_ref(Gwn_Batch* batch, const Gwn_ShaderInterface* interface)
+void gpu_batch_remove_interface_ref(GPUBatch* batch, const GPUShaderInterface* interface)
 {
 	if (batch->is_dynamic_vao_count) {
 		for (int i = 0; i < batch->dynamic_vaos.count; ++i) {
 			if (batch->dynamic_vaos.interfaces[i] == interface) {
-				GWN_vao_free(batch->dynamic_vaos.vao_ids[i], batch->context);
+				GPU_vao_free(batch->dynamic_vaos.vao_ids[i], batch->context);
 				batch->dynamic_vaos.vao_ids[i] = 0;
 				batch->dynamic_vaos.interfaces[i] = NULL;
 				break; /* cannot have duplicates */
@@ -325,9 +325,9 @@ void gwn_batch_remove_interface_ref(Gwn_Batch* batch, const Gwn_ShaderInterface*
 	}
 	else {
 		int i;
-		for (i = 0; i < GWN_BATCH_VAO_STATIC_LEN; ++i) {
+		for (i = 0; i < GPU_BATCH_VAO_STATIC_LEN; ++i) {
 			if (batch->static_vaos.interfaces[i] == interface) {
-				GWN_vao_free(batch->static_vaos.vao_ids[i], batch->context);
+				GPU_vao_free(batch->static_vaos.vao_ids[i], batch->context);
 				batch->static_vaos.vao_ids[i] = 0;
 				batch->static_vaos.interfaces[i] = NULL;
 				break; /* cannot have duplicates */
@@ -337,28 +337,28 @@ void gwn_batch_remove_interface_ref(Gwn_Batch* batch, const Gwn_ShaderInterface*
 }

 static void create_bindings(
-        Gwn_VertBuf* verts, const Gwn_ShaderInterface* interface,
+        GPUVertBuf* verts, const GPUShaderInterface* interface,
        uint v_first, const bool use_instancing)
 {
-	const Gwn_VertFormat* format = &verts->format;
+	const GPUVertFormat* format = &verts->format;

 	const uint attr_len = format->attr_len;
 	const uint stride = format->stride;

-	GWN_vertbuf_use(verts);
+	GPU_vertbuf_use(verts);

 	for (uint a_idx = 0; a_idx < attr_len; ++a_idx) {
-		const Gwn_VertAttr* a = format->attribs + a_idx;
+		const GPUVertAttr* a = format->attribs + a_idx;
 		const GLvoid* pointer = (const GLubyte*)0 + a->offset + v_first * stride;

 		for (uint n_idx = 0; n_idx < a->name_len; ++n_idx) {
-			const Gwn_ShaderInput* input = GWN_shaderinterface_attr(interface, a->name[n_idx]);
+			const GPUShaderInput* input = GPU_shaderinterface_attr(interface, a->name[n_idx]);

 			if (input == NULL) continue;

 			if (a->comp_len == 16 || a->comp_len == 12 || a->comp_len == 8) {
 #if TRUST_NO_ONE
-				assert(a->fetch_mode == GWN_FETCH_FLOAT);
+				assert(a->fetch_mode == GPU_FETCH_FLOAT);
 				assert(a->gl_comp_type == GL_FLOAT);
 #endif
 				for (int i = 0; i < a->comp_len / 4; ++i) {
@@ -374,14 +374,14 @@ static void create_bindings(
 				glVertexAttribDivisor(input->location, (use_instancing) ? 1 : 0);

 				switch (a->fetch_mode) {
-					case GWN_FETCH_FLOAT:
-					case GWN_FETCH_INT_TO_FLOAT:
+					case GPU_FETCH_FLOAT:
+					case GPU_FETCH_INT_TO_FLOAT:
 						glVertexAttribPointer(input->location, a->comp_len, a->gl_comp_type, GL_FALSE, stride, pointer);
 						break;
-					case GWN_FETCH_INT_TO_FLOAT_UNIT:
+					case GPU_FETCH_INT_TO_FLOAT_UNIT:
 						glVertexAttribPointer(input->location, a->comp_len, a->gl_comp_type, GL_TRUE, stride, pointer);
 						break;
-					case GWN_FETCH_INT:
+					case GPU_FETCH_INT:
 						glVertexAttribIPointer(input->location, a->comp_len, a->gl_comp_type, stride, pointer);
 						break;
 				}
@@ -390,20 +390,20 @@ static void create_bindings(
 	}
 }

-static void batch_update_program_bindings(Gwn_Batch* batch, uint v_first)
+static void batch_update_program_bindings(GPUBatch* batch, uint v_first)
 {
-	for (int v = 0; v < GWN_BATCH_VBO_MAX_LEN && batch->verts[v] != NULL; ++v) {
+	for (int v = 0; v < GPU_BATCH_VBO_MAX_LEN && batch->verts[v] != NULL; ++v) {
 		create_bindings(batch->verts[v], batch->interface, (batch->inst) ? 0 : v_first, false);
 	}
 	if (batch->inst) {
 		create_bindings(batch->inst, batch->interface, v_first, true);
 	}
 	if (batch->elem) {
-		GWN_indexbuf_use(batch->elem);
+		GPU_indexbuf_use(batch->elem);
 	}
 }

-void GWN_batch_program_use_begin(Gwn_Batch* batch)
+void GPU_batch_program_use_begin(GPUBatch* batch)
 {
 	/* NOTE: use_program & done_using_program are fragile, depend on staying in sync with
 	 *       the GL context's active program. use_program doesn't mark other programs as "not used". */
@@ -415,7 +415,7 @@ void GWN_batch_program_use_begin(Gwn_Batch* batch)
 	}
 }

-void GWN_batch_program_use_end(Gwn_Batch* batch)
+void GPU_batch_program_use_end(GPUBatch* batch)
 {
 	if (batch->program_in_use) {
 #if PROGRAM_NO_OPTI
@@ -426,99 +426,99 @@ void GWN_batch_program_use_end(Gwn_Batch* batch)
 }

 #if TRUST_NO_ONE
-  #define GET_UNIFORM const Gwn_ShaderInput* uniform = GWN_shaderinterface_uniform(batch->interface, name); assert(uniform);
+  #define GET_UNIFORM const GPUShaderInput* uniform = GPU_shaderinterface_uniform(batch->interface, name); assert(uniform);
 #else
-  #define GET_UNIFORM const Gwn_ShaderInput* uniform = GWN_shaderinterface_uniform(batch->interface, name);
+  #define GET_UNIFORM const GPUShaderInput* uniform = GPU_shaderinterface_uniform(batch->interface, name);
 #endif

-void GWN_batch_uniform_1ui(Gwn_Batch* batch, const char* name, int value)
+void GPU_batch_uniform_1ui(GPUBatch* batch, const char* name, int value)
 {
 	GET_UNIFORM
 	glUniform1ui(uniform->location, value);
 }

-void GWN_batch_uniform_1i(Gwn_Batch* batch, const char* name, int value)
+void GPU_batch_uniform_1i(GPUBatch* batch, const char* name, int value)
 {
 	GET_UNIFORM
 	glUniform1i(uniform->location, value);
 }

-void GWN_batch_uniform_1b(Gwn_Batch* batch, const char* name, bool value)
+void GPU_batch_uniform_1b(GPUBatch* batch, const char* name, bool value)
 {
 	GET_UNIFORM
 	glUniform1i(uniform->location, value ? GL_TRUE : GL_FALSE);
 }

-void GWN_batch_uniform_2f(Gwn_Batch* batch, const char* name, float x, float y)
+void GPU_batch_uniform_2f(GPUBatch* batch, const char* name, float x, float y)
 {
 	GET_UNIFORM
 	glUniform2f(uniform->location, x, y);
 }

-void GWN_batch_uniform_3f(Gwn_Batch* batch, const char* name, float x, float y, float z)
+void GPU_batch_uniform_3f(GPUBatch* batch, const char* name, float x, float y, float z)
 {
 	GET_UNIFORM
 	glUniform3f(uniform->location, x, y, z);
 }

-void GWN_batch_uniform_4f(Gwn_Batch* batch, const char* name, float x, float y, float z, float w)
+void GPU_batch_uniform_4f(GPUBatch* batch, const char* name, float x, float y, float z, float w)
 {
 	GET_UNIFORM
 	glUniform4f(uniform->location, x, y, z, w);
 }

-void GWN_batch_uniform_1f(Gwn_Batch* batch, const char* name, float x)
+void GPU_batch_uniform_1f(GPUBatch* batch, const char* name, float x)
 {
 	GET_UNIFORM
 	glUniform1f(uniform->location, x);
 }

-void GWN_batch_uniform_2fv(Gwn_Batch* batch, const char* name, const float data[2])
+void GPU_batch_uniform_2fv(GPUBatch* batch, const char* name, const float data[2])
 {
 	GET_UNIFORM
 	glUniform2fv(uniform->location, 1, data);
 }

-void GWN_batch_uniform_3fv(Gwn_Batch* batch, const char* name, const float data[3])
+void GPU_batch_uniform_3fv(GPUBatch* batch, const char* name, const float data[3])
 {
 	GET_UNIFORM
 	glUniform3fv(uniform->location, 1, data);
 }

-void GWN_batch_uniform_4fv(Gwn_Batch* batch, const char* name, const float data[4])
+void GPU_batch_uniform_4fv(GPUBatch* batch, const char* name, const float data[4])
 {
 	GET_UNIFORM
 	glUniform4fv(uniform->location, 1, data);
 }

-void GWN_batch_uniform_2fv_array(Gwn_Batch* batch, const char* name, const int len, const float *data)
+void GPU_batch_uniform_2fv_array(GPUBatch* batch, const char* name, const int len, const float *data)
 {
 	GET_UNIFORM
 	glUniform2fv(uniform->location, len, data);
 }

-void GWN_batch_uniform_4fv_array(Gwn_Batch* batch, const char* name, const int len, const float *data)
+void GPU_batch_uniform_4fv_array(GPUBatch* batch, const char* name, const int len, const float *data)
 {
 	GET_UNIFORM
 	glUniform4fv(uniform->location, len, data);
 }

-void GWN_batch_uniform_mat4(Gwn_Batch* batch, const char* name, const float data[4][4])
+void GPU_batch_uniform_mat4(GPUBatch* batch, const char* name, const float data[4][4])
 {
 	GET_UNIFORM
 	glUniformMatrix4fv(uniform->location, 1, GL_FALSE, (const float *)data);
 }

-static void primitive_restart_enable(const Gwn_IndexBuf *el)
+static void primitive_restart_enable(const GPUIndexBuf *el)
 {
 	// TODO(fclem) Replace by GL_PRIMITIVE_RESTART_FIXED_INDEX when we have ogl 4.3
 	glEnable(GL_PRIMITIVE_RESTART);
 	GLuint restart_index = (GLuint)0xFFFFFFFF;

-#if GWN_TRACK_INDEX_RANGE
-	if (el->index_type == GWN_INDEX_U8)
+#if GPU_TRACK_INDEX_RANGE
+	if (el->index_type == GPU_INDEX_U8)
 		restart_index = (GLuint)0xFF;
-	else if (el->index_type == GWN_INDEX_U16)
+	else if (el->index_type == GPU_INDEX_U16)
 		restart_index = (GLuint)0xFFFF;
 #endif

@@ -530,21 +530,21 @@ static void primitive_restart_disable(void)
 	glDisable(GL_PRIMITIVE_RESTART);
 }

-void GWN_batch_draw(Gwn_Batch* batch)
+void GPU_batch_draw(GPUBatch* batch)
 {
 #if TRUST_NO_ONE
-	assert(batch->phase == GWN_BATCH_READY_TO_DRAW);
+	assert(batch->phase == GPU_BATCH_READY_TO_DRAW);
 	assert(batch->verts[0]->vbo_id != 0);
 #endif
-	GWN_batch_program_use_begin(batch);
+	GPU_batch_program_use_begin(batch);
 	GPU_matrix_bind(batch->interface); // external call.

-	GWN_batch_draw_range_ex(batch, 0, 0, false);
+	GPU_batch_draw_range_ex(batch, 0, 0, false);

-	GWN_batch_program_use_end(batch);
+	GPU_batch_program_use_end(batch);
 }

-void GWN_batch_draw_range_ex(Gwn_Batch* batch, int v_first, int v_count, bool force_instance)
+void GPU_batch_draw_range_ex(GPUBatch* batch, int v_first, int v_count, bool force_instance)
 {
 #if TRUST_NO_ONE
 	assert(!(force_instance && (batch->inst == NULL)) || v_count > 0); // we cannot infer length if force_instance
@@ -553,7 +553,7 @@ void GWN_batch_draw_range_ex(Gwn_Batch* batch, int v_first, int v_count, bool fo

 	// If using offset drawing, use the default VAO and redo bindings.
 	if (v_first != 0 && (do_instance || batch->elem)) {
-		glBindVertexArray(GWN_vao_default());
+		glBindVertexArray(GPU_vao_default());
 		batch_update_program_bindings(batch, v_first);
 	}
 	else {
@@ -567,12 +567,12 @@ void GWN_batch_draw_range_ex(Gwn_Batch* batch, int v_first, int v_count, bool fo
 		}

 		if (batch->elem) {
-			const Gwn_IndexBuf* el = batch->elem;
+			const GPUIndexBuf* el = batch->elem;

 			if (el->use_prim_restart) {
 				primitive_restart_enable(el);
 			}
-#if GWN_TRACK_INDEX_RANGE
+#if GPU_TRACK_INDEX_RANGE
 			glDrawElementsInstancedBaseVertex(batch->gl_prim_type,
 			                                  el->index_len,
 			                                  el->gl_index_type,
@@ -597,13 +597,13 @@ void GWN_batch_draw_range_ex(Gwn_Batch* batch, int v_first, int v_count, bool fo
 		}

 		if (batch->elem) {
-			const Gwn_IndexBuf* el = batch->elem;
+			const GPUIndexBuf* el = batch->elem;

 			if (el->use_prim_restart) {
 				primitive_restart_enable(el);
 			}

-#if GWN_TRACK_INDEX_RANGE
+#if GPU_TRACK_INDEX_RANGE
 			if (el->base_index) {
 				glDrawRangeElementsBaseVertex(batch->gl_prim_type,
 				                              el->min_index,
@@ -634,10 +634,10 @@ void GWN_batch_draw_range_ex(Gwn_Batch* batch, int v_first, int v_count, bool fo
 }

 /* just draw some vertices and let shader place them where we want. */
-void GWN_draw_primitive(Gwn_PrimType prim_type, int v_count)
+void GPU_draw_primitive(GPUPrimType prim_type, int v_count)
 	{
 	/* we cannot draw without vao ... annoying ... */
-	glBindVertexArray(GWN_vao_default());
+	glBindVertexArray(GPU_vao_default());

 	GLenum type = convert_prim_type_to_gl(prim_type);
 	glDrawArrays(type, 0, v_count);
@@ -652,10 +652,10 @@ void GWN_draw_primitive(Gwn_PrimType prim_type, int v_count)
 /** \name Utilities
 * \{ */

-void GWN_batch_program_set_builtin(Gwn_Batch *batch, GPUBuiltinShader shader_id)
+void GPU_batch_program_set_builtin(GPUBatch *batch, GPUBuiltinShader shader_id)
 {
 	GPUShader *shader = GPU_shader_get_builtin_shader(shader_id);
-	GWN_batch_program_set(batch, shader->program, shader->interface);
+	GPU_batch_program_set(batch, shader->program, shader->interface);
 }

 /** \} */