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

1 files changed, 79 insertions, 79 deletions

diff --git a/source/blender/gpu/GPU_batch.h b/source/blender/gpu/GPU_batch.h
index 4c98eb8f537..bd0e3b43e6c 100644
--- a/source/blender/gpu/GPU_batch.h
+++ b/source/blender/gpu/GPU_batch.h
@@ -23,15 +23,15 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
-/** \file blender/gpu/gwn_batch.h
+/** \file blender/gpu/GPU_batch.h
  *  \ingroup gpu
  *
- * Gawain geometry batch
+ * GPU geometry batch
  * Contains VAOs + VBOs + Shader representing a drawable entity.
  */
 
-#ifndef __GWN_BATCH_H__
-#define __GWN_BATCH_H__
+#ifndef __GPU_BATCH_H__
+#define __GPU_BATCH_H__
 
 #include "GPU_vertex_buffer.h"
 #include "GPU_element.h"
@@ -39,32 +39,32 @@
 #include "GPU_shader.h"
 
 typedef enum {
-	GWN_BATCH_READY_TO_FORMAT,
-	GWN_BATCH_READY_TO_BUILD,
-	GWN_BATCH_BUILDING,
-	GWN_BATCH_READY_TO_DRAW
-} Gwn_BatchPhase;
+	GPU_BATCH_READY_TO_FORMAT,
+	GPU_BATCH_READY_TO_BUILD,
+	GPU_BATCH_BUILDING,
+	GPU_BATCH_READY_TO_DRAW
+} GPUBatchPhase;
 
-#define GWN_BATCH_VBO_MAX_LEN 3
-#define GWN_BATCH_VAO_STATIC_LEN 3
-#define GWN_BATCH_VAO_DYN_ALLOC_COUNT 16
+#define GPU_BATCH_VBO_MAX_LEN 3
+#define GPU_BATCH_VAO_STATIC_LEN 3
+#define GPU_BATCH_VAO_DYN_ALLOC_COUNT 16
 
-typedef struct Gwn_Batch {
+typedef struct GPUBatch {
 	/* geometry */
-	Gwn_VertBuf* verts[GWN_BATCH_VBO_MAX_LEN]; /* verts[0] is required, others can be NULL */
-	Gwn_VertBuf* inst; /* instance attribs */
-	Gwn_IndexBuf* elem; /* NULL if element list not needed */
+	GPUVertBuf* verts[GPU_BATCH_VBO_MAX_LEN]; /* verts[0] is required, others can be NULL */
+	GPUVertBuf* inst; /* instance attribs */
+	GPUIndexBuf* elem; /* NULL if element list not needed */
 	uint32_t gl_prim_type;
 
 	/* cached values (avoid dereferencing later) */
 	uint32_t vao_id;
 	uint32_t program;
-	const struct Gwn_ShaderInterface* interface;
+	const struct GPUShaderInterface* interface;
 
 	/* book-keeping */
 	uint owns_flag;
-	struct Gwn_Context *context; /* used to free all vaos. this implies all vaos were created under the same context. */
-	Gwn_BatchPhase phase;
+	struct GPUContext *context; /* used to free all vaos. this implies all vaos were created under the same context. */
+	GPUBatchPhase phase;
 	bool program_in_use;
 
 	/* Vao management: remembers all geometry state (vertex attrib bindings & element buffer)
@@ -74,113 +74,113 @@ typedef struct Gwn_Batch {
 	union {
 		/* Static handle count */
 		struct {
-			const struct Gwn_ShaderInterface* interfaces[GWN_BATCH_VAO_STATIC_LEN];
-			uint32_t vao_ids[GWN_BATCH_VAO_STATIC_LEN];
+			const struct GPUShaderInterface* interfaces[GPU_BATCH_VAO_STATIC_LEN];
+			uint32_t vao_ids[GPU_BATCH_VAO_STATIC_LEN];
 		} static_vaos;
 		/* Dynamic handle count */
 		struct {
 			uint count;
-			const struct Gwn_ShaderInterface** interfaces;
+			const struct GPUShaderInterface** interfaces;
 			uint32_t* vao_ids;
 		} dynamic_vaos;
 	};
 
 	/* XXX This is the only solution if we want to have some data structure using
 	 * batches as key to identify nodes. We must destroy these nodes with this callback. */
-	void (*free_callback)(struct Gwn_Batch*, void*);
+	void (*free_callback)(struct GPUBatch*, void*);
 	void* callback_data;
-} Gwn_Batch;
+} GPUBatch;
 
 enum {
-	GWN_BATCH_OWNS_VBO = (1 << 0),
+	GPU_BATCH_OWNS_VBO = (1 << 0),
 	/* each vbo index gets bit-shifted */
-	GWN_BATCH_OWNS_INSTANCES = (1 << 30),
-	GWN_BATCH_OWNS_INDEX = (1 << 31),
+	GPU_BATCH_OWNS_INSTANCES = (1 << 30),
+	GPU_BATCH_OWNS_INDEX = (1 << 31),
 };
 
