Cleanup: use uint/uchar types in GPU

14 files changed, 115 insertions, 115 deletions

diff --git a/source/blender/gpu/intern/gpu_attr_binding_private.h b/source/blender/gpu/intern/gpu_attr_binding_private.h
index cb338b10aa4..c545983637c 100644
--- a/source/blender/gpu/intern/gpu_attr_binding_private.h
+++ b/source/blender/gpu/intern/gpu_attr_binding_private.h
@@ -39,7 +39,7 @@ void AttribBinding_clear(GPUAttrBinding *binding);
 
 void get_attrib_locations(
         const GPUVertFormat *format, GPUAttrBinding *binding, const GPUShaderInterface *shaderface);
-unsigned read_attrib_location(
-        const GPUAttrBinding *binding, unsigned a_idx);
+uint read_attrib_location(
+        const GPUAttrBinding *binding, uint a_idx);
 
 #endif /* __GPU_ATTR_BINDING_PRIVATE_H__ */
diff --git a/source/blender/gpu/intern/gpu_buffers.c b/source/blender/gpu/intern/gpu_buffers.c
index 6da7deece32..cd3290d1901 100644
--- a/source/blender/gpu/intern/gpu_buffers.c
+++ b/source/blender/gpu/intern/gpu_buffers.c
@@ -89,7 +89,7 @@ struct GPU_PBVH_Buffers {
 
 	bool use_bmesh;
 
-	unsigned int tot_tri, tot_quad;
+	uint tot_tri, tot_quad;
 
 	/* The PBVH ensures that either all faces in the node are
 	 * smooth-shaded or all faces are flat-shaded */
@@ -104,7 +104,7 @@ static struct {
 
 /* Allocates a non-initialized buffer to be sent to GPU.
  * Return is false it indicates that the memory map failed. */
-static bool gpu_pbvh_vert_buf_data_set(GPU_PBVH_Buffers *buffers, unsigned int vert_len)
+static bool gpu_pbvh_vert_buf_data_set(GPU_PBVH_Buffers *buffers, uint vert_len)
 {
 	if (buffers->vert_buf == NULL) {
 		/* Initialize vertex buffer */
@@ -192,13 +192,13 @@ void GPU_pbvh_mesh_buffers_update(
 			}
 			else {
 				/* calculate normal for each polygon only once */
-				unsigned int mpoly_prev = UINT_MAX;
+				uint mpoly_prev = UINT_MAX;
 				short no[3];
 				int vbo_index = 0;
 
 				for (uint i = 0; i < buffers->face_indices_len; i++) {
 					const MLoopTri *lt = &buffers->looptri[buffers->face_indices[i]];
-					const unsigned int vtri[3] = {
+					const uint vtri[3] = {
 					    buffers->mloop[lt->tri[0]].v,
 					    buffers->mloop[lt->tri[1]].v,
 					    buffers->mloop[lt->tri[2]].v,
@@ -433,7 +433,7 @@ void GPU_pbvh_grid_buffers_update(
 }
 
 /* Build the element array buffer of grid indices using either
- * unsigned shorts or unsigned ints. */
+ * ushorts or uints. */
 #define FILL_QUAD_BUFFER(max_vert_, tot_quad_, buffer_)                 \
 	{                                                                   \
 		int offset = 0;                                                 \
@@ -474,7 +474,7 @@ void GPU_pbvh_grid_buffers_update(
 /* end FILL_QUAD_BUFFER */
 
 static GPUIndexBuf *gpu_get_grid_buffer(
-        int gridsize, unsigned *totquad,
+        int gridsize, uint *totquad,
         /* remove this arg  when GPU gets base-vertex support! */
         int totgrid)
 {
@@ -845,7 +845,7 @@ void GPU_pbvh_buffers_free(GPU_PBVH_Buffers *buffers)
 }
 
 /* debug function, draws the pbvh BB */
-void GPU_pbvh_BB_draw(float min[3], float max[3], bool leaf, unsigned int pos)
+void GPU_pbvh_BB_draw(float min[3], float max[3], bool leaf, uint pos)
 {
 	if (leaf)
 		immUniformColor4f(0.0, 1.0, 0.0, 0.5);
diff --git a/source/blender/gpu/intern/gpu_codegen.c b/source/blender/gpu/intern/gpu_codegen.c
index 678c3019dc7..2b81ec02c9c 100644
--- a/source/blender/gpu/intern/gpu_codegen.c
+++ b/source/blender/gpu/intern/gpu_codegen.c
@@ -82,15 +82,15 @@ static uint32_t gpu_pass_hash(const char *frag_gen, const char *defs, GPUVertexA
 {
 	BLI_HashMurmur2A hm2a;
 	BLI_hash_mm2a_init(&hm2a, 0);
-	BLI_hash_mm2a_add(&hm2a, (unsigned char *)frag_gen, strlen(frag_gen));
+	BLI_hash_mm2a_add(&hm2a, (uchar *)frag_gen, strlen(frag_gen));
 	if (attribs) {
 		for (int att_idx = 0; att_idx < attribs->totlayer; att_idx++) {
 			char *name = attribs->layer[att_idx].name;
-			BLI_hash_mm2a_add(&hm2a, (unsigned char *)name, strlen(name));
+			BLI_hash_mm2a_add(&hm2a, (uchar *)name, strlen(name));
 		}
 	}
 	if (defs)
-		BLI_hash_mm2a_add(&hm2a, (unsigned char *)defs, strlen(defs));
+		BLI_hash_mm2a_add(&hm2a, (uchar *)defs, strlen(defs));
 
 	return BLI_hash_mm2a_end(&hm2a);
 }
@@ -923,7 +923,7 @@ static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool u
 					BLI_dynstr_appendf(ds, "#define att%d %s\n", input->attribid, attrib_prefix_get(input->attribtype));
 				}
 				else {
-					unsigned int hash = BLI_ghashutil_strhash_p(input->attribname);
+					uint hash = BLI_ghashutil_strhash_p(input->attribname);
 					BLI_dynstr_appendf(
 					        ds, "DEFINE_ATTRIB(%s, %s%u);\n",
 					        GPU_DATATYPE_STR[input->type], attrib_prefix_get(input->attribtype), hash);
diff --git a/source/blender/gpu/intern/gpu_codegen.h b/source/blender/gpu/intern/gpu_codegen.h
index 7a86bed55de..a6cb2468f2f 100644
--- a/source/blender/gpu/intern/gpu_codegen.h
+++ b/source/blender/gpu/intern/gpu_codegen.h
@@ -169,7 +169,7 @@ struct GPUPass {
 	char *geometrycode;
 	char *vertexcode;
 	char *defines;
-	unsigned int refcount;       /* Orphaned GPUPasses gets freed by the garbage collector. */
+	uint refcount;               /* Orphaned GPUPasses gets freed by the garbage collector. */
 	uint32_t hash;               /* Identity hash generated from all GLSL code. */
 	bool compiled;               /* Did we already tried to compile the attached GPUShader. */
 };
diff --git a/source/blender/gpu/intern/gpu_draw.c b/source/blender/gpu/intern/gpu_draw.c
index 325ade776de..92539fc2fb3 100644
--- a/source/blender/gpu/intern/gpu_draw.c
+++ b/source/blender/gpu/intern/gpu_draw.c
@@ -309,7 +309,7 @@ GPUTexture *GPU_texture_from_blender(
 
 	/* Check if we have a valid image. If not, we return a dummy
 	 * texture with zero bindcode so we don't keep trying. */
-	unsigned int bindcode = 0;
+	uint bindcode = 0;
 	if (ima->ok == 0) {
 		*tex = GPU_texture_from_bindcode(textarget, bindcode);
 		return *tex;
@@ -353,7 +353,7 @@ GPUTexture *GPU_texture_from_blender(
 
 	const int rectw = ibuf->x;
 	const int recth = ibuf->y;
-	unsigned int *rect = ibuf->rect;
+	uint *rect = ibuf->rect;
 	float *frect = NULL;
 	float *srgb_frect = NULL;
 
@@ -397,9 +397,9 @@ GPUTexture *GPU_texture_from_blender(
 	return *tex;
 }
 
-static void **gpu_gen_cube_map(unsigned int *rect, float *frect, int rectw, int recth, bool use_high_bit_depth)
+static void **gpu_gen_cube_map(uint *rect, float *frect, int rectw, int recth, bool use_high_bit_depth)
 {
-	size_t block_size = use_high_bit_depth ? sizeof(float) * 4 : sizeof(unsigned char) * 4;
+	size_t block_size = use_high_bit_depth ? sizeof(float[4]) : sizeof(uchar[4]);
 	void **sides = NULL;
 	int h = recth / 2;
 	int w = rectw / 3;
@@ -437,7 +437,7 @@ static void **gpu_gen_cube_map(unsigned int *rect, float *frect, int rectw, int
 		}
 	}
 	else {
-		unsigned int **isides = (unsigned int **)sides;
+		uint **isides = (uint **)sides;
 
 		for (int y = 0; y < h; y++) {
 			for (int x = 0; x < w; x++) {
@@ -466,7 +466,7 @@ static void gpu_del_cube_map(void **cube_map)
 
 /* Image *ima can be NULL */
 void GPU_create_gl_tex(
-        unsigned int *bind, unsigned int *rect, float *frect, int rectw, int recth,
+        uint *bind, uint *rect, float *frect, int rectw, int recth,
         int textarget, bool mipmap, bool use_high_bit_depth, Image *ima)
 {
 	ImBuf *ibuf = NULL;
@@ -670,7 +670,7 @@ bool GPU_upload_dxt_texture(ImBuf *ibuf)
 }
 
 void GPU_create_gl_tex_compressed(
-        unsigned int *bind, unsigned int *pix, int x, int y,
+        uint *bind, uint *pix, int x, int y,
         int textarget, int mipmap, Image *ima, ImBuf *ibuf)
 {
 #ifndef WITH_DDS
@@ -775,8 +775,8 @@ static bool gpu_check_scaled_image(ImBuf *ibuf, Image *ima, float *frect, int x,
 		}
 		/* byte images are not continuous in memory so do manual interpolation */
 		else {
-			unsigned char *scalerect = MEM_mallocN(rectw * recth * sizeof(*scalerect) * 4, "scalerect");
-			unsigned int *p = (unsigned int *)scalerect;
+			uchar *scalerect = MEM_mallocN(rectw * recth * sizeof(*scalerect) * 4, "scalerect");
+			uint *p = (uint *)scalerect;
 			int i, j;
 			float inv_xratio = 1.0f / xratio;
 			float inv_yratio = 1.0f / yratio;
@@ -784,7 +784,7 @@ static bool gpu_check_scaled_image(ImBuf *ibuf, Image *ima, float *frect, int x,
 				float u = (x + i) * inv_xratio;
 				for (j = 0; j < recth; j++) {
 					float v = (y + j) * inv_yratio;
-					bilinear_interpolation_color_wrap(ibuf, (unsigned char *)(p + i + j * (rectw)), NULL, u, v);
+					bilinear_interpolation_color_wrap(ibuf, (uchar *)(p + i + j * (rectw)), NULL, u, v);
 				}
 			}
 
@@ -1215,9 +1215,9 @@ void GPU_disable_program_point_size(void)
 
 /* apple seems to round colors to below and up on some configs */
 
-static unsigned int index_to_framebuffer(int index)
+static uint index_to_framebuffer(int index)
 {
-	unsigned int i = index;
+	uint i = index;
 
 	switch (GPU_color_depth()) {
 		case 12:
@@ -1245,9 +1245,9 @@ static unsigned int index_to_framebuffer(int index)
 
 /* this is the old method as being in use for ages.... seems to work? colors are rounded to lower values */
 
-static unsigned int index_to_framebuffer(int index)
+static uint index_to_framebuffer(int index)
 {
-	unsigned int i = index;
+	uint i = index;
 
 	switch (GPU_color_depth()) {
 		case 8:
@@ -1303,7 +1303,7 @@ void GPU_select_index_get(int index, int *r_col)
 #define INDEX_FROM_BUF_18(col)    ((((col) & 0xFC0000) >> 6)  + (((col) & 0xFC00) >> 4)  + (((col) & 0xFC) >> 2))
 #define INDEX_FROM_BUF_24(col)      ((col) & 0xFFFFFF)
 
-int GPU_select_to_index(unsigned int col)
+int GPU_select_to_index(uint col)
 {
 	if (col == 0) {
 		return 0;
@@ -1319,7 +1319,7 @@ int GPU_select_to_index(unsigned int col)
 	}
 }
 
-void GPU_select_to_index_array(unsigned int *col, const unsigned int size)
+void GPU_select_to_index_array(uint *col, const uint size)
 {
 #define INDEX_BUF_ARRAY(INDEX_FROM_BUF_BITS) \
 	for (i = size; i--; col++) { \
@@ -1329,7 +1329,7 @@ void GPU_select_to_index_array(unsigned int *col, const unsigned int size)
 	} ((void)0)
 
 	if (size > 0) {
-		unsigned int i, c;
+		uint i, c;
 
 		switch (GPU_color_depth()) {
 			case  8:
@@ -1360,32 +1360,32 @@ typedef struct {
 	eGPUAttribMask mask;
 
 	/* GL_ENABLE_BIT */
-	unsigned int is_blend : 1;
-	unsigned int is_cull_face : 1;
-	unsigned int is_depth_test : 1;
-	unsigned int is_dither : 1;
-	unsigned int is_lighting : 1;
-	unsigned int is_line_smooth : 1;
-	unsigned int is_color_logic_op : 1;
-	unsigned int is_multisample : 1;
-	unsigned int is_polygon_offset_line : 1;
-	unsigned int is_polygon_offset_fill : 1;
-	unsigned int is_polygon_smooth : 1;
-	unsigned int is_sample_alpha_to_coverage : 1;
-	unsigned int is_scissor_test : 1;
-	unsigned int is_stencil_test : 1;
+	uint is_blend : 1;
+	uint is_cull_face : 1;
+	uint is_depth_test : 1;
+	uint is_dither : 1;
+	uint is_lighting : 1;
+	uint is_line_smooth : 1;
+	uint is_color_logic_op : 1;
+	uint is_multisample : 1;
+	uint is_polygon_offset_line : 1;
+	uint is_polygon_offset_fill : 1;
+	uint is_polygon_smooth : 1;
+	uint is_sample_alpha_to_coverage : 1;
+	uint is_scissor_test : 1;
+	uint is_stencil_test : 1;
 
 	bool is_clip_plane[6];
 
 	/* GL_DEPTH_BUFFER_BIT */
-	/* unsigned int is_depth_test : 1; */
+	/* uint is_depth_test : 1; */
 	int depth_func;
 	double depth_clear_value;
 	bool depth_write_mask;
 
 	/* GL_SCISSOR_BIT */
 	int scissor_box[4];
-	/* unsigned int is_scissor_test : 1; */
+	/* uint is_scissor_test : 1; */
 
 	/* GL_VIEWPORT_BIT */
 	int viewport[4];
@@ -1394,7 +1394,7 @@ typedef struct {
 
 typedef struct {
 	GPUAttribValues attrib_stack[STATE_STACK_DEPTH];
-	unsigned int top;
+	uint top;
 } GPUAttribStack;
 
 static GPUAttribStack state = {
diff --git a/source/blender/gpu/intern/gpu_framebuffer.c b/source/blender/gpu/intern/gpu_framebuffer.c
index 21bfae00faa..f915ab758ed 100644
--- a/source/blender/gpu/intern/gpu_framebuffer.c
+++ b/source/blender/gpu/intern/gpu_framebuffer.c
@@ -487,7 +487,7 @@ void GPU_framebuffer_viewport_set(GPUFrameBuffer *fb, int x, int y, int w, int h
 
 void GPU_framebuffer_clear(
         GPUFrameBuffer *fb, GPUFrameBufferBits buffers,
-        const float clear_col[4], float clear_depth, unsigned int clear_stencil)
+        const float clear_col[4], float clear_depth, uint clear_stencil)
 {
 	CHECK_FRAMEBUFFER_IS_BOUND(fb);
 
diff --git a/source/blender/gpu/intern/gpu_immediate.c b/source/blender/gpu/intern/gpu_immediate.c
index 32c30c3f924..6e3de51df6b 100644
--- a/source/blender/gpu/intern/gpu_immediate.c
+++ b/source/blender/gpu/intern/gpu_immediate.c
@@ -558,7 +558,7 @@ void immAttrib4fv(uint attrib_id, const float data[4])
 	immAttrib4f(attrib_id, data[0], data[1], data[2], data[3]);
 }
 
-void immAttrib3ub(uint attrib_id, unsigned char r, unsigned char g, unsigned char b)
+void immAttrib3ub(uint attrib_id, uchar r, uchar g, uchar b)
 {
 	GPUVertAttr *attrib = imm.vertex_format.attribs + attrib_id;
 #if TRUST_NO_ONE
@@ -578,7 +578,7 @@ void immAttrib3ub(uint attrib_id, unsigned char r, unsigned char g, unsigned cha
 	data[2] = b;
 }
 
-void immAttrib4ub(uint attrib_id, unsigned char r, unsigned char g, unsigned char b, unsigned char a)
+void immAttrib4ub(uint attrib_id, uchar r, uchar g, uchar b, uchar a)
 {
 	GPUVertAttr *attrib = imm.vertex_format.attribs + attrib_id;
 #if TRUST_NO_ONE
@@ -599,12 +599,12 @@ void immAttrib4ub(uint attrib_id, unsigned char r, unsigned char g, unsigned cha
 	data[3] = a;
 }
 
-void immAttrib3ubv(uint attrib_id, const unsigned char data[3])
+void immAttrib3ubv(uint attrib_id, const uchar data[3])
 {
 	immAttrib3ub(attrib_id, data[0], data[1], data[2]);
 }
 
-void immAttrib4ubv(uint attrib_id, const unsigned char data[4])
+void immAttrib4ubv(uint attrib_id, const uchar data[4])
 {
 	immAttrib4ub(attrib_id, data[0], data[1], data[2], data[3]);
 }
@@ -847,29 +847,29 @@ void immUniformColor3fvAlpha(const float rgb[3], float a)
 
 /* TODO: v-- treat as sRGB? --v */
 
-void immUniformColor3ub(unsigned char r, unsigned char g, unsigned char b)
+void immUniformColor3ub(uchar r, uchar g, uchar b)
 {
 	const float scale = 1.0f / 255.0f;
 	immUniformColor4f(scale * r, scale * g, scale * b, 1.0f);
 }
 
-void immUniformColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
+void immUniformColor4ub(uchar r, uchar g, uchar b, uchar a)
 {
 	const float scale = 1.0f / 255.0f;
 	immUniformColor4f(scale * r, scale * g, scale * b, scale * a);
 }
 
-void immUniformColor3ubv(const unsigned char rgb[3])
+void immUniformColor3ubv(const uchar rgb[3])
 {
 	immUniformColor3ub(rgb[0], rgb[1], rgb[2]);
 }
 
-void immUniformColor3ubvAlpha(const unsigned char rgb[3], unsigned char alpha)
+void immUniformColor3ubvAlpha(const uchar rgb[3], uchar alpha)
 {
 	immUniformColor4ub(rgb[0], rgb[1], rgb[2], alpha);
 }
 
-void immUniformColor4ubv(const unsigned char rgba[4])
+void immUniformColor4ubv(const uchar rgba[4])
 {
 	immUniformColor4ub(rgba[0], rgba[1], rgba[2], rgba[3]);
 }
@@ -918,7 +918,7 @@ void immUniformThemeColorBlend(int color_id1, int color_id2, float fac)
 
 void immThemeColorShadeAlpha(int colorid, int coloffset, int alphaoffset)
 {
-	unsigned char col[4];
+	uchar col[4];
 	UI_GetThemeColorShadeAlpha4ubv(colorid, coloffset, alphaoffset, col);
 	immUniformColor4ub(col[0], col[1], col[2], col[3]);
 }
diff --git a/source/blender/gpu/intern/gpu_immediate_util.c b/source/blender/gpu/intern/gpu_immediate_util.c
index 0a75bd17d8c..fdba7800016 100644
--- a/source/blender/gpu/intern/gpu_immediate_util.c
+++ b/source/blender/gpu/intern/gpu_immediate_util.c
@@ -144,7 +144,7 @@ void immRecti_complete(int x1, int y1, int x2, int y2, const float color[4])
  *
  * \param x color.
  */
-void imm_cpack(unsigned int x)
+void imm_cpack(uint x)
 {
 	immUniformColor3ub(((x) & 0xFF),
 	                   (((x) >> 8) & 0xFF),
@@ -205,7 +205,7 @@ void imm_draw_circle_fill_aspect_2d(uint shdr_pos, float x, float y, float rad_x
  * \note We could have `imm_draw_lined_disk_partial` but currently there is no need.
  */
 static void imm_draw_disk_partial(
-        GPUPrimType prim_type, unsigned pos, float x, float y,
+        GPUPrimType prim_type, uint pos, float x, float y,
         float rad_inner, float rad_outer, int nsegments, float start, float sweep)
 {
 	/* shift & reverse angle, increase 'nsegments' to match gluPartialDisk */
@@ -239,14 +239,14 @@ static void imm_draw_disk_partial(
  * \param sweep: Specifies the sweep angle, in degrees, of the disk portion.
  */
 void imm_draw_disk_partial_fill_2d(
-        unsigned pos, float x, float y,
+        uint pos, float x, float y,
         float rad_inner, float rad_outer, int nsegments, float start, float sweep)
 {
 	imm_draw_disk_partial(GPU_PRIM_TRI_STRIP, pos, x, y, rad_inner, rad_outer, nsegments, start, sweep);
 }
 
 static void imm_draw_circle_3D(
-        GPUPrimType prim_type, unsigned pos, float x, float y,
+        GPUPrimType prim_type, uint pos, float x, float y,
         float rad, int nsegments)
 {
 	immBegin(prim_type, nsegments);
@@ -257,12 +257,12 @@ static void imm_draw_circle_3D(
 	immEnd();
 }
 
-void imm_draw_circle_wire_3d(unsigned pos, float x, float y, float rad, int nsegments)
+void imm_draw_circle_wire_3d(uint pos, float x, float y, float rad, int nsegments)
 {
 	imm_draw_circle_3D(GPU_PRIM_LINE_LOOP, pos, x, y, rad, nsegments);
 }
 
-void imm_draw_circle_fill_3d(unsigned pos, float x, float y, float rad, int nsegments)
+void imm_draw_circle_fill_3d(uint pos, float x, float y, float rad, int nsegments)
 {
 	imm_draw_circle_3D(GPU_PRIM_TRI_FAN, pos, x, y, rad, nsegments);
 }
@@ -276,7 +276,7 @@ void imm_draw_circle_fill_3d(unsigned pos, float x, float y, float rad, int nseg
  * \param x2 right.
  * \param y2 top.
  */
-void imm_draw_box_wire_2d(unsigned pos, float x1, float y1, float x2, float y2)
+void imm_draw_box_wire_2d(uint pos, float x1, float y1, float x2, float y2)
 {
 	immBegin(GPU_PRIM_LINE_LOOP, 4);
 	immVertex2f(pos, x1, y1);
@@ -286,7 +286,7 @@ void imm_draw_box_wire_2d(unsigned pos, float x1, float y1, float x2, float y2)
 	immEnd();
 }
 
-void imm_draw_box_wire_3d(unsigned pos, float x1, float y1, float x2, float y2)
+void imm_draw_box_wire_3d(uint pos, float x1, float y1, float x2, float y2)
 {
 	/* use this version when GPUVertFormat has a vec3 position */
 	immBegin(GPU_PRIM_LINE_LOOP, 4);
@@ -364,7 +364,7 @@ void imm_draw_cube_wire_3d(uint pos, const float co[3], const float aspect[3])
  * \param stacks Specifies the number of subdivisions along the z axis.
  */
 void imm_draw_cylinder_fill_normal_3d(
-        unsigned int pos, unsigned int nor, float base, float top, float height, int slices, int stacks)
+        uint pos, uint nor, float base, float top, float height, int slices, int stacks)
 {
 	immBegin(GPU_PRIM_TRIS, 6 * slices * stacks);
 	for (int i = 0; i < slices; ++i) {
@@ -415,7 +415,7 @@ void imm_draw_cylinder_fill_normal_3d(
 	immEnd();
 }
 
-void imm_draw_cylinder_wire_3d(unsigned int pos, float base, float top, float height, int slices, int stacks)
+void imm_draw_cylinder_wire_3d(uint pos, float base, float top, float height, int slices, int stacks)
 {
 	immBegin(GPU_PRIM_LINES, 6 * slices * stacks);
 	for (int i = 0; i < slices; ++i) {
@@ -452,7 +452,7 @@ void imm_draw_cylinder_wire_3d(unsigned int pos, float base, float top, float he
 	immEnd();
 }
 
-void imm_draw_cylinder_fill_3d(unsigned int pos, float base, float top, float height, int slices, int stacks)
+void imm_draw_cylinder_fill_3d(uint pos, float base, float top, float height, int slices, int stacks)
 {
 	immBegin(GPU_PRIM_TRIS, 6 * slices * stacks);
 	for (int i = 0; i < slices; ++i) {
diff --git a/source/blender/gpu/intern/gpu_matrix.c b/source/blender/gpu/intern/gpu_matrix.c
index 0fa4a158c00..5ab8086397c 100644
--- a/source/blender/gpu/intern/gpu_matrix.c
+++ b/source/blender/gpu/intern/gpu_matrix.c
@@ -50,7 +50,7 @@ typedef float Mat3[3][3];
 
 typedef struct MatrixStack {
 	Mat4 stack[MATRIX_STACK_DEPTH];
-	unsigned int top;
+	uint top;
 } MatrixStack;
 
 typedef struct {
diff --git a/source/blender/gpu/intern/gpu_select_private.h b/source/blender/gpu/intern/gpu_select_private.h
index 8935bd7b253..d6c02d5b3ea 100644
--- a/source/blender/gpu/intern/gpu_select_private.h
+++ b/source/blender/gpu/intern/gpu_select_private.h
@@ -33,9 +33,9 @@
 #define __GPU_SELECT_PRIVATE_H__
 
 /* gpu_select_pick */
-void gpu_select_pick_begin(unsigned int (*buffer)[4], unsigned int bufsize, const rcti *input, char mode);
-bool gpu_select_pick_load_id(unsigned int id);
-unsigned int gpu_select_pick_end(void);
+void gpu_select_pick_begin(uint (*buffer)[4], uint bufsize, const rcti *input, char mode);
+bool gpu_select_pick_load_id(uint id);
+uint gpu_select_pick_end(void);
 
 void gpu_select_pick_cache_begin(void);
 void gpu_select_pick_cache_end(void);
@@ -43,11 +43,11 @@ bool gpu_select_pick_is_cached(void);
 void gpu_select_pick_cache_load_id(void);
 
 /* gpu_select_sample_query */
-void gpu_select_query_begin(unsigned int (*buffer)[4], unsigned int bufsize, const rcti *input, char mode, int oldhits);
-bool gpu_select_query_load_id(unsigned int id);
-unsigned int gpu_select_query_end(void);
+void gpu_select_query_begin(uint (*buffer)[4], uint bufsize, const rcti *input, char mode, int oldhits);
+bool gpu_select_query_load_id(uint id);
+uint gpu_select_query_end(void);
 
 
-#define SELECT_ID_NONE ((unsigned int)0xffffffff)
+#define SELECT_ID_NONE ((uint)0xffffffff)
 
 #endif  /* __GPU_SELECT_PRIVATE_H__ */
diff --git a/source/blender/gpu/intern/gpu_shader.c b/source/blender/gpu/intern/gpu_shader.c
index 67825c9cbaf..803a6319017 100644
--- a/source/blender/gpu/intern/gpu_shader.c
+++ b/source/blender/gpu/intern/gpu_shader.c
@@ -582,7 +582,7 @@ void GPU_shader_unbind(void)
 	glUseProgram(0);
 }
 
-bool GPU_shader_transform_feedback_enable(GPUShader *shader, unsigned int vbo_id)
+bool GPU_shader_transform_feedback_enable(GPUShader *shader, uint vbo_id)
 {
 	if (shader->feedback_transform_type == GPU_SHADER_TFB_NONE) {
 		return false;
diff --git a/source/blender/gpu/intern/gpu_texture.c b/source/blender/gpu/intern/gpu_texture.c
index 98362abfbfd..3e4a57c8f64 100644
--- a/source/blender/gpu/intern/gpu_texture.c
+++ b/source/blender/gpu/intern/gpu_texture.c
@@ -83,7 +83,7 @@ struct GPUTexture {
 	GPUTextureFormat format;
 	GPUTextureFormatFlag format_flag;
 
-	unsigned int bytesize; /* number of byte for one pixel */
+	uint bytesize;      /* number of byte for one pixel */
 	int components;     /* number of color/alpha channels */
 	int samples;        /* number of samples for multisamples textures. 0 if not multisample target */
 
@@ -94,9 +94,9 @@ struct GPUTexture {
 /* ------ Memory Management ------- */
 /* Records every texture allocation / free
  * to estimate the Texture Pool Memory consumption */
-static unsigned int memory_usage;
+static uint memory_usage;
 
-static unsigned int gpu_texture_memory_footprint_compute(GPUTexture *tex)
+static uint gpu_texture_memory_footprint_compute(GPUTexture *tex)
 {
 	int samp = max_ii(tex->samples, 1);
 	switch (tex->target) {
@@ -127,7 +127,7 @@ static void gpu_texture_memory_footprint_remove(GPUTexture *tex)
 	memory_usage -= gpu_texture_memory_footprint_compute(tex);
 }
 
-unsigned int GPU_texture_memory_usage_get(void)
+uint GPU_texture_memory_usage_get(void)
 {
 	return memory_usage;
 }
@@ -281,7 +281,7 @@ static GLenum gpu_get_gl_dataformat(GPUTextureFormat data_type, GPUTextureFormat
 	return GL_RGBA;
 }
 
-static unsigned int gpu_get_bytesize(GPUTextureFormat data_type)
+static uint gpu_get_bytesize(GPUTextureFormat data_type)
 {
 	switch (data_type) {
 		case GPU_RGBA32F:
@@ -384,22 +384,22 @@ static GLenum gpu_get_gl_datatype(GPUDataFormat format)
 
 static float *GPU_texture_3D_rescale(GPUTexture *tex, int w, int h, int d, int channels, const float *fpixels)
 {
-	const unsigned int xf = w / tex->w, yf = h / tex->h, zf = d / tex->d;
+	const uint xf = w / tex->w, yf = h / tex->h, zf = d / tex->d;
 	float *nfpixels = MEM_mallocN(channels * sizeof(float) * tex->w * tex->h * tex->d, "GPUTexture Rescaled 3Dtex");
 
 	if (nfpixels) {
 		GPU_print_error_debug("You need to scale a 3D texture, feel the pain!");
 
-		for (unsigned k = 0; k < tex->d; k++) {
-			for (unsigned j = 0; j < tex->h; j++) {
-				for (unsigned i = 0; i < tex->w; i++) {
+		for (uint k = 0; k < tex->d; k++) {
+			for (uint j = 0; j < tex->h; j++) {
+				for (uint i = 0; i < tex->w; i++) {
 					/* obviously doing nearest filtering here,
 					 * it's going to be slow in any case, let's not make it worse */
 					float xb = i * xf;
 					float yb = j * yf;
 					float zb = k * zf;
-					unsigned int offset = k * (tex->w * tex->h) + i * tex->h + j;
-					unsigned int offset_orig = (zb) * (w * h) + (xb) * h + (yb);
+					uint offset = k * (tex->w * tex->h) + i * tex->h + j;
+					uint offset_orig = (zb) * (w * h) + (xb) * h + (yb);
 
 					if (channels == 4) {
 						nfpixels[offset * 4] = fpixels[offset_orig * 4];
@@ -939,7 +939,7 @@ GPUTexture *GPU_texture_create_from_vertbuf(GPUVertBuf *vert)
 	BLI_assert(attr->comp_type != GPU_COMP_I10);
 	BLI_assert(attr->fetch_mode != GPU_FETCH_INT_TO_FLOAT);
 
-	unsigned int byte_per_comp = attr->sz / attr->comp_len;
+	uint byte_per_comp = attr->sz / attr->comp_len;
 	bool is_uint = ELEM(attr->comp_type, GPU_COMP_U8, GPU_COMP_U16, GPU_COMP_U32);
 
 	/* Cannot fetch signed int or 32bit ints as normalized float. */
diff --git a/source/blender/gpu/intern/gpu_vertex_format.c b/source/blender/gpu/intern/gpu_vertex_format.c
index eef4945d9ef..59e413a1f3e 100644
--- a/source/blender/gpu/intern/gpu_vertex_format.c
+++ b/source/blender/gpu/intern/gpu_vertex_format.c
@@ -50,7 +50,7 @@ void GPU_vertformat_clear(GPUVertFormat *format)
 	format->name_offset = 0;
 	format->name_len = 0;
 
-	for (unsigned i = 0; i < GPU_VERT_ATTR_MAX_LEN; i++) {
+	for (uint i = 0; i < GPU_VERT_ATTR_MAX_LEN; i++) {
 		format->attribs[i].name_len = 0;
 	}
 #endif
@@ -61,8 +61,8 @@ void GPU_vertformat_copy(GPUVertFormat *dest, const GPUVertFormat *src)
 	/* copy regular struct fields */
 	memcpy(dest, src, sizeof(GPUVertFormat));
 
-	for (unsigned i = 0; i < dest->attr_len; i++) {
-		for (unsigned j = 0; j < dest->attribs[i].name_len; j++) {
+	for (uint i = 0; i < dest->attr_len; i++) {
+		for (uint j = 0; j < dest->attribs[i].name_len; j++) {
 			dest->attribs[i].name[j] = (char *)dest + (src->attribs[i].name[j] - ((char *)src));
 		}
 	}
@@ -85,7 +85,7 @@ static GLenum convert_comp_type_to_gl(GPUVertCompType type)
 	return table[type];
 }
 
-static unsigned comp_sz(GPUVertCompType type)
+static uint comp_sz(GPUVertCompType type)
 {
 #if TRUST_NO_ONE
 	assert(type <= GPU_COMP_F32); /* other types have irregular sizes (not bytes) */
@@ -94,7 +94,7 @@ static unsigned comp_sz(GPUVertCompType type)
 	return sizes[type];
 }
 
-static unsigned attrib_sz(const GPUVertAttr *a)
+static uint attrib_sz(const GPUVertAttr *a)
 {
 	if (a->comp_type == GPU_COMP_I10) {
 		return 4; /* always packed as 10_10_10_2 */
@@ -102,12 +102,12 @@ static unsigned attrib_sz(const GPUVertAttr *a)
 	return a->comp_len * comp_sz(a->comp_type);
 }
 
-static unsigned attrib_align(const GPUVertAttr *a)
+static uint attrib_align(const GPUVertAttr *a)
 {
 	if (a->comp_type == GPU_COMP_I10) {
 		return 4; /* always packed as 10_10_10_2 */
 	}
-	unsigned c = comp_sz(a->comp_type);
+	uint c = comp_sz(a->comp_type);
 	if (a->comp_len == 3 && c <= 2) {
 		return 4 * c; /* AMD HW can't fetch these well, so pad it out (other vendors too?) */
 	}
@@ -116,7 +116,7 @@ static unsigned attrib_align(const GPUVertAttr *a)
 	}
 }
 
-unsigned vertex_buffer_size(const GPUVertFormat *format, unsigned vertex_len)
+uint vertex_buffer_size(const GPUVertFormat *format, uint vertex_len)
 {
 #if TRUST_NO_ONE
 	assert(format->packed && format->stride > 0);
@@ -128,10 +128,10 @@ static const char *copy_attrib_name(GPUVertFormat *format, const char *name)
 {
 	/* strncpy does 110% of what we need; let's do exactly 100% */
 	char *name_copy = format->names + format->name_offset;
-	unsigned available = GPU_VERT_ATTR_NAMES_BUF_LEN - format->name_offset;
+	uint available = GPU_VERT_ATTR_NAMES_BUF_LEN - format->name_offset;
 	bool terminated = false;
 
-	for (unsigned i = 0; i < available; ++i) {
+	for (uint i = 0; i < available; ++i) {
 		const char c = name[i];
 		name_copy[i] = c;
 		if (c == '\0') {
@@ -149,9 +149,9 @@ static const char *copy_attrib_name(GPUVertFormat *format, const char *name)
 	return name_copy;
 }
 
-unsigned GPU_vertformat_attr_add(
+uint GPU_vertformat_attr_add(
         GPUVertFormat *format, const char *name,
-        GPUVertCompType comp_type, unsigned comp_len, GPUVertFetchMode fetch_mode)
+        GPUVertCompType comp_type, uint comp_len, GPUVertFetchMode fetch_mode)
 {
 #if TRUST_NO_ONE
 	assert(format->name_len < GPU_VERT_ATTR_MAX_LEN); /* there's room for more */
@@ -179,7 +179,7 @@ unsigned GPU_vertformat_attr_add(
 #endif
 	format->name_len++; /* multiname support */
 
-	const unsigned attrib_id = format->attr_len++;
+	const uint attrib_id = format->attr_len++;
 	GPUVertAttr *attrib = format->attribs + attrib_id;
 
 	attrib->name[attrib->name_len++] = copy_attrib_name(format, name);
@@ -204,20 +204,20 @@ void GPU_vertformat_alias_add(GPUVertFormat *format, const char *alias)
 	attrib->name[attrib->name_len++] = copy_attrib_name(format, alias);
 }
 
-unsigned padding(unsigned offset, unsigned alignment)
+uint padding(uint offset, uint alignment)
 {
-	const unsigned mod = offset % alignment;
+	const uint mod = offset % alignment;
 	return (mod == 0) ? 0 : (alignment - mod);
 }
 
 #if PACK_DEBUG
-static void show_pack(unsigned a_idx, unsigned sz, unsigned pad)
+static void show_pack(uint a_idx, uint sz, uint pad)
 {
 	const char c = 'A' + a_idx;
-	for (unsigned i = 0; i < pad; ++i) {
+	for (uint i = 0; i < pad; ++i) {
 		putchar('-');
 	}
-	for (unsigned i = 0; i < sz; ++i) {
+	for (uint i = 0; i < sz; ++i) {
 		putchar(c);
 	}
 }
@@ -235,15 +235,15 @@ void VertexFormat_pack(GPUVertFormat *format)
 
 	GPUVertAttr *a0 = format->attribs + 0;
 	a0->offset = 0;
-	unsigned offset = a0->sz;
+	uint offset = a0->sz;
 
 #if PACK_DEBUG
 	show_pack(0, a0->sz, 0);
 #endif
 
-	for (unsigned a_idx = 1; a_idx < format->attr_len; ++a_idx) {
+	for (uint a_idx = 1; a_idx < format->attr_len; ++a_idx) {
 		GPUVertAttr *a = format->attribs + a_idx;
-		unsigned mid_padding = padding(offset, attrib_align(a));
+		uint mid_padding = padding(offset, attrib_align(a));
 		offset += mid_padding;
 		a->offset = offset;
 		offset += a->sz;
@@ -253,7 +253,7 @@ void VertexFormat_pack(GPUVertFormat *format)
 #endif
 	}
 
-	unsigned end_padding = padding(offset, attrib_align(a0));
+	uint end_padding = padding(offset, attrib_align(a0));
 
 #if PACK_DEBUG
 	show_pack(0, 0, end_padding);
diff --git a/source/blender/gpu/intern/gpu_viewport.c b/source/blender/gpu/intern/gpu_viewport.c
index 5d495779ba1..fe98477f28c 100644
--- a/source/blender/gpu/intern/gpu_viewport.c
+++ b/source/blender/gpu/intern/gpu_viewport.c
@@ -76,7 +76,7 @@ struct GPUViewport {
 	int flag;
 
 	ListBase data;  /* ViewportEngineData wrapped in LinkData */
-	unsigned int data_hash;  /* If hash mismatch we free all ViewportEngineData in this viewport */
+	uint data_hash;  /* If hash mismatch we free all ViewportEngineData in this viewport */
 
 	DefaultFramebufferList *fbl;
 	DefaultTextureList *txl;
@@ -360,7 +360,7 @@ static void gpu_viewport_texture_pool_free(GPUViewport *viewport)
 	BLI_freelistN(&viewport->tex_pool);
 }
 
-bool GPU_viewport_engines_data_validate(GPUViewport *viewport, unsigned int hash)
+bool GPU_viewport_engines_data_validate(GPUViewport *viewport, uint hash)
 {
 	bool dirty = false;