-Gwn_Batch* GWN_batch_create_ex(Gwn_PrimType, Gwn_VertBuf*, Gwn_IndexBuf*, uint owns_flag);
-void GWN_batch_init_ex(Gwn_Batch*, Gwn_PrimType, Gwn_VertBuf*, Gwn_IndexBuf*, uint owns_flag);
-Gwn_Batch* GWN_batch_duplicate(Gwn_Batch* batch_src);
+GPUBatch* GPU_batch_create_ex(GPUPrimType, GPUVertBuf*, GPUIndexBuf*, uint owns_flag);
+void GPU_batch_init_ex(GPUBatch*, GPUPrimType, GPUVertBuf*, GPUIndexBuf*, uint owns_flag);
+GPUBatch* GPU_batch_duplicate(GPUBatch* batch_src);
 
-#define GWN_batch_create(prim, verts, elem) \
-	GWN_batch_create_ex(prim, verts, elem, 0)
-#define GWN_batch_init(batch, prim, verts, elem) \
-	GWN_batch_init_ex(batch, prim, verts, elem, 0)
+#define GPU_batch_create(prim, verts, elem) \
+	GPU_batch_create_ex(prim, verts, elem, 0)
+#define GPU_batch_init(batch, prim, verts, elem) \
+	GPU_batch_init_ex(batch, prim, verts, elem, 0)
 
-void GWN_batch_discard(Gwn_Batch*); /* verts & elem are not discarded */
+void GPU_batch_discard(GPUBatch*); /* verts & elem are not discarded */
 
-void gwn_batch_vao_cache_clear(Gwn_Batch*);
+void GPU_batch_vao_cache_clear(GPUBatch*);
 
-void GWN_batch_callback_free_set(Gwn_Batch*, void (*callback)(Gwn_Batch*, void*), void*);
+void GPU_batch_callback_free_set(GPUBatch*, void (*callback)(GPUBatch*, void*), void*);
 
-void GWN_batch_instbuf_set(Gwn_Batch*, Gwn_VertBuf*, bool own_vbo); /* Instancing */
+void GPU_batch_instbuf_set(GPUBatch*, GPUVertBuf*, bool own_vbo); /* Instancing */
 
-int GWN_batch_vertbuf_add_ex(Gwn_Batch*, Gwn_VertBuf*, bool own_vbo);
+int GPU_batch_vertbuf_add_ex(GPUBatch*, GPUVertBuf*, bool own_vbo);
 
-#define GWN_batch_vertbuf_add(batch, verts) \
-	GWN_batch_vertbuf_add_ex(batch, verts, false)
+#define GPU_batch_vertbuf_add(batch, verts) \
+	GPU_batch_vertbuf_add_ex(batch, verts, false)
 
-void GWN_batch_program_set_no_use(Gwn_Batch*, uint32_t program, const Gwn_ShaderInterface*);
-void GWN_batch_program_set(Gwn_Batch*, uint32_t program, const Gwn_ShaderInterface*);
-void GWN_batch_program_set_builtin(Gwn_Batch *batch, GPUBuiltinShader shader_id);
+void GPU_batch_program_set_no_use(GPUBatch*, uint32_t program, const GPUShaderInterface*);
+void GPU_batch_program_set(GPUBatch*, uint32_t program, const GPUShaderInterface*);
+void GPU_batch_program_set_builtin(GPUBatch *batch, GPUBuiltinShader shader_id);
 /* Entire batch draws with one shader program, but can be redrawn later with another program. */
 /* Vertex shader's inputs must be compatible with the batch's vertex format. */
 
-void GWN_batch_program_use_begin(Gwn_Batch*); /* call before Batch_Uniform (temp hack?) */
-void GWN_batch_program_use_end(Gwn_Batch*);
-
-void GWN_batch_uniform_1ui(Gwn_Batch*, const char* name, int value);
-void GWN_batch_uniform_1i(Gwn_Batch*, const char* name, int value);
-void GWN_batch_uniform_1b(Gwn_Batch*, const char* name, bool value);
-void GWN_batch_uniform_1f(Gwn_Batch*, const char* name, float value);
-void GWN_batch_uniform_2f(Gwn_Batch*, const char* name, float x, float y);
-void GWN_batch_uniform_3f(Gwn_Batch*, const char* name, float x, float y, float z);
-void GWN_batch_uniform_4f(Gwn_Batch*, const char* name, float x, float y, float z, float w);
-void GWN_batch_uniform_2fv(Gwn_Batch*, const char* name, const float data[2]);
-void GWN_batch_uniform_3fv(Gwn_Batch*, const char* name, const float data[3]);
-void GWN_batch_uniform_4fv(Gwn_Batch*, const char* name, const float data[4]);
-void GWN_batch_uniform_2fv_array(Gwn_Batch*, const char* name, int len, const float *data);
-void GWN_batch_uniform_4fv_array(Gwn_Batch*, const char* name, int len, const float *data);
-void GWN_batch_uniform_mat4(Gwn_Batch*, const char* name, const float data[4][4]);
-
-void GWN_batch_draw(Gwn_Batch*);
+void GPU_batch_program_use_begin(GPUBatch*); /* call before Batch_Uniform (temp hack?) */
+void GPU_batch_program_use_end(GPUBatch*);
+
+void GPU_batch_uniform_1ui(GPUBatch*, const char* name, int value);
+void GPU_batch_uniform_1i(GPUBatch*, const char* name, int value);
+void GPU_batch_uniform_1b(GPUBatch*, const char* name, bool value);
+void GPU_batch_uniform_1f(GPUBatch*, const char* name, float value);
+void GPU_batch_uniform_2f(GPUBatch*, const char* name, float x, float y);
+void GPU_batch_uniform_3f(GPUBatch*, const char* name, float x, float y, float z);
+void GPU_batch_uniform_4f(GPUBatch*, const char* name, float x, float y, float z, float w);
+void GPU_batch_uniform_2fv(GPUBatch*, const char* name, const float data[2]);
+void GPU_batch_uniform_3fv(GPUBatch*, const char* name, const float data[3]);
+void GPU_batch_uniform_4fv(GPUBatch*, const char* name, const float data[4]);
+void GPU_batch_uniform_2fv_array(GPUBatch*, const char* name, int len, const float *data);
+void GPU_batch_uniform_4fv_array(GPUBatch*, const char* name, int len, const float *data);
+void GPU_batch_uniform_mat4(GPUBatch*, const char* name, const float data[4][4]);
+
+void GPU_batch_draw(GPUBatch*);
 
 /* This does not bind/unbind shader and does not call GPU_matrix_bind() */
-void GWN_batch_draw_range_ex(Gwn_Batch*, int v_first, int v_count, bool force_instance);
+void GPU_batch_draw_range_ex(GPUBatch*, int v_first, int v_count, bool force_instance);
 
 /* Does not even need batch */
-void GWN_draw_primitive(Gwn_PrimType, int v_count);
+void GPU_draw_primitive(GPUPrimType, int v_count);
 
 #if 0 /* future plans */
 
-/* Can multiple batches share a Gwn_VertBuf? Use ref count? */
+/* Can multiple batches share a GPUVertBuf? Use ref count? */
 
 
 /* We often need a batch with its own data, to be created and discarded together. */
 /* WithOwn variants reduce number of system allocations. */
 
 typedef struct BatchWithOwnVertexBuffer {
-	Gwn_Batch batch;
-	Gwn_VertBuf verts; /* link batch.verts to this */
+	GPUBatch batch;
+	GPUVertBuf verts; /* link batch.verts to this */
 } BatchWithOwnVertexBuffer;
 
 typedef struct BatchWithOwnElementList {
-	Gwn_Batch batch;
-	Gwn_IndexBuf elem; /* link batch.elem to this */
+	GPUBatch batch;
+	GPUIndexBuf elem; /* link batch.elem to this */
 } BatchWithOwnElementList;
 
 typedef struct BatchWithOwnVertexBufferAndElementList {
-	Gwn_Batch batch;
-	Gwn_IndexBuf elem; /* link batch.elem to this */
-	Gwn_VertBuf verts; /* link batch.verts to this */
+	GPUBatch batch;
+	GPUIndexBuf elem; /* link batch.elem to this */
+	GPUVertBuf verts; /* link batch.verts to this */
 } BatchWithOwnVertexBufferAndElementList;
 
-Gwn_Batch* create_BatchWithOwnVertexBuffer(Gwn_PrimType, Gwn_VertFormat*, uint v_len, Gwn_IndexBuf*);
-Gwn_Batch* create_BatchWithOwnElementList(Gwn_PrimType, Gwn_VertBuf*, uint prim_len);
-Gwn_Batch* create_BatchWithOwnVertexBufferAndElementList(Gwn_PrimType, Gwn_VertFormat*, uint v_len, uint prim_len);
+GPUBatch* create_BatchWithOwnVertexBuffer(GPUPrimType, GPUVertFormat*, uint v_len, GPUIndexBuf*);
+GPUBatch* create_BatchWithOwnElementList(GPUPrimType, GPUVertBuf*, uint prim_len);
+GPUBatch* create_BatchWithOwnVertexBufferAndElementList(GPUPrimType, GPUVertFormat*, uint v_len, uint prim_len);
 /* verts: shared, own */
 /* elem: none, shared, own */
-Gwn_Batch* create_BatchInGeneral(Gwn_PrimType, VertexBufferStuff, ElementListStuff);
+GPUBatch* create_BatchInGeneral(GPUPrimType, VertexBufferStuff, ElementListStuff);
 
 #endif /* future plans */
 
@@ -189,11 +189,11 @@ void gpu_batch_exit(void);
 
 /* Macros */
 
-#define GWN_BATCH_DISCARD_SAFE(batch) do { \
+#define GPU_BATCH_DISCARD_SAFE(batch) do { \
 	if (batch != NULL) { \
-		GWN_batch_discard(batch); \
+		GPU_batch_discard(batch); \
 		batch = NULL; \
 	} \
 } while (0)
 
-#endif /* __GWN_BATCH_H__ */
+#endif /* __GPU_BATCH_H__ */