(API Change) Improve graphics API consistency

Summary:
- Prefix all graphics subsystem names with gs_ or GS_
- Unsquish funciton names (for example _setfloat to _set_float)
- Changed create functions to be more consistent with the rest of the
  API elsewhere.  For exmaple, instead of
  gs_create_texture/gs_texture_destroy, it's now
  gs_texture_create/gs_texture_destroy
- Renamed gs_stencil_op enum to gs_stencil_op_type

From:                            To:
-----------------------------------------------------------
tvertarray                       gs_tvertarray
vb_data                          gs_vb_data
vbdata_create                    gs_vbdata_create
vbdata_destroy                   gs_vbdata_destroy
shader_param                     gs_shader_param
gs_effect                        gs_effect
effect_technique                 gs_effect_technique
effect_pass                      gs_effect_pass
effect_param                     gs_effect_param
texture_t                        gs_texture_t
stagesurf_t                      gs_stagesurf_t
zstencil_t                       gs_zstencil_t
vertbuffer_t                     gs_vertbuffer_t
indexbuffer_t                    gs_indexbuffer_t
samplerstate_t                   gs_samplerstate_t
swapchain_t                      gs_swapchain_t
texrender_t                      gs_texrender_t
shader_t                         gs_shader_t
sparam_t                         gs_sparam_t
effect_t                         gs_effect_t
technique_t                      gs_technique_t
eparam_t                         gs_eparam_t
device_t                         gs_device_t
graphics_t                       graphics_t
shader_param_type                gs_shader_param_type
SHADER_PARAM_UNKNOWN             GS_SHADER_PARAM_UNKNOWN
SHADER_PARAM_BOOL                GS_SHADER_PARAM_BOOL
SHADER_PARAM_FLOAT               GS_SHADER_PARAM_FLOAT
SHADER_PARAM_INT                 GS_SHADER_PARAM_INT
SHADER_PARAM_STRING              GS_SHADER_PARAM_STRING
SHADER_PARAM_VEC2                GS_SHADER_PARAM_VEC2
SHADER_PARAM_VEC3                GS_SHADER_PARAM_VEC3
SHADER_PARAM_VEC4                GS_SHADER_PARAM_VEC4
SHADER_PARAM_MATRIX4X4           GS_SHADER_PARAM_MATRIX4X4
SHADER_PARAM_TEXTURE             GS_SHADER_PARAM_TEXTURE
shader_param_info                gs_shader_param_info
shader_type                      gs_shader_type
SHADER_VERTEX                    GS_SHADER_VERTEX
SHADER_PIXEL                     GS_SHADER_PIXEL
shader_destroy                   gs_shader_destroy
shader_numparams                 gs_shader_get_num_params
shader_getparambyidx             gs_shader_get_param_by_idx
shader_getparambyname            gs_shader_get_param_by_name
shader_getviewprojmatrix         gs_shader_get_viewproj_matrix
shader_getworldmatrix            gs_shader_get_world_matrix
shader_getparaminfo              gs_shader_get_param_info
shader_setbool                   gs_shader_set_bool
shader_setfloat                  gs_shader_set_float
shader_setint                    gs_shader_set_int
shader_setmatrix3                gs_shader_setmatrix3
shader_setmatrix4                gs_shader_set_matrix4
shader_setvec2                   gs_shader_set_vec2
shader_setvec3                   gs_shader_set_vec3
shader_setvec4                   gs_shader_set_vec4
shader_settexture                gs_shader_set_texture
shader_setval                    gs_shader_set_val
shader_setdefault                gs_shader_set_default
effect_property_type             gs_effect_property_type
EFFECT_NONE                      GS_EFFECT_NONE
EFFECT_BOOL                      GS_EFFECT_BOOL
EFFECT_FLOAT                     GS_EFFECT_FLOAT
EFFECT_COLOR                     GS_EFFECT_COLOR
EFFECT_TEXTURE                   GS_EFFECT_TEXTURE
effect_param_info                gs_effect_param_info
effect_destroy                   gs_effect_destroy
effect_gettechnique              gs_effect_get_technique
technique_begin                  gs_technique_begin
technique_end                    gs_technique_end
technique_beginpass              gs_technique_begin_pass
technique_beginpassbyname        gs_technique_begin_pass_by_name
technique_endpass                gs_technique_end_pass
effect_numparams                 gs_effect_get_num_params
effect_getparambyidx             gs_effect_get_param_by_idx
effect_getparambyname            gs_effect_get_param_by_name
effect_updateparams              gs_effect_update_params
effect_getviewprojmatrix         gs_effect_get_viewproj_matrix
effect_getworldmatrix            gs_effect_get_world_matrix
effect_getparaminfo              gs_effect_get_param_info
effect_setbool                   gs_effect_set_bool
effect_setfloat                  gs_effect_set_float
effect_setint                    gs_effect_set_int
effect_setmatrix4                gs_effect_set_matrix4
effect_setvec2                   gs_effect_set_vec2
effect_setvec3                   gs_effect_set_vec3
effect_setvec4                   gs_effect_set_vec4
effect_settexture                gs_effect_set_texture
effect_setval                    gs_effect_set_val
effect_setdefault                gs_effect_set_default
texrender_create                 gs_texrender_create
texrender_destroy                gs_texrender_destroy
texrender_begin                  gs_texrender_begin
texrender_end                    gs_texrender_end
texrender_reset                  gs_texrender_reset
texrender_gettexture             gs_texrender_get_texture
GS_BUILDMIPMAPS                  GS_BUILD_MIPMAPS
GS_RENDERTARGET                  GS_RENDER_TARGET
gs_device_name                   gs_get_device_name
gs_device_type                   gs_get_device_type
gs_entercontext                  gs_enter_context
gs_leavecontext                  gs_leave_context
gs_getcontext                    gs_get_context
gs_renderstart                   gs_render_start
gs_renderstop                    gs_render_stop
gs_rendersave                    gs_render_save
gs_getinput                      gs_get_input
gs_geteffect                     gs_get_effect
gs_create_effect_from_file       gs_effect_create_from_file
gs_create_effect                 gs_effect_create
gs_create_vertexshader_from_file gs_vertexshader_create_from_file
gs_create_pixelshader_from_file  gs_pixelshader_create_from_file
gs_create_texture_from_file      gs_texture_create_from_file
gs_resetviewport                 gs_reset_viewport
gs_set2dmode                     gs_set_2d_mode
gs_set3dmode                     gs_set_3d_mode
gs_create_swapchain              gs_swapchain_create
gs_getsize                       gs_get_size
gs_getwidth                      gs_get_width
gs_getheight                     gs_get_height
gs_create_texture                gs_texture_create
gs_create_cubetexture            gs_cubetexture_create
gs_create_volumetexture          gs_voltexture_create
gs_create_zstencil               gs_zstencil_create
gs_create_stagesurface           gs_stagesurface_create
gs_create_samplerstate           gs_samplerstate_create
gs_create_vertexshader           gs_vertexshader_create
gs_create_pixelshader            gs_pixelshader_create
gs_create_vertexbuffer           gs_vertexbuffer_create
gs_create_indexbuffer            gs_indexbuffer_create
gs_gettexturetype                gs_get_texture_type
gs_load_defaultsamplerstate      gs_load_default_samplerstate
gs_getvertexshader               gs_get_vertex_shader
gs_getpixelshader                gs_get_pixel_shader
gs_getrendertarget               gs_get_render_target
gs_getzstenciltarget             gs_get_zstencil_target
gs_setrendertarget               gs_set_render_target
gs_setcuberendertarget           gs_set_cube_render_target
gs_beginscene                    gs_begin_scene
gs_draw                          gs_draw
gs_endscene                      gs_end_scene
gs_setcullmode                   gs_set_cull_mode
gs_getcullmode                   gs_get_cull_mode
gs_enable_depthtest              gs_enable_depth_test
gs_enable_stenciltest            gs_enable_stencil_test
gs_enable_stencilwrite           gs_enable_stencil_write
gs_blendfunction                 gs_blend_function
gs_depthfunction                 gs_depth_function
gs_stencilfunction               gs_stencil_function
gs_stencilop                     gs_stencil_op
gs_setviewport                   gs_set_viewport
gs_getviewport                   gs_get_viewport
gs_setscissorrect                gs_set_scissor_rect
gs_create_texture_from_iosurface gs_texture_create_from_iosurface
gs_create_gdi_texture            gs_texture_create_gdi
gs_is_compressed_format          gs_is_compressed_format
gs_num_total_levels              gs_get_total_levels
texture_setimage                 gs_texture_set_image
cubetexture_setimage             gs_cubetexture_set_image
swapchain_destroy                gs_swapchain_destroy
texture_destroy                  gs_texture_destroy
texture_getwidth                 gs_texture_get_width
texture_getheight                gs_texture_get_height
texture_getcolorformat           gs_texture_get_color_format
texture_map                      gs_texture_map
texture_unmap                    gs_texture_unmap
texture_isrect                   gs_texture_is_rect
texture_getobj                   gs_texture_get_obj
cubetexture_destroy              gs_cubetexture_destroy
cubetexture_getsize              gs_cubetexture_get_size
cubetexture_getcolorformat       gs_cubetexture_get_color_format
volumetexture_destroy            gs_voltexture_destroy
volumetexture_getwidth           gs_voltexture_get_width
volumetexture_getheight          gs_voltexture_get_height
volumetexture_getdepth           gs_voltexture_getdepth
volumetexture_getcolorformat     gs_voltexture_get_color_format
stagesurface_destroy             gs_stagesurface_destroy
stagesurface_getwidth            gs_stagesurface_get_width
stagesurface_getheight           gs_stagesurface_get_height
stagesurface_getcolorformat      gs_stagesurface_get_color_format
stagesurface_map                 gs_stagesurface_map
stagesurface_unmap               gs_stagesurface_unmap
zstencil_destroy                 gs_zstencil_destroy
samplerstate_destroy             gs_samplerstate_destroy
vertexbuffer_destroy             gs_vertexbuffer_destroy
vertexbuffer_flush               gs_vertexbuffer_flush
vertexbuffer_getdata             gs_vertexbuffer_get_data
indexbuffer_destroy              gs_indexbuffer_destroy
indexbuffer_flush                gs_indexbuffer_flush
indexbuffer_getdata              gs_indexbuffer_get_data
indexbuffer_numindices           gs_indexbuffer_get_num_indices
indexbuffer_gettype              gs_indexbuffer_get_type
texture_rebind_iosurface         gs_texture_rebind_iosurface
texture_get_dc                   gs_texture_get_dc
texture_release_dc               gs_texture_release_dc

libobs-opengl/gl-cocoa.m

@@ -96,7 +96,7 @@ static NSOpenGLContext *gl_context_create(struct gs_init_data *info)
 	return context;
 }
 
-static bool gl_init_default_swap(struct gl_platform *plat, device_t dev,
+static bool gl_init_default_swap(struct gl_platform *plat, gs_device_t dev,
 		struct gs_init_data *info)
 {
 	if(!(plat->context = gl_context_create(info)))
@@ -109,7 +109,7 @@ static bool gl_init_default_swap(struct gl_platform *plat, device_t dev,
 	return plat->swap.wi != NULL;
 }
 
-struct gl_platform *gl_platform_create(device_t device,
+struct gl_platform *gl_platform_create(gs_device_t device,
 		struct gs_init_data *info)
 {
 	struct gl_platform *plat = bzalloc(sizeof(struct gl_platform));
@@ -186,24 +186,24 @@ void gl_windowinfo_destroy(struct gl_windowinfo *wi)
 	bfree(wi);
 }
 
-void gl_update(device_t device)
+void gl_update(gs_device_t device)
 {
 	[device->plat->context update];
 }
 
-void device_entercontext(device_t device)
+void device_enter_context(gs_device_t device)
 {
 	[device->plat->context makeCurrentContext];
 }
 
-void device_leavecontext(device_t device)
+void device_leave_context(gs_device_t device)
 {
 	UNUSED_PARAMETER(device);
 
 	[NSOpenGLContext clearCurrentContext];
 }
 
-void device_load_swapchain(device_t device, swapchain_t swap)
+void device_load_swapchain(gs_device_t device, gs_swapchain_t swap)
 {
 	if(!swap)
 		swap = &device->plat->swap;
@@ -215,7 +215,7 @@ void device_load_swapchain(device_t device, swapchain_t swap)
 	[device->plat->context setView:swap->wi->view];
 }
 
-void device_present(device_t device)
+void device_present(gs_device_t device)
 {
 	[device->plat->context flushBuffer];
 }
@@ -227,7 +227,8 @@ void gl_getclientsize(struct gs_swap_chain *swap, uint32_t *width,
 	if(height) *height = swap->info.cy;
 }
 
-texture_t texture_create_from_iosurface(device_t device, void *iosurf)
+gs_texture_t device_texture_create_from_iosurface(gs_device_t device,
+		void *iosurf)
 {
 	IOSurfaceRef ref = (IOSurfaceRef)iosurf;
 	struct gs_texture_2d *tex = bzalloc(sizeof(struct gs_texture_2d));
@@ -270,7 +271,7 @@ texture_t texture_create_from_iosurface(device_t device, void *iosurf)
 	
 	if(err != kCGLNoError) {
 		blog(LOG_ERROR, "CGLTexImageIOSurface2D: %u, %s"
-			        " (texture_create_from_iosurface)",
+			        " (device_texture_create_from_iosurface)",
 				err, CGLErrorString(err));
 
 		gl_success("CGLTexImageIOSurface2D");
@@ -284,15 +285,15 @@ texture_t texture_create_from_iosurface(device_t device, void *iosurf)
 	if (!gl_bind_texture(tex->base.gl_target, 0))
 		goto fail;
 
-	return (texture_t)tex;
+	return (gs_texture_t)tex;
 
 fail:
-	texture_destroy((texture_t)tex);
-	blog(LOG_ERROR, "texture_create_from_iosurface (GL) failed");
+	gs_texture_destroy((gs_texture_t)tex);
+	blog(LOG_ERROR, "device_texture_create_from_iosurface (GL) failed");
 	return NULL;
 }
 
-bool texture_rebind_iosurface(texture_t texture, void *iosurf)
+bool gs_texture_rebind_iosurface(gs_texture_t texture, void *iosurf)
 {
 	if (!texture)
 		return false;
@@ -326,7 +327,7 @@ bool texture_rebind_iosurface(texture_t texture, void *iosurf)
 	
 	if(err != kCGLNoError) {
 		blog(LOG_ERROR, "CGLTexImageIOSurface2D: %u, %s"
-			        " (texture_rebind_iosurface)",
+			        " (gs_texture_rebind_iosurface)",
 				err, CGLErrorString(err));
 
 		gl_success("CGLTexImageIOSurface2D");

libobs-opengl/gl-indexbuffer.c

@@ -33,7 +33,7 @@ static inline bool init_ib(struct gs_index_buffer *ib)
 	return success;
 }
 
-indexbuffer_t device_create_indexbuffer(device_t device,
+gs_indexbuffer_t device_indexbuffer_create(gs_device_t device,
 		enum gs_index_type type, void *indices, size_t num,
 		uint32_t flags)
 {
@@ -51,15 +51,15 @@ indexbuffer_t device_create_indexbuffer(device_t device,
 	                                         GL_UNSIGNED_SHORT;
 
 	if (!init_ib(ib)) {
-		blog(LOG_ERROR, "device_create_indexbuffer (GL) failed");
-		indexbuffer_destroy(ib);
+		blog(LOG_ERROR, "device_indexbuffer_create (GL) failed");
+		gs_indexbuffer_destroy(ib);
 		return NULL;
 	}
 
 	return ib;
 }
 
-void indexbuffer_destroy(indexbuffer_t ib)
+void gs_indexbuffer_destroy(gs_indexbuffer_t ib)
 {
 	if (ib) {
 		if (ib->buffer)
@@ -70,7 +70,7 @@ void indexbuffer_destroy(indexbuffer_t ib)
 	}
 }
 
-void indexbuffer_flush(indexbuffer_t ib)
+void gs_indexbuffer_flush(gs_indexbuffer_t ib)
 {
 	if (!ib->dynamic) {
 		blog(LOG_ERROR, "Index buffer is not dynamic");
@@ -83,25 +83,25 @@ void indexbuffer_flush(indexbuffer_t ib)
 	return;
 
 fail:
-	blog(LOG_ERROR, "indexbuffer_flush (GL) failed");
+	blog(LOG_ERROR, "gs_indexbuffer_flush (GL) failed");
 }
 
-void *indexbuffer_getdata(indexbuffer_t ib)
+void *gs_indexbuffer_get_data(gs_indexbuffer_t ib)
 {
 	return ib->data;
 }
 
-size_t indexbuffer_numindices(indexbuffer_t ib)
+size_t gs_indexbuffer_get_num_indices(gs_indexbuffer_t ib)
 {
 	return ib->num;
 }
 
-enum gs_index_type indexbuffer_gettype(indexbuffer_t ib)
+enum gs_index_type gs_indexbuffer_get_type(gs_indexbuffer_t ib)
 {
 	return ib->type;
 }
 
-void device_load_indexbuffer(device_t device, indexbuffer_t ib)
+void device_load_indexbuffer(gs_device_t device, gs_indexbuffer_t ib)
 {
 	if (ib == device->cur_index_buffer)
 		return;

libobs-opengl/gl-shader.c

@@ -25,12 +25,12 @@
 #include "gl-subsystem.h"
 #include "gl-shaderparser.h"
 
-static inline void shader_param_init(struct shader_param *param)
+static inline void shader_param_init(struct gs_shader_param *param)
 {
-	memset(param, 0, sizeof(struct shader_param));
+	memset(param, 0, sizeof(struct gs_shader_param));
 }
 
-static inline void shader_param_free(struct shader_param *param)
+static inline void shader_param_free(struct gs_shader_param *param)
 {
 	bfree(param->name);
 	da_free(param->cur_value);
@@ -63,14 +63,14 @@ static void gl_get_program_info(GLuint program, const char *file,
 static bool gl_add_param(struct gs_shader *shader, struct shader_var *var,
 		GLint *texture_id)
 {
-	struct shader_param param = {0};
+	struct gs_shader_param param = {0};
 
 	param.array_count = var->array_count;
 	param.name        = bstrdup(var->name);
 	param.shader      = shader;
 	param.type        = get_shader_param_type(var->type);
 
-	if (param.type == SHADER_PARAM_TEXTURE) {
+	if (param.type == GS_SHADER_PARAM_TEXTURE) {
 		param.sampler_id  = var->gl_sampler_id;
 		param.texture_id  = (*texture_id)++;
 	} else {
@@ -84,7 +84,7 @@ static bool gl_add_param(struct gs_shader *shader, struct shader_var *var,
 	if (!gl_success("glGetUniformLocation"))
 		goto fail;
 
-	if (param.type == SHADER_PARAM_TEXTURE) {
+	if (param.type == GS_SHADER_PARAM_TEXTURE) {
 		glProgramUniform1i(shader->program, param.param,
 				param.texture_id);
 		if (!gl_success("glProgramUniform1i"))
@@ -109,8 +109,8 @@ static inline bool gl_add_params(struct gs_shader *shader,
 		if (!gl_add_param(shader, glsp->parser.params.array+i, &tex_id))
 			return false;
 
-	shader->viewproj = shader_getparambyname(shader, "ViewProj");
-	shader->world    = shader_getparambyname(shader, "World");
+	shader->viewproj = gs_shader_get_param_by_name(shader, "ViewProj");
+	shader->world    = gs_shader_get_param_by_name(shader, "World");
 
 	return true;
 }
@@ -118,11 +118,11 @@ static inline bool gl_add_params(struct gs_shader *shader,
 static inline void gl_add_sampler(struct gs_shader *shader,
 		struct shader_sampler *sampler)
 {
-	samplerstate_t new_sampler;
+	gs_samplerstate_t new_sampler;
 	struct gs_sampler_info info;
 
 	shader_sampler_convert(sampler, &info);
-	new_sampler = device_create_samplerstate(shader->device, &info);
+	new_sampler = device_samplerstate_create(shader->device, &info);
 
 	da_push_back(shader->samplers, &new_sampler);
 }
@@ -235,7 +235,7 @@ static bool gl_shader_init(struct gs_shader *shader,
 	if (success)
 		success = gl_add_params(shader, glsp);
 	/* Only vertex shaders actually require input attributes */
-	if (success && shader->type == SHADER_VERTEX)
+	if (success && shader->type == GS_SHADER_VERTEX)
 		success = gl_process_attribs(shader, glsp);
 	if (success)
 		gl_add_samplers(shader, glsp);
@@ -243,8 +243,9 @@ static bool gl_shader_init(struct gs_shader *shader,
 	return success;
 }
 
-static struct gs_shader *shader_create(device_t device, enum shader_type type,
-		const char *shader_str, const char *file, char **error_string)
+static struct gs_shader *shader_create(gs_device_t device,
+		enum gs_shader_type type, const char *shader_str,
+		const char *file, char **error_string)
 {
 	struct gs_shader *shader = bzalloc(sizeof(struct gs_shader));
 	struct gl_shader_parser glsp;
@@ -260,7 +261,7 @@ static struct gs_shader *shader_create(device_t device, enum shader_type type,
 		success = gl_shader_init(shader, &glsp, file, error_string);
 
 	if (!success) {
-		shader_destroy(shader);
+		gs_shader_destroy(shader);
 		shader = NULL;
 	}
 
@@ -268,29 +269,31 @@ static struct gs_shader *shader_create(device_t device, enum shader_type type,
 	return shader;
 }
 
-shader_t device_create_vertexshader(device_t device,
+gs_shader_t device_vertexshader_create(gs_device_t device,
 		const char *shader, const char *file,
 		char **error_string)
 {
 	struct gs_shader *ptr;
-	ptr = shader_create(device, SHADER_VERTEX, shader, file, error_string);
+	ptr = shader_create(device, GS_SHADER_VERTEX, shader, file,
+			error_string);
 	if (!ptr)
-		blog(LOG_ERROR, "device_create_vertexshader (GL) failed");
+		blog(LOG_ERROR, "device_vertexshader_create (GL) failed");
 	return ptr;
 }
 
-shader_t device_create_pixelshader(device_t device,
+gs_shader_t device_pixelshader_create(gs_device_t device,
 		const char *shader, const char *file,
 		char **error_string)
 {
 	struct gs_shader *ptr;
-	ptr = shader_create(device, SHADER_PIXEL, shader, file, error_string);
+	ptr = shader_create(device, GS_SHADER_PIXEL, shader, file,
+			error_string);
 	if (!ptr)
-		blog(LOG_ERROR, "device_create_pixelshader (GL) failed");
+		blog(LOG_ERROR, "device_pixelshader_create (GL) failed");
 	return ptr;
 }
 
-void shader_destroy(shader_t shader)
+void gs_shader_destroy(gs_shader_t shader)
 {
 	size_t i;
 
@@ -298,7 +301,7 @@ void shader_destroy(shader_t shader)
 		return;
 
 	for (i = 0; i < shader->samplers.num; i++)
-		samplerstate_destroy(shader->samplers.array[i]);
+		gs_samplerstate_destroy(shader->samplers.array[i]);
 
 	for (i = 0; i < shader->params.num; i++)
 		shader_param_free(shader->params.array+i);
@@ -314,22 +317,22 @@ void shader_destroy(shader_t shader)
 	bfree(shader);
 }
 
-int shader_numparams(shader_t shader)
+int gs_shader_get_num_params(gs_shader_t shader)
 {
 	return (int)shader->params.num;
 }
 
-sparam_t shader_getparambyidx(shader_t shader, uint32_t param)
+gs_sparam_t gs_shader_get_param_by_idx(gs_shader_t shader, uint32_t param)
 {
 	assert(param < shader->params.num);
 	return shader->params.array+param;
 }
 
-sparam_t shader_getparambyname(shader_t shader, const char *name)
+gs_sparam_t gs_shader_get_param_by_name(gs_shader_t shader, const char *name)
 {
 	size_t i;
 	for (i = 0; i < shader->params.num; i++) {
-		struct shader_param *param = shader->params.array+i;
+		struct gs_shader_param *param = shader->params.array+i;
 
 		if (strcmp(param->name, name) == 0)
 			return param;
@@ -338,44 +341,45 @@ sparam_t shader_getparambyname(shader_t shader, const char *name)
 	return NULL;
 }
 
-sparam_t shader_getviewprojmatrix(shader_t shader)
+gs_sparam_t gs_shader_get_viewproj_matrix(gs_shader_t shader)
 {
 	return shader->viewproj;
 }
 
-sparam_t shader_getworldmatrix(shader_t shader)
+gs_sparam_t gs_shader_get_world_matrix(gs_shader_t shader)
 {
 	return shader->world;
 }
 
-void shader_getparaminfo(sparam_t param, struct shader_param_info *info)
+void gs_shader_get_param_info(gs_sparam_t param,
+		struct gs_shader_param_info *info)
 {
 	info->type = param->type;
 	info->name = param->name;
 }
 
-void shader_setbool(sparam_t param, bool val)
+void gs_shader_set_bool(gs_sparam_t param, bool val)
 {
 	struct gs_shader *shader = param->shader;
 	glProgramUniform1i(shader->program, param->param, (GLint)val);
 	gl_success("glProgramUniform1i");
 }
 
-void shader_setfloat(sparam_t param, float val)
+void gs_shader_set_float(gs_sparam_t param, float val)
 {
 	struct gs_shader *shader = param->shader;
 	glProgramUniform1f(shader->program, param->param, val);
 	gl_success("glProgramUniform1f");
 }
 
-void shader_setint(sparam_t param, int val)
+void gs_shader_set_int(gs_sparam_t param, int val)
 {
 	struct gs_shader *shader = param->shader;
 	glProgramUniform1i(shader->program, param->param, val);
 	gl_success("glProgramUniform1i");
 }
 
-void shader_setmatrix3(sparam_t param, const struct matrix3 *val)
+void gs_shader_setmatrix3(gs_sparam_t param, const struct matrix3 *val)
 {
 	struct gs_shader *shader = param->shader;
 	struct matrix4 mat;
@@ -386,7 +390,7 @@ void shader_setmatrix3(sparam_t param, const struct matrix3 *val)
 	gl_success("glProgramUniformMatrix4fv");
 }
 
-void shader_setmatrix4(sparam_t param, const struct matrix4 *val)
+void gs_shader_set_matrix4(gs_sparam_t param, const struct matrix4 *val)
 {
 	struct gs_shader *shader = param->shader;
 	glProgramUniformMatrix4fv(shader->program, param->param, 1,
@@ -394,58 +398,58 @@ void shader_setmatrix4(sparam_t param, const struct matrix4 *val)
 	gl_success("glProgramUniformMatrix4fv");
 }
 
-void shader_setvec2(sparam_t param, const struct vec2 *val)
+void gs_shader_set_vec2(gs_sparam_t param, const struct vec2 *val)
 {
 	struct gs_shader *shader = param->shader;
 	glProgramUniform2fv(shader->program, param->param, 1, val->ptr);
 	gl_success("glProgramUniform2fv");
 }
 
-void shader_setvec3(sparam_t param, const struct vec3 *val)
+void gs_shader_set_vec3(gs_sparam_t param, const struct vec3 *val)
 {
 	struct gs_shader *shader = param->shader;
 	glProgramUniform3fv(shader->program, param->param, 1, val->ptr);
 	gl_success("glProgramUniform3fv");
 }
 
-void shader_setvec4(sparam_t param, const struct vec4 *val)
+void gs_shader_set_vec4(gs_sparam_t param, const struct vec4 *val)
 {
 	struct gs_shader *shader = param->shader;
 	glProgramUniform4fv(shader->program, param->param, 1, val->ptr);
 	gl_success("glProgramUniform4fv");
 }
 
-void shader_settexture(sparam_t param, texture_t val)
+void gs_shader_set_texture(gs_sparam_t param, gs_texture_t val)
 {
 	param->texture = val;
 }
 
-static void shader_setval_data(sparam_t param, const void *val, int count)
+static void shader_setval_data(gs_sparam_t param, const void *val, int count)
 {
 	struct gs_shader *shader = param->shader;
 
-	if (param->type == SHADER_PARAM_BOOL ||
-	    param->type == SHADER_PARAM_INT) {
+	if (param->type == GS_SHADER_PARAM_BOOL ||
+	    param->type == GS_SHADER_PARAM_INT) {
 		glProgramUniform1iv(shader->program, param->param, count, val);
 		gl_success("glProgramUniform1iv");
 
-	} else if (param->type == SHADER_PARAM_FLOAT) {
+	} else if (param->type == GS_SHADER_PARAM_FLOAT) {
 		glProgramUniform1fv(shader->program, param->param, count, val);
 		gl_success("glProgramUniform1fv");
 
-	} else if (param->type == SHADER_PARAM_VEC2) {
+	} else if (param->type == GS_SHADER_PARAM_VEC2) {
 		glProgramUniform2fv(shader->program, param->param, count, val);
 		gl_success("glProgramUniform2fv");
 
-	} else if (param->type == SHADER_PARAM_VEC3) {
+	} else if (param->type == GS_SHADER_PARAM_VEC3) {
 		glProgramUniform3fv(shader->program, param->param, count, val);
 		gl_success("glProgramUniform3fv");
 
-	} else if (param->type == SHADER_PARAM_VEC4) {
+	} else if (param->type == GS_SHADER_PARAM_VEC4) {
 		glProgramUniform4fv(shader->program, param->param, count, val);
 		gl_success("glProgramUniform4fv");
 
-	} else if (param->type == SHADER_PARAM_MATRIX4X4) {
+	} else if (param->type == GS_SHADER_PARAM_MATRIX4X4) {
 		glProgramUniformMatrix4fv(shader->program, param->param,
 				count, false, val);
 		gl_success("glProgramUniformMatrix4fv");
@@ -456,15 +460,15 @@ void shader_update_textures(struct gs_shader *shader)
 {
 	size_t i;
 	for (i = 0; i < shader->params.num; i++) {
-		struct shader_param *param = shader->params.array+i;
+		struct gs_shader_param *param = shader->params.array+i;
 
-		if (param->type == SHADER_PARAM_TEXTURE)
+		if (param->type == GS_SHADER_PARAM_TEXTURE)
 			device_load_texture(shader->device, param->texture,
 					param->texture_id);
 	}
 }
 
-void shader_setval(sparam_t param, const void *val, size_t size)
+void gs_shader_set_val(gs_sparam_t param, const void *val, size_t size)
 {
 	int count = param->array_count;
 	size_t expected_size = 0;
@@ -472,14 +476,14 @@ void shader_setval(sparam_t param, const void *val, size_t size)
 		count = 1;
 
 	switch ((uint32_t)param->type) {
-	case SHADER_PARAM_FLOAT:     expected_size = sizeof(float); break;
-	case SHADER_PARAM_BOOL:
-	case SHADER_PARAM_INT:       expected_size = sizeof(int); break;
-	case SHADER_PARAM_VEC2:      expected_size = sizeof(float)*2; break;
-	case SHADER_PARAM_VEC3:      expected_size = sizeof(float)*3; break;
-	case SHADER_PARAM_VEC4:      expected_size = sizeof(float)*4; break;
-	case SHADER_PARAM_MATRIX4X4: expected_size = sizeof(float)*4*4; break;
-	case SHADER_PARAM_TEXTURE:   expected_size = sizeof(void*); break;
+	case GS_SHADER_PARAM_FLOAT:     expected_size = sizeof(float); break;
+	case GS_SHADER_PARAM_BOOL:
+	case GS_SHADER_PARAM_INT:       expected_size = sizeof(int); break;
+	case GS_SHADER_PARAM_VEC2:      expected_size = sizeof(float)*2; break;
+	case GS_SHADER_PARAM_VEC3:      expected_size = sizeof(float)*3; break;
+	case GS_SHADER_PARAM_VEC4:      expected_size = sizeof(float)*4; break;
+	case GS_SHADER_PARAM_MATRIX4X4: expected_size = sizeof(float)*4*4;break;
+	case GS_SHADER_PARAM_TEXTURE:   expected_size = sizeof(void*); break;
 	default:                     expected_size = 0;
 	}
 
@@ -488,18 +492,18 @@ void shader_setval(sparam_t param, const void *val, size_t size)
 		return;
 
 	if (expected_size != size) {
-		blog(LOG_ERROR, "shader_setval (GL): Size of shader param does "
-		                "not match the size of the input");
+		blog(LOG_ERROR, "gs_shader_set_val (GL): Size of shader "
+		                "param does not match the size of the input");
 		return;
 	}
 
-	if (param->type == SHADER_PARAM_TEXTURE)
-		shader_settexture(param, *(texture_t*)val);
+	if (param->type == GS_SHADER_PARAM_TEXTURE)
+		gs_shader_set_texture(param, *(gs_texture_t*)val);
 	else
 		shader_setval_data(param, val, count);
 }
 
-void shader_setdefault(sparam_t param)
+void gs_shader_set_default(gs_sparam_t param)
 {
-	shader_setval(param, param->def_value.array, param->def_value.num);
+	gs_shader_set_val(param, param->def_value.array, param->def_value.num);
 }

libobs-opengl/gl-shaderparser.c

@@ -218,7 +218,7 @@ static void gl_write_struct(struct gl_shader_parser *glsp,
 
 static void gl_write_interface_block(struct gl_shader_parser *glsp)
 {
-	if (glsp->type == SHADER_VERTEX) {
+	if (glsp->type == GS_SHADER_VERTEX) {
 		dstr_cat(&glsp->gl_string, "out gl_PerVertex {\n"
 		                           "\tvec4 gl_Position;\n};\n\n");
 	}
@@ -470,7 +470,7 @@ static inline void gl_write_main_interface_assign(
 		const char *src)
 {
 	/* vertex shaders: write gl_Position */
-	if (glsp->type == SHADER_VERTEX &&
+	if (glsp->type == GS_SHADER_VERTEX &&
 	    strcmp(var->mapping, "POSITION") == 0) {
 		dstr_cat(&glsp->gl_string, "\tgl_Position = ");
 		dstr_cat(&glsp->gl_string, src);

libobs-opengl/gl-shaderparser.h

@@ -43,7 +43,7 @@ static inline void gl_parser_attrib_free(struct gl_parser_attrib *attr)
 }
 
 struct gl_shader_parser {
-	enum shader_type                type;
+	enum gs_shader_type             type;
 	const char                      *input_prefix;
 	const char                      *output_prefix;
 	struct shader_parser            parser;
@@ -54,14 +54,14 @@ struct gl_shader_parser {
 };
 
 static inline void gl_shader_parser_init(struct gl_shader_parser *glsp,
-		enum shader_type type)
+		enum gs_shader_type type)
 {
 	glsp->type = type;
 
-	if (type == SHADER_VERTEX) {
+	if (type == GS_SHADER_VERTEX) {
 		glsp->input_prefix  = "_input_attrib";
 		glsp->output_prefix = "_vertex_shader_attrib";
-	} else if (type == SHADER_PIXEL) {
+	} else if (type == GS_SHADER_PIXEL) {
 		glsp->input_prefix  = "_vertex_shader_attrib";
 		glsp->output_prefix = "_pixel_shader_attrib";
 	}

libobs-opengl/gl-stagesurf.c

@@ -42,7 +42,7 @@ static bool create_pixel_pack_buffer(struct gs_stage_surface *surf)
 	return success;
 }
 
-stagesurf_t device_create_stagesurface(device_t device, uint32_t width,
+gs_stagesurf_t device_stagesurface_create(gs_device_t device, uint32_t width,
 		uint32_t height, enum gs_color_format color_format)
 {
 	struct gs_stage_surface *surf;
@@ -57,15 +57,15 @@ stagesurf_t device_create_stagesurface(device_t device, uint32_t width,
 	surf->bytes_per_pixel    = gs_get_format_bpp(color_format)/8;
 
 	if (!create_pixel_pack_buffer(surf)) {
-		blog(LOG_ERROR, "device_create_stagesurface (GL) failed");
-		stagesurface_destroy(surf);
+		blog(LOG_ERROR, "device_stagesurface_create (GL) failed");
+		gs_stagesurface_destroy(surf);
 		return NULL;
 	}
 
 	return surf;
 }
 
-void stagesurface_destroy(stagesurf_t stagesurf)
+void gs_stagesurface_destroy(gs_stagesurf_t stagesurf)
 {
 	if (stagesurf) {
 		if (stagesurf->pack_buffer)
@@ -110,7 +110,8 @@ static bool can_stage(struct gs_stage_surface *dst, struct gs_texture_2d *src)
 
 /* Apparently for mac, PBOs won't do an asynchronous transfer unless you use
  * FBOs aong with glReadPixels, which is really dumb. */
-void device_stage_texture(device_t device, stagesurf_t dst, texture_t src)
+void device_stage_texture(gs_device_t device, gs_stagesurf_t dst,
+		gs_texture_t src)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)src;
 	struct fbo_info *fbo;
@@ -155,7 +156,8 @@ failed:
 
 #else
 
-void device_stage_texture(device_t device, stagesurf_t dst, texture_t src)
+void device_stage_texture(gs_device_t device, gs_stagesurf_t dst,
+		gs_texture_t src)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)src;
 	if (!can_stage(dst, tex2d))
@@ -184,22 +186,23 @@ failed:
 
 #endif
 
-uint32_t stagesurface_getwidth(stagesurf_t stagesurf)
+uint32_t gs_stagesurface_get_width(gs_stagesurf_t stagesurf)
 {
 	return stagesurf->width;
 }
 
-uint32_t stagesurface_getheight(stagesurf_t stagesurf)
+uint32_t gs_stagesurface_get_height(gs_stagesurf_t stagesurf)
 {
 	return stagesurf->height;
 }
 
-enum gs_color_format stagesurface_getcolorformat(stagesurf_t stagesurf)
+enum gs_color_format gs_stagesurface_get_color_format(gs_stagesurf_t stagesurf)
 {
 	return stagesurf->format;
 }
 
-bool stagesurface_map(stagesurf_t stagesurf, uint8_t **data, uint32_t *linesize)
+bool gs_stagesurface_map(gs_stagesurf_t stagesurf, uint8_t **data,
+		uint32_t *linesize)
 {
 	if (!gl_bind_buffer(GL_PIXEL_PACK_BUFFER, stagesurf->pack_buffer))
 		goto fail;
@@ -218,7 +221,7 @@ fail:
 	return false;
 }
 
-void stagesurface_unmap(stagesurf_t stagesurf)
+void gs_stagesurface_unmap(gs_stagesurf_t stagesurf)
 {
 	if (!gl_bind_buffer(GL_PIXEL_PACK_BUFFER, stagesurf->pack_buffer))
 		return;

libobs-opengl/gl-subsystem.c

@@ -182,12 +182,12 @@ void convert_sampler_info(struct gs_sampler_state *sampler,
 	               info->max_anisotropy, sampler->max_anisotropy);
 }
 
-const char *device_name(void)
+const char *device_get_name(void)
 {
 	return "OpenGL";
 }
 
-int device_type(void)
+int device_get_type(void)
 {
 	return GS_DEVICE_OPENGL;
 }
@@ -197,7 +197,7 @@ const char *device_preprocessor_name(void)
 	return "_OPENGL";
 }
 
-int device_create(device_t *p_device, struct gs_init_data *info)
+int device_create(gs_device_t *p_device, struct gs_init_data *info)
 {
 	struct gs_device *device = bzalloc(sizeof(struct gs_device));
 	int errorcode = GS_ERROR_FAIL;
@@ -221,7 +221,7 @@ int device_create(device_t *p_device, struct gs_init_data *info)
 	if (!gl_success("glBindProgramPipeline"))
 		goto fail;
 
-	device_leavecontext(device);
+	device_leave_context(device);
 	device->cur_swap = gl_platform_getswap(device->plat);
 
 	*p_device = device;
@@ -235,7 +235,7 @@ fail:
 	return errorcode;
 }
 
-void device_destroy(device_t device)
+void device_destroy(gs_device_t device)
 {
 	if (device) {
 		size_t i;
@@ -252,7 +252,8 @@ void device_destroy(device_t device)
 	}
 }
 
-swapchain_t device_create_swapchain(device_t device, struct gs_init_data *info)
+gs_swapchain_t device_swapchain_create(gs_device_t device,
+		struct gs_init_data *info)
 {
 	struct gs_swap_chain *swap = bzalloc(sizeof(struct gs_swap_chain));
 
@@ -260,21 +261,21 @@ swapchain_t device_create_swapchain(device_t device, struct gs_init_data *info)
 	swap->info   = *info;
 	swap->wi     = gl_windowinfo_create(info);
 	if (!swap->wi) {
-		blog(LOG_ERROR, "device_create_swapchain (GL) failed");
-		swapchain_destroy(swap);
+		blog(LOG_ERROR, "device_swapchain_create (GL) failed");
+		gs_swapchain_destroy(swap);
 		return NULL;
 	}
 
 	if (!gl_platform_init_swapchain(swap)) {
 		blog(LOG_ERROR, "gl_platform_init_swapchain  failed");
-		swapchain_destroy(swap);
+		gs_swapchain_destroy(swap);
 		return NULL;
 	}
 
 	return swap;
 }
 
-void device_resize(device_t device, uint32_t cx, uint32_t cy)
+void device_resize(gs_device_t device, uint32_t cx, uint32_t cy)
 {
 	/* GL automatically resizes the device, so it doesn't do much */
 	device->cur_swap->info.cx = cx;
@@ -283,23 +284,23 @@ void device_resize(device_t device, uint32_t cx, uint32_t cy)
 	gl_update(device);
 }
 
-void device_getsize(device_t device, uint32_t *cx, uint32_t *cy)
+void device_get_size(gs_device_t device, uint32_t *cx, uint32_t *cy)
 {
 	*cx = device->cur_swap->info.cx;
 	*cy = device->cur_swap->info.cy;
 }
 
-uint32_t device_getwidth(device_t device)
+uint32_t device_get_width(gs_device_t device)
 {
 	return device->cur_swap->info.cx;
 }
 
-uint32_t device_getheight(device_t device)
+uint32_t device_get_height(gs_device_t device)
 {
 	return device->cur_swap->info.cy;
 }
 
-texture_t device_create_volumetexture(device_t device, uint32_t width,
+gs_texture_t device_voltexture_create(gs_device_t device, uint32_t width,
 		uint32_t height, uint32_t depth,
 		enum gs_color_format color_format, uint32_t levels,
 		const uint8_t **data, uint32_t flags)
@@ -316,7 +317,7 @@ texture_t device_create_volumetexture(device_t device, uint32_t width,
 	return NULL;
 }
 
-samplerstate_t device_create_samplerstate(device_t device,
+gs_samplerstate_t device_samplerstate_create(gs_device_t device,
 		struct gs_sampler_info *info)
 {
 	struct gs_sampler_state *sampler;
@@ -329,7 +330,7 @@ samplerstate_t device_create_samplerstate(device_t device,
 	return sampler;
 }
 
-enum gs_texture_type device_gettexturetype(texture_t texture)
+enum gs_texture_type device_get_texture_type(gs_texture_t texture)
 {
 	return texture->type;
 }
@@ -362,7 +363,7 @@ static inline void apply_swizzle(struct gs_texture *tex)
 	}
 }
 
-static bool load_texture_sampler(texture_t tex, samplerstate_t ss)
+static bool load_texture_sampler(gs_texture_t tex, gs_samplerstate_t ss)
 {
 	bool  success = true;
 	GLint min_filter;
@@ -379,7 +380,7 @@ static bool load_texture_sampler(texture_t tex, samplerstate_t ss)
 	samplerstate_addref(ss);
 
 	min_filter = ss->min_filter;
-	if (texture_isrect(tex))
+	if (gs_texture_is_rect(tex))
 		strip_mipmap_filter(&min_filter);
 
 	if (!gl_tex_param_i(tex->gl_target, GL_TEXTURE_MIN_FILTER,
@@ -403,14 +404,15 @@ static bool load_texture_sampler(texture_t tex, samplerstate_t ss)
 	return success;
 }
 
-static inline struct shader_param *get_texture_param(device_t device, int unit)
+static inline struct gs_shader_param *get_texture_param(gs_device_t device,
+		int unit)
 {
 	struct gs_shader *shader = device->cur_pixel_shader;
 	size_t i;
 
 	for (i = 0; i < shader->params.num; i++) {
-		struct shader_param *param = shader->params.array+i;
-		if (param->type == SHADER_PARAM_TEXTURE) {
+		struct gs_shader_param *param = shader->params.array+i;
+		if (param->type == GS_SHADER_PARAM_TEXTURE) {
 			if (param->texture_id == unit)
 				return param;
 		}
@@ -419,9 +421,9 @@ static inline struct shader_param *get_texture_param(device_t device, int unit)
 	return NULL;
 }
 
-void device_load_texture(device_t device, texture_t tex, int unit)
+void device_load_texture(gs_device_t device, gs_texture_t tex, int unit)
 {
-	struct shader_param *param;
+	struct gs_shader_param *param;
 	struct gs_sampler_state *sampler;
 	struct gs_texture *cur_tex = device->cur_textures[unit];
 
@@ -463,16 +465,16 @@ fail:
 	blog(LOG_ERROR, "device_load_texture (GL) failed");
 }
 
-static bool load_sampler_on_textures(device_t device, samplerstate_t ss,
+static bool load_sampler_on_textures(gs_device_t device, gs_samplerstate_t ss,
 		int sampler_unit)
 {
 	struct gs_shader *shader = device->cur_pixel_shader;
 	size_t i;
 
 	for (i = 0; i < shader->params.num; i++) {
-		struct shader_param *param = shader->params.array+i;
+		struct gs_shader_param *param = shader->params.array+i;
 
-		if (param->type == SHADER_PARAM_TEXTURE &&
+		if (param->type == GS_SHADER_PARAM_TEXTURE &&
 		    param->sampler_id == (uint32_t)sampler_unit &&
 		    param->texture) {
 			if (!gl_active_texture(GL_TEXTURE0 + param->texture_id))
@@ -485,7 +487,8 @@ static bool load_sampler_on_textures(device_t device, samplerstate_t ss,
 	return true;
 }
 
-void device_load_samplerstate(device_t device, samplerstate_t ss, int unit)
+void device_load_samplerstate(gs_device_t device, gs_samplerstate_t ss,
+		int unit)
 {
 	/* need a pixel shader to properly bind samplers */
 	if (!device->cur_pixel_shader)
@@ -505,15 +508,15 @@ void device_load_samplerstate(device_t device, samplerstate_t ss, int unit)
 	return;
 }
 
-void device_load_vertexshader(device_t device, shader_t vertshader)
+void device_load_vertexshader(gs_device_t device, gs_shader_t vertshader)
 {
 	GLuint program = 0;
-	vertbuffer_t cur_vb = device->cur_vertex_buffer;
+	gs_vertbuffer_t cur_vb = device->cur_vertex_buffer;
 
 	if (device->cur_vertex_shader == vertshader)
 		return;
 
-	if (vertshader && vertshader->type != SHADER_VERTEX) {
+	if (vertshader && vertshader->type != GS_SHADER_VERTEX) {
 		blog(LOG_ERROR, "Specified shader is not a vertex shader");
 		goto fail;
 	}
@@ -557,13 +560,13 @@ static void load_default_pixelshader_samplers(struct gs_device *device,
 		device->cur_samplers[i] = NULL;
 }
 
-void device_load_pixelshader(device_t device, shader_t pixelshader)
+void device_load_pixelshader(gs_device_t device, gs_shader_t pixelshader)
 {
 	GLuint program = 0;
 	if (device->cur_pixel_shader == pixelshader)
 		return;
 
-	if (pixelshader && pixelshader->type != SHADER_PIXEL) {
+	if (pixelshader && pixelshader->type != GS_SHADER_PIXEL) {
 		blog(LOG_ERROR, "Specified shader is not a pixel shader");
 		goto fail;
 	}
@@ -587,7 +590,7 @@ fail:
 	blog(LOG_ERROR, "device_load_pixelshader (GL) failed");
 }
 
-void device_load_defaultsamplerstate(device_t device, bool b_3d, int unit)
+void device_load_default_samplerstate(gs_device_t device, bool b_3d, int unit)
 {
 	/* TODO */
 	UNUSED_PARAMETER(device);
@@ -595,27 +598,28 @@ void device_load_defaultsamplerstate(device_t device, bool b_3d, int unit)
 	UNUSED_PARAMETER(unit);
 }
 
-shader_t device_getvertexshader(device_t device)
+gs_shader_t device_get_vertex_shader(gs_device_t device)
 {
 	return device->cur_vertex_shader;
 }
 
-shader_t device_getpixelshader(device_t device)
+gs_shader_t device_get_pixel_shader(gs_device_t device)
 {
 	return device->cur_pixel_shader;
 }
 
-texture_t device_getrendertarget(device_t device)
+gs_texture_t device_get_render_target(gs_device_t device)
 {
 	return device->cur_render_target;
 }
 
-zstencil_t device_getzstenciltarget(device_t device)
+gs_zstencil_t device_get_zstencil_target(gs_device_t device)
 {
 	return device->cur_zstencil_buffer;
 }
 
-static bool get_tex_dimensions(texture_t tex, uint32_t *width, uint32_t *height)
+static bool get_tex_dimensions(gs_texture_t tex, uint32_t *width,
+		uint32_t *height)
 {
 	if (tex->type == GS_TEXTURE_2D) {
 		struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
@@ -671,7 +675,7 @@ struct fbo_info *get_fbo(struct gs_device *device,
 }
 
 static inline struct fbo_info *get_fbo_by_tex(struct gs_device *device,
-		texture_t tex)
+		gs_texture_t tex)
 {
 	uint32_t width, height;
 	if (!get_tex_dimensions(tex, &width, &height))
@@ -680,7 +684,7 @@ static inline struct fbo_info *get_fbo_by_tex(struct gs_device *device,
 	return get_fbo(device, width, height, tex->format);
 }
 
-static bool set_current_fbo(device_t device, struct fbo_info *fbo)
+static bool set_current_fbo(gs_device_t device, struct fbo_info *fbo)
 {
 	if (device->cur_fbo != fbo) {
 		GLuint fbo_obj = fbo ? fbo->fbo : 0;
@@ -692,7 +696,8 @@ static bool set_current_fbo(device_t device, struct fbo_info *fbo)
 	return true;
 }
 
-static bool attach_rendertarget(struct fbo_info *fbo, texture_t tex, int side)
+static bool attach_rendertarget(struct fbo_info *fbo, gs_texture_t tex,
+		int side)
 {
 	if (fbo->cur_render_target == tex)
 		return true;
@@ -717,7 +722,7 @@ static bool attach_rendertarget(struct fbo_info *fbo, texture_t tex, int side)
 	return gl_success("glFramebufferTexture2D");
 }
 
-static bool attach_zstencil(struct fbo_info *fbo, zstencil_t zs)
+static bool attach_zstencil(struct fbo_info *fbo, gs_zstencil_t zs)
 {
 	GLuint zsbuffer = 0;
 	GLenum zs_attachment = GL_DEPTH_STENCIL_ATTACHMENT;
@@ -740,7 +745,8 @@ static bool attach_zstencil(struct fbo_info *fbo, zstencil_t zs)
 	return true;
 }
 
-static bool set_target(device_t device, texture_t tex, int side, zstencil_t zs)
+static bool set_target(gs_device_t device, gs_texture_t tex, int side,
+		gs_zstencil_t zs)
 {
 	struct fbo_info *fbo;
 
@@ -770,7 +776,8 @@ static bool set_target(device_t device, texture_t tex, int side, zstencil_t zs)
 	return true;
 }
 
-void device_setrendertarget(device_t device, texture_t tex, zstencil_t zstencil)
+void device_set_render_target(gs_device_t device, gs_texture_t tex,
+		gs_zstencil_t zstencil)
 {
 	if (tex) {
 		if (tex->type != GS_TEXTURE_2D) {
@@ -790,11 +797,11 @@ void device_setrendertarget(device_t device, texture_t tex, zstencil_t zstencil)
 	return;
 
 fail:
-	blog(LOG_ERROR, "device_setrendertarget (GL) failed");
+	blog(LOG_ERROR, "device_set_render_target (GL) failed");
 }
 
-void device_setcuberendertarget(device_t device, texture_t cubetex,
-		int side, zstencil_t zstencil)
+void device_set_cube_render_target(gs_device_t device, gs_texture_t cubetex,
+		int side, gs_zstencil_t zstencil)
 {
 	if (cubetex) {
 		if (cubetex->type != GS_TEXTURE_CUBE) {
@@ -814,12 +821,12 @@ void device_setcuberendertarget(device_t device, texture_t cubetex,
 	return;
 
 fail:
-	blog(LOG_ERROR, "device_setcuberendertarget (GL) failed");
+	blog(LOG_ERROR, "device_set_cube_render_target (GL) failed");
 }
 
-void device_copy_texture_region(device_t device,
-		texture_t dst, uint32_t dst_x, uint32_t dst_y,
-		texture_t src, uint32_t src_x, uint32_t src_y,
+void device_copy_texture_region(gs_device_t device,
+		gs_texture_t dst, uint32_t dst_x, uint32_t dst_y,
+		gs_texture_t src, uint32_t src_x, uint32_t src_y,
 		uint32_t src_w, uint32_t src_h)
 {
 	struct gs_texture_2d *src2d = (struct gs_texture_2d*)src;
@@ -851,7 +858,7 @@ void device_copy_texture_region(device_t device,
 
 	if (dst2d->width - dst_x < nw || dst2d->height - dst_y < nh) {
 		blog(LOG_ERROR, "Destination texture region is not big "
-						"enough to hold the source region");
+		                "enough to hold the source region");
 		goto fail;
 	}
 
@@ -866,17 +873,17 @@ fail:
 	blog(LOG_ERROR, "device_copy_texture (GL) failed");
 }
 
-void device_copy_texture(device_t device, texture_t dst, texture_t src)
+void device_copy_texture(gs_device_t device, gs_texture_t dst, gs_texture_t src)
 {
 	device_copy_texture_region(device, dst, 0, 0, src, 0, 0, 0, 0);
 }
 
-void device_beginscene(device_t device)
+void device_begin_scene(gs_device_t device)
 {
 	clear_textures(device);
 }
 
-static inline bool can_render(device_t device)
+static inline bool can_render(gs_device_t device)
 {
 	if (!device->cur_vertex_shader) {
 		blog(LOG_ERROR, "No vertex shader specified");
@@ -906,10 +913,10 @@ static void update_viewproj_matrix(struct gs_device *device)
 	matrix4_transpose(&device->cur_viewproj, &device->cur_viewproj);
 
 	if (vs->viewproj)
-		shader_setmatrix4(vs->viewproj, &device->cur_viewproj);
+		gs_shader_set_matrix4(vs->viewproj, &device->cur_viewproj);
 }
 
-static inline bool check_shader_pipeline_validity(device_t device)
+static inline bool check_shader_pipeline_validity(gs_device_t device)
 {
 	int valid = false;
 
@@ -927,18 +934,18 @@ static inline bool check_shader_pipeline_validity(device_t device)
 	return valid != 0;
 }
 
-void device_draw(device_t device, enum gs_draw_mode draw_mode,
+void device_draw(gs_device_t device, enum gs_draw_mode draw_mode,
 		uint32_t start_vert, uint32_t num_verts)
 {
 	struct gs_index_buffer *ib = device->cur_index_buffer;
 	GLenum  topology = convert_gs_topology(draw_mode);
-	effect_t effect = gs_geteffect();
+	gs_effect_t effect = gs_get_effect();
 
 	if (!can_render(device))
 		goto fail;
 
 	if (effect)
-		effect_updateparams(effect);
+		gs_effect_update_params(effect);
 
 	shader_update_textures(device->cur_pixel_shader);
 
@@ -972,13 +979,13 @@ fail:
 	blog(LOG_ERROR, "device_draw (GL) failed");
 }
 
-void device_endscene(device_t device)
+void device_end_scene(gs_device_t device)
 {
 	/* does nothing */
 	UNUSED_PARAMETER(device);
 }
 
-void device_clear(device_t device, uint32_t clear_flags,
+void device_clear(gs_device_t device, uint32_t clear_flags,
 		struct vec4 *color, float depth, uint8_t stencil)
 {
 	GLbitfield gl_flags = 0;
@@ -1005,14 +1012,14 @@ void device_clear(device_t device, uint32_t clear_flags,
 	UNUSED_PARAMETER(device);
 }
 
-void device_flush(device_t device)
+void device_flush(gs_device_t device)
 {
 	glFlush();
 
 	UNUSED_PARAMETER(device);
 }
 
-void device_setcullmode(device_t device, enum gs_cull_mode mode)
+void device_set_cull_mode(gs_device_t device, enum gs_cull_mode mode)
 {
 	if (device->cur_cull_mode == mode)
 		return;
@@ -1030,12 +1037,12 @@ void device_setcullmode(device_t device, enum gs_cull_mode mode)
 		gl_disable(GL_CULL_FACE);
 }
 
-enum gs_cull_mode device_getcullmode(device_t device)
+enum gs_cull_mode device_get_cull_mode(gs_device_t device)
 {
 	return device->cur_cull_mode;
 }
 
-void device_enable_blending(device_t device, bool enable)
+void device_enable_blending(gs_device_t device, bool enable)
 {
 	if (enable)
 		gl_enable(GL_BLEND);
@@ -1045,7 +1052,7 @@ void device_enable_blending(device_t device, bool enable)
 	UNUSED_PARAMETER(device);
 }
 
-void device_enable_depthtest(device_t device, bool enable)
+void device_enable_depth_test(gs_device_t device, bool enable)
 {
 	if (enable)
 		gl_enable(GL_DEPTH_TEST);
@@ -1055,7 +1062,7 @@ void device_enable_depthtest(device_t device, bool enable)
 	UNUSED_PARAMETER(device);
 }
 
-void device_enable_stenciltest(device_t device, bool enable)
+void device_enable_stencil_test(gs_device_t device, bool enable)
 {
 	if (enable)
 		gl_enable(GL_STENCIL_TEST);
@@ -1065,7 +1072,7 @@ void device_enable_stenciltest(device_t device, bool enable)
 	UNUSED_PARAMETER(device);
 }
 
-void device_enable_stencilwrite(device_t device, bool enable)
+void device_enable_stencil_write(gs_device_t device, bool enable)
 {
 	if (enable)
 		glStencilMask(0xFFFFFFFF);
@@ -1075,7 +1082,7 @@ void device_enable_stencilwrite(device_t device, bool enable)
 	UNUSED_PARAMETER(device);
 }
 
-void device_enable_color(device_t device, bool red, bool green,
+void device_enable_color(gs_device_t device, bool red, bool green,
 		bool blue, bool alpha)
 {
 	glColorMask(red, green, blue, alpha);
@@ -1083,7 +1090,7 @@ void device_enable_color(device_t device, bool red, bool green,
 	UNUSED_PARAMETER(device);
 }
 
-void device_blendfunction(device_t device, enum gs_blend_type src,
+void device_blend_function(gs_device_t device, enum gs_blend_type src,
 		enum gs_blend_type dest)
 {
 	GLenum gl_src = convert_gs_blend_type(src);
@@ -1091,23 +1098,23 @@ void device_blendfunction(device_t device, enum gs_blend_type src,
 
 	glBlendFunc(gl_src, gl_dst);
 	if (!gl_success("glBlendFunc"))
-		blog(LOG_ERROR, "device_blendfunction (GL) failed");
+		blog(LOG_ERROR, "device_blend_function (GL) failed");
 
 	UNUSED_PARAMETER(device);
 }
 
-void device_depthfunction(device_t device, enum gs_depth_test test)
+void device_depth_function(gs_device_t device, enum gs_depth_test test)
 {
 	GLenum gl_test = convert_gs_depth_test(test);
 
 	glDepthFunc(gl_test);
 	if (!gl_success("glDepthFunc"))
-		blog(LOG_ERROR, "device_depthfunction (GL) failed");
+		blog(LOG_ERROR, "device_depth_function (GL) failed");
 
 	UNUSED_PARAMETER(device);
 }
 
-void device_stencilfunction(device_t device, enum gs_stencil_side side,
+void device_stencil_function(gs_device_t device, enum gs_stencil_side side,
 		enum gs_depth_test test)
 {
 	GLenum gl_side = convert_gs_stencil_side(side);
@@ -1115,14 +1122,14 @@ void device_stencilfunction(device_t device, enum gs_stencil_side side,
 
 	glStencilFuncSeparate(gl_side, gl_test, 0, 0xFFFFFFFF);
 	if (!gl_success("glStencilFuncSeparate"))
-		blog(LOG_ERROR, "device_stencilfunction (GL) failed");
+		blog(LOG_ERROR, "device_stencil_function (GL) failed");
 
 	UNUSED_PARAMETER(device);
 }
 
-void device_stencilop(device_t device, enum gs_stencil_side side,
-		enum gs_stencil_op fail, enum gs_stencil_op zfail,
-		enum gs_stencil_op zpass)
+void device_stencil_op(gs_device_t device, enum gs_stencil_side side,
+		enum gs_stencil_op_type fail, enum gs_stencil_op_type zfail,
+		enum gs_stencil_op_type zpass)
 {
 	GLenum gl_side  = convert_gs_stencil_side(side);
 	GLenum gl_fail  = convert_gs_stencil_op(fail);
@@ -1131,7 +1138,7 @@ void device_stencilop(device_t device, enum gs_stencil_side side,
 
 	glStencilOpSeparate(gl_side, gl_fail, gl_zfail, gl_zpass);
 	if (!gl_success("glStencilOpSeparate"))
-		blog(LOG_ERROR, "device_stencilop (GL) failed");
+		blog(LOG_ERROR, "device_stencil_op (GL) failed");
 
 	UNUSED_PARAMETER(device);
 }
@@ -1139,15 +1146,15 @@ void device_stencilop(device_t device, enum gs_stencil_side side,
 static inline uint32_t get_target_height(struct gs_device *device)
 {
 	if (!device->cur_render_target)
-		return device_getheight(device);
+		return device_get_height(device);
 
 	if (device->cur_render_target->type == GS_TEXTURE_2D)
-		return texture_getheight(device->cur_render_target);
+		return gs_texture_get_height(device->cur_render_target);
 	else /* cube map */
-		return cubetexture_getsize(device->cur_render_target);
+		return gs_cubetexture_get_size(device->cur_render_target);
 }
 
-void device_setviewport(device_t device, int x, int y, int width,
+void device_set_viewport(gs_device_t device, int x, int y, int width,
 		int height)
 {
 	uint32_t base_height;
@@ -1162,7 +1169,7 @@ void device_setviewport(device_t device, int x, int y, int width,
 
 	glViewport(x, base_height - y - height, width, height);
 	if (!gl_success("glViewport"))
-		blog(LOG_ERROR, "device_setviewport (GL) failed");
+		blog(LOG_ERROR, "device_set_viewport (GL) failed");
 
 	device->cur_viewport.x  = x;
 	device->cur_viewport.y  = y;
@@ -1170,12 +1177,12 @@ void device_setviewport(device_t device, int x, int y, int width,
 	device->cur_viewport.cy = height;
 }
 
-void device_getviewport(device_t device, struct gs_rect *rect)
+void device_get_viewport(gs_device_t device, struct gs_rect *rect)
 {
 	*rect = device->cur_viewport;
 }
 
-void device_setscissorrect(device_t device, struct gs_rect *rect)
+void device_set_scissor_rect(gs_device_t device, struct gs_rect *rect)
 {
 	UNUSED_PARAMETER(device);
 
@@ -1188,10 +1195,10 @@ void device_setscissorrect(device_t device, struct gs_rect *rect)
 		return;
 	}
 
-	blog(LOG_ERROR, "device_setscissorrect (GL) failed");
+	blog(LOG_ERROR, "device_set_scissor_rect (GL) failed");
 }
 
-void device_ortho(device_t device, float left, float right,
+void device_ortho(gs_device_t device, float left, float right,
 		float top, float bottom, float near, float far)
 {
 	struct matrix4 *dst = &device->cur_proj;
@@ -1217,7 +1224,7 @@ void device_ortho(device_t device, float left, float right,
 	dst->t.w = 1.0f;
 }
 
-void device_frustum(device_t device, float left, float right,
+void device_frustum(gs_device_t device, float left, float right,
 		float top, float bottom, float near, float far)
 {
 	struct matrix4 *dst = &device->cur_proj;
@@ -1244,12 +1251,12 @@ void device_frustum(device_t device, float left, float right,
 	dst->z.w = -1.0f;
 }
 
-void device_projection_push(device_t device)
+void device_projection_push(gs_device_t device)
 {
 	da_push_back(device->proj_stack, &device->cur_proj);
 }
 
-void device_projection_pop(device_t device)
+void device_projection_pop(gs_device_t device)
 {
 	struct matrix4 *end;
 	if (!device->proj_stack.num)
@@ -1260,7 +1267,7 @@ void device_projection_pop(device_t device)
 	da_pop_back(device->proj_stack);
 }
 
-void swapchain_destroy(swapchain_t swapchain)
+void gs_swapchain_destroy(gs_swapchain_t swapchain)
 {
 	if (!swapchain)
 		return;
@@ -1274,41 +1281,41 @@ void swapchain_destroy(swapchain_t swapchain)
 	bfree(swapchain);
 }
 
-void volumetexture_destroy(texture_t voltex)
+void gs_voltexture_destroy(gs_texture_t voltex)
 {
 	/* TODO */
 	UNUSED_PARAMETER(voltex);
 }
 
-uint32_t volumetexture_getwidth(texture_t voltex)
+uint32_t gs_voltexture_get_width(gs_texture_t voltex)
 {
 	/* TODO */
 	UNUSED_PARAMETER(voltex);
 	return 0;
 }
 
-uint32_t volumetexture_getheight(texture_t voltex)
+uint32_t gs_voltexture_get_height(gs_texture_t voltex)
 {
 	/* TODO */
 	UNUSED_PARAMETER(voltex);
 	return 0;
 }
 
-uint32_t volumetexture_getdepth(texture_t voltex)
+uint32_t gs_voltexture_getdepth(gs_texture_t voltex)
 {
 	/* TODO */
 	UNUSED_PARAMETER(voltex);
 	return 0;
 }
 
-enum gs_color_format volumetexture_getcolorformat(texture_t voltex)
+enum gs_color_format gs_voltexture_get_color_format(gs_texture_t voltex)
 {
 	/* TODO */
 	UNUSED_PARAMETER(voltex);
 	return GS_UNKNOWN;
 }
 
-void samplerstate_destroy(samplerstate_t samplerstate)
+void gs_samplerstate_destroy(gs_samplerstate_t samplerstate)
 {
 	if (!samplerstate)
 		return;

libobs-opengl/gl-subsystem.h

@@ -143,7 +143,7 @@ static inline GLenum convert_gs_depth_test(enum gs_depth_test test)
 	return GL_NEVER;
 }
 
-static inline GLenum convert_gs_stencil_op(enum gs_stencil_op op)
+static inline GLenum convert_gs_stencil_op(enum gs_stencil_op_type op)
 {
 	switch (op) {
 	case GS_KEEP:    return GL_KEEP;
@@ -187,11 +187,11 @@ static inline GLenum convert_gs_blend_type(enum gs_blend_type type)
 	return GL_ONE;
 }
 
-static inline GLenum convert_shader_type(enum shader_type type)
+static inline GLenum convert_shader_type(enum gs_shader_type type)
 {
 	switch (type) {
-	case SHADER_VERTEX: return GL_VERTEX_SHADER;
-	case SHADER_PIXEL:  return GL_FRAGMENT_SHADER;
+	case GS_SHADER_VERTEX: return GL_VERTEX_SHADER;
+	case GS_SHADER_PIXEL:  return GL_FRAGMENT_SHADER;
 	}
 
 	return GL_VERTEX_SHADER;
@@ -273,7 +273,7 @@ extern void convert_sampler_info(struct gs_sampler_state *sampler,
 		struct gs_sampler_info *info);
 
 struct gs_sampler_state {
-	device_t             device;
+	gs_device_t          device;
 	volatile long        ref;
 
 	GLint                min_filter;
@@ -284,22 +284,22 @@ struct gs_sampler_state {
 	GLint                max_anisotropy;
 };
 
-static inline void samplerstate_addref(samplerstate_t ss)
+static inline void samplerstate_addref(gs_samplerstate_t ss)
 {
 	os_atomic_inc_long(&ss->ref);
 }
 
-static inline void samplerstate_release(samplerstate_t ss)
+static inline void samplerstate_release(gs_samplerstate_t ss)
 {
 	if (os_atomic_dec_long(&ss->ref) == 0)
 		bfree(ss);
 }
 
-struct shader_param {
-	enum shader_param_type type;
+struct gs_shader_param {
+	enum gs_shader_param_type type;
 
 	char                 *name;
-	shader_t             shader;
+	gs_shader_t          shader;
 	GLint                param;
 	GLint                texture_id;
 	size_t               sampler_id;
@@ -328,16 +328,16 @@ struct shader_attrib {
 };
 
 struct gs_shader {
-	device_t             device;
-	enum shader_type     type;
+	gs_device_t          device;
+	enum gs_shader_type  type;
 	GLuint               program;
 
-	struct shader_param  *viewproj;
-	struct shader_param  *world;
+	struct gs_shader_param  *viewproj;
+	struct gs_shader_param  *world;
 
-	DARRAY(struct shader_attrib) attribs;
-	DARRAY(struct shader_param)  params;
-	DARRAY(samplerstate_t)       samplers;
+	DARRAY(struct shader_attrib)    attribs;
+	DARRAY(struct gs_shader_param)  params;
+	DARRAY(gs_samplerstate_t)       samplers;
 };
 
 extern void shader_update_textures(struct gs_shader *shader);
@@ -351,20 +351,20 @@ struct gs_vertex_buffer {
 	DARRAY(GLuint)       uv_buffers;
 	DARRAY(size_t)       uv_sizes;
 
-	device_t             device;
+	gs_device_t          device;
 	size_t               num;
 	bool                 dynamic;
-	struct vb_data       *data;
+	struct gs_vb_data    *data;
 };
 
-extern bool vertexbuffer_load(device_t device, vertbuffer_t vb);
+extern bool vertexbuffer_load(gs_device_t device, gs_vertbuffer_t vb);
 
 struct gs_index_buffer {
 	GLuint               buffer;
 	enum gs_index_type   type;
 	GLuint               gl_type;
 
-	device_t             device;
+	gs_device_t          device;
 	void                 *data;
 	size_t               num;
 	size_t               width;
@@ -373,7 +373,7 @@ struct gs_index_buffer {
 };
 
 struct gs_texture {
-	device_t             device;
+	gs_device_t          device;
 	enum gs_texture_type type;
 	enum gs_color_format format;
 	GLenum               gl_format;
@@ -387,7 +387,7 @@ struct gs_texture {
 	bool                 is_dummy;
 	bool                 gen_mipmaps;
 
-	samplerstate_t       cur_sampler;
+	gs_samplerstate_t    cur_sampler;
 };
 
 struct gs_texture_2d {
@@ -406,7 +406,7 @@ struct gs_texture_cube {
 };
 
 struct gs_stage_surface {
-	device_t             device;
+	gs_device_t          device;
 
 	enum gs_color_format format;
 	uint32_t             width;
@@ -420,14 +420,14 @@ struct gs_stage_surface {
 };
 
 struct gs_zstencil_buffer {
-	device_t             device;
+	gs_device_t          device;
 	GLuint               buffer;
 	GLuint               attachment;
 	GLenum               format;
 };
 
 struct gs_swap_chain {
-	device_t             device;
+	gs_device_t             device;
 	struct gl_windowinfo *wi;
 	struct gs_init_data  info;
 };
@@ -438,9 +438,9 @@ struct fbo_info {
 	uint32_t             height;
 	enum gs_color_format format;
 
-	texture_t            cur_render_target;
+	gs_texture_t         cur_render_target;
 	int                  cur_render_side;
-	zstencil_t           cur_zstencil_buffer;
+	gs_zstencil_t        cur_zstencil_buffer;
 };
 
 static inline void fbo_info_destroy(struct fbo_info *fbo)
@@ -458,16 +458,16 @@ struct gs_device {
 	GLuint               pipeline;
 	enum copy_type       copy_type;
 
-	texture_t            cur_render_target;
-	zstencil_t           cur_zstencil_buffer;
+	gs_texture_t         cur_render_target;
+	gs_zstencil_t        cur_zstencil_buffer;
 	int                  cur_render_side;
-	texture_t            cur_textures[GS_MAX_TEXTURES];
-	samplerstate_t       cur_samplers[GS_MAX_TEXTURES];
-	vertbuffer_t         cur_vertex_buffer;
-	indexbuffer_t        cur_index_buffer;
-	shader_t             cur_vertex_shader;
-	shader_t             cur_pixel_shader;
-	swapchain_t          cur_swap;
+	gs_texture_t         cur_textures[GS_MAX_TEXTURES];
+	gs_samplerstate_t    cur_samplers[GS_MAX_TEXTURES];
+	gs_vertbuffer_t      cur_vertex_buffer;
+	gs_indexbuffer_t     cur_index_buffer;
+	gs_shader_t          cur_vertex_shader;
+	gs_shader_t          cur_pixel_shader;
+	gs_swapchain_t       cur_swap;
 
 	enum gs_cull_mode    cur_cull_mode;
 	struct gs_rect       cur_viewport;
@@ -485,9 +485,9 @@ struct gs_device {
 extern struct fbo_info *get_fbo(struct gs_device *device,
 		uint32_t width, uint32_t height, enum gs_color_format format);
 
-extern void                  gl_update(device_t device);
+extern void                  gl_update(gs_device_t device);
 
-extern struct gl_platform   *gl_platform_create(device_t device,
+extern struct gl_platform   *gl_platform_create(gs_device_t device,
                                                 struct gs_init_data *info);
 extern struct gs_swap_chain *gl_platform_getswap(struct gl_platform *platform);
 extern void                  gl_platform_destroy(struct gl_platform *platform);

libobs-opengl/gl-texture2d.c

@@ -26,7 +26,7 @@ static bool upload_texture_2d(struct gs_texture_2d *tex, const uint8_t **data)
 	bool     success;
 
 	if (!num_levels)
-		num_levels = gs_num_total_levels(tex->width, tex->height);
+		num_levels = gs_get_total_levels(tex->width, tex->height);
 
 	if (!gl_bind_texture(GL_TEXTURE_2D, tex->base.texture))
 		return false;
@@ -74,7 +74,7 @@ static bool create_pixel_unpack_buffer(struct gs_texture_2d *tex)
 	return success;
 }
 
-texture_t device_create_texture(device_t device, uint32_t width,
+gs_texture_t device_texture_create(gs_device_t device, uint32_t width,
 		uint32_t height, enum gs_color_format color_format,
 		uint32_t levels, const uint8_t **data, uint32_t flags)
 {
@@ -87,10 +87,10 @@ texture_t device_create_texture(device_t device, uint32_t width,
 	tex->base.gl_internal_format = convert_gs_internal_format(color_format);
 	tex->base.gl_type            = get_gl_format_type(color_format);
 	tex->base.gl_target          = GL_TEXTURE_2D;
-	tex->base.is_dynamic         = (flags & GS_DYNAMIC)      != 0;
-	tex->base.is_render_target   = (flags & GS_RENDERTARGET) != 0;
-	tex->base.is_dummy           = (flags & GS_GL_DUMMYTEX)  != 0;
-	tex->base.gen_mipmaps        = (flags & GS_BUILDMIPMAPS) != 0;
+	tex->base.is_dynamic         = (flags & GS_DYNAMIC)       != 0;
+	tex->base.is_render_target   = (flags & GS_RENDER_TARGET) != 0;
+	tex->base.is_dummy           = (flags & GS_GL_DUMMYTEX)   != 0;
+	tex->base.gen_mipmaps        = (flags & GS_BUILD_MIPMAPS) != 0;
 	tex->width                   = width;
 	tex->height                  = height;
 
@@ -104,15 +104,15 @@ texture_t device_create_texture(device_t device, uint32_t width,
 			goto fail;
 	}
 
-	return (texture_t)tex;
+	return (gs_texture_t)tex;
 
 fail:
-	texture_destroy((texture_t)tex);
-	blog(LOG_ERROR, "device_create_texture (GL) failed");
+	gs_texture_destroy((gs_texture_t)tex);
+	blog(LOG_ERROR, "device_texture_create (GL) failed");
 	return NULL;
 }
 
-static inline bool is_texture_2d(texture_t tex, const char *func)
+static inline bool is_texture_2d(gs_texture_t tex, const char *func)
 {
 	bool is_tex2d = tex->type == GS_TEXTURE_2D;
 	if (!is_tex2d)
@@ -120,17 +120,17 @@ static inline bool is_texture_2d(texture_t tex, const char *func)
 	return is_tex2d;
 }
 
-void texture_destroy(texture_t tex)
+void gs_texture_destroy(gs_texture_t tex)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
 	if (!tex)
 		return;
 
-	if (!is_texture_2d(tex, "texture_destroy"))
+	if (!is_texture_2d(tex, "gs_texture_destroy"))
 		return;
 
 	if (tex->cur_sampler)
-		samplerstate_destroy(tex->cur_sampler);
+		gs_samplerstate_destroy(tex->cur_sampler);
 
 	if (!tex->is_dummy && tex->is_dynamic && tex2d->unpack_buffer)
 		gl_delete_buffers(1, &tex2d->unpack_buffer);
@@ -141,34 +141,34 @@ void texture_destroy(texture_t tex)
 	bfree(tex);
 }
 
-uint32_t texture_getwidth(texture_t tex)
+uint32_t gs_texture_get_width(gs_texture_t tex)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
-	if (!is_texture_2d(tex, "texture_getwidth"))
+	if (!is_texture_2d(tex, "gs_texture_get_width"))
 		return 0;
 
 	return tex2d->width;
 }
 
-uint32_t texture_getheight(texture_t tex)
+uint32_t gs_texture_get_height(gs_texture_t tex)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
-	if (!is_texture_2d(tex, "texture_getheight"))
+	if (!is_texture_2d(tex, "gs_texture_get_height"))
 		return 0;
 
 	return tex2d->height;
 }
 
-enum gs_color_format texture_getcolorformat(texture_t tex)
+enum gs_color_format gs_texture_get_color_format(gs_texture_t tex)
 {
 	return tex->format;
 }
 
-bool texture_map(texture_t tex, uint8_t **ptr, uint32_t *linesize)
+bool gs_texture_map(gs_texture_t tex, uint8_t **ptr, uint32_t *linesize)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
 
-	if (!is_texture_2d(tex, "texture_map"))
+	if (!is_texture_2d(tex, "gs_texture_map"))
 		goto fail;
 
 	if (!tex2d->base.is_dynamic) {
@@ -190,14 +190,14 @@ bool texture_map(texture_t tex, uint8_t **ptr, uint32_t *linesize)
 	return true;
 
 fail:
-	blog(LOG_ERROR, "texture_map (GL) failed");
+	blog(LOG_ERROR, "gs_texture_map (GL) failed");
 	return false;
 }
 
-void texture_unmap(texture_t tex)
+void gs_texture_unmap(gs_texture_t tex)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
-	if (!is_texture_2d(tex, "texture_unmap"))
+	if (!is_texture_2d(tex, "gs_texture_unmap"))
 		goto failed;
 
 	if (!gl_bind_buffer(GL_PIXEL_UNPACK_BUFFER, tex2d->unpack_buffer))
@@ -223,25 +223,25 @@ void texture_unmap(texture_t tex)
 failed:
 	gl_bind_buffer(GL_PIXEL_UNPACK_BUFFER, 0);
 	gl_bind_texture(GL_TEXTURE_2D, 0);
-	blog(LOG_ERROR, "texture_unmap (GL) failed");
+	blog(LOG_ERROR, "gs_texture_unmap (GL) failed");
 }
 
-bool texture_isrect(texture_t tex)
+bool gs_texture_is_rect(gs_texture_t tex)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
-	if (!is_texture_2d(tex, "texture_unmap")) {
-		blog(LOG_ERROR, "texture_isrect (GL) failed");
+	if (!is_texture_2d(tex, "gs_texture_unmap")) {
+		blog(LOG_ERROR, "gs_texture_is_rect (GL) failed");
 		return false;
 	}
 
 	return tex2d->base.gl_target == GL_TEXTURE_RECTANGLE;
 }
 
-void *texture_getobj(texture_t tex)
+void *gs_texture_get_obj(gs_texture_t tex)
 {
 	struct gs_texture_2d *tex2d = (struct gs_texture_2d*)tex;
-	if (!is_texture_2d(tex, "texture_unmap")) {
-		blog(LOG_ERROR, "texture_getobj (GL) failed");
+	if (!is_texture_2d(tex, "gs_texture_unmap")) {
+		blog(LOG_ERROR, "gs_texture_get_obj (GL) failed");
 		return NULL;
 	}
 

libobs-opengl/gl-texturecube.c

@@ -29,7 +29,7 @@ static inline bool upload_texture_cube(struct gs_texture_cube *tex,
 	uint32_t i;
 
 	if (!num_levels)
-		num_levels = gs_num_total_levels(tex->size, tex->size);
+		num_levels = gs_get_total_levels(tex->size, tex->size);
 
 	for (i = 0; i < 6; i++) {
 		GLenum target = GL_TEXTURE_CUBE_MAP_POSITIVE_X + i;
@@ -58,7 +58,7 @@ static inline bool upload_texture_cube(struct gs_texture_cube *tex,
 	return success;
 }
 
-texture_t device_create_cubetexture(device_t device, uint32_t size,
+gs_texture_t device_cubetexture_create(gs_device_t device, uint32_t size,
 		enum gs_color_format color_format, uint32_t levels,
 		const uint8_t **data, uint32_t flags)
 {
@@ -70,8 +70,8 @@ texture_t device_create_cubetexture(device_t device, uint32_t size,
 	tex->base.gl_format          = convert_gs_format(color_format);
 	tex->base.gl_internal_format = convert_gs_internal_format(color_format);
 	tex->base.gl_target          = GL_TEXTURE_CUBE_MAP;
-	tex->base.is_render_target   = (flags & GS_RENDERTARGET) != 0;
-	tex->base.gen_mipmaps        = (flags & GS_BUILDMIPMAPS) != 0;
+	tex->base.is_render_target   = (flags & GS_RENDER_TARGET) != 0;
+	tex->base.gen_mipmaps        = (flags & GS_BUILD_MIPMAPS) != 0;
 	tex->size                    = size;
 
 	if (!gl_gen_textures(1, &tex->base.texture))
@@ -79,15 +79,15 @@ texture_t device_create_cubetexture(device_t device, uint32_t size,
 	if (!upload_texture_cube(tex, data))
 		goto fail;
 
-	return (texture_t)tex;
+	return (gs_texture_t)tex;
 
 fail:
-	cubetexture_destroy((texture_t)tex);
-	blog(LOG_ERROR, "device_create_cubetexture (GL) failed");
+	gs_cubetexture_destroy((gs_texture_t)tex);
+	blog(LOG_ERROR, "device_cubetexture_create (GL) failed");
 	return NULL;
 }
 
-void cubetexture_destroy(texture_t tex)
+void gs_cubetexture_destroy(gs_texture_t tex)
 {
 	if (!tex)
 		return;
@@ -100,7 +100,7 @@ void cubetexture_destroy(texture_t tex)
 	bfree(tex);
 }
 
-static inline bool is_texture_cube(texture_t tex, const char *func)
+static inline bool is_texture_cube(gs_texture_t tex, const char *func)
 {
 	bool is_texcube = tex->type == GS_TEXTURE_CUBE;
 	if (!is_texcube)
@@ -108,16 +108,16 @@ static inline bool is_texture_cube(texture_t tex, const char *func)
 	return is_texcube;
 }
 
-uint32_t cubetexture_getsize(texture_t cubetex)
+uint32_t gs_cubetexture_get_size(gs_texture_t cubetex)
 {
 	struct gs_texture_cube *cube = (struct gs_texture_cube*)cubetex;
-	if (!is_texture_cube(cubetex, "cubetexture_getsize"))
+	if (!is_texture_cube(cubetex, "gs_cubetexture_get_size"))
 		return 0;
 
 	return cube->size;
 }
 
-enum gs_color_format cubetexture_getcolorformat(texture_t cubetex)
+enum gs_color_format gs_cubetexture_get_color_format(gs_texture_t cubetex)
 {
 	return cubetex->format;
 }

libobs-opengl/gl-vertexbuffer.c

@@ -54,7 +54,7 @@ static bool create_buffers(struct gs_vertex_buffer *vb)
 
 	for (i = 0; i < vb->data->num_tex; i++) {
 		GLuint tex_buffer;
-		struct tvertarray *tv = vb->data->tvarray+i;
+		struct gs_tvertarray *tv = vb->data->tvarray+i;
 		size_t size = vb->data->num * sizeof(float) * tv->width;
 
 		if (!gl_create_buffer(GL_ARRAY_BUFFER, &tex_buffer, size,
@@ -66,7 +66,7 @@ static bool create_buffers(struct gs_vertex_buffer *vb)
 	}
 
 	if (!vb->dynamic) {
-		vbdata_destroy(vb->data);
+		gs_vbdata_destroy(vb->data);
 		vb->data = NULL;
 	}
 
@@ -76,8 +76,8 @@ static bool create_buffers(struct gs_vertex_buffer *vb)
 	return true;
 }
 
-vertbuffer_t device_create_vertexbuffer(device_t device,
-		struct vb_data *data, uint32_t flags)
+gs_vertbuffer_t device_vertexbuffer_create(gs_device_t device,
+		struct gs_vb_data *data, uint32_t flags)
 {
 	struct gs_vertex_buffer *vb = bzalloc(sizeof(struct gs_vertex_buffer));
 	vb->device  = device;
@@ -86,15 +86,15 @@ vertbuffer_t device_create_vertexbuffer(device_t device,
 	vb->dynamic = flags & GS_DYNAMIC;
 
 	if (!create_buffers(vb)) {
-		blog(LOG_ERROR, "device_create_vertexbuffer (GL) failed");
-		vertexbuffer_destroy(vb);
+		blog(LOG_ERROR, "device_vertexbuffer_create (GL) failed");
+		gs_vertexbuffer_destroy(vb);
 		return NULL;
 	}
 
 	return vb;
 }
 
-void vertexbuffer_destroy(vertbuffer_t vb)
+void gs_vertexbuffer_destroy(gs_vertbuffer_t vb)
 {
 	if (vb) {
 		if (vb->vertex_buffer)
@@ -114,13 +114,13 @@ void vertexbuffer_destroy(vertbuffer_t vb)
 
 		da_free(vb->uv_sizes);
 		da_free(vb->uv_buffers);
-		vbdata_destroy(vb->data);
+		gs_vbdata_destroy(vb->data);
 
 		bfree(vb);
 	}
 }
 
-void vertexbuffer_flush(vertbuffer_t vb)
+void gs_vertexbuffer_flush(gs_vertbuffer_t vb)
 {
 	size_t i;
 
@@ -157,7 +157,7 @@ void vertexbuffer_flush(vertbuffer_t vb)
 
 	for (i = 0; i < vb->data->num_tex; i++) {
 		GLuint buffer = vb->uv_buffers.array[i];
-		struct tvertarray *tv = vb->data->tvarray+i;
+		struct gs_tvertarray *tv = vb->data->tvarray+i;
 		size_t size = vb->data->num * tv->width * sizeof(float);
 
 		if (!update_buffer(GL_ARRAY_BUFFER, buffer, tv->array, size))
@@ -167,10 +167,10 @@ void vertexbuffer_flush(vertbuffer_t vb)
 	return;
 
 failed:
-	blog(LOG_ERROR, "vertexbuffer_flush (GL) failed");
+	blog(LOG_ERROR, "gs_vertexbuffer_flush (GL) failed");
 }
 
-struct vb_data *vertexbuffer_getdata(vertbuffer_t vb)
+struct gs_vb_data *gs_vertexbuffer_get_data(gs_vertbuffer_t vb)
 {
 	return vb->data;
 }
@@ -251,7 +251,7 @@ static inline bool load_vb_buffers(struct gs_shader *shader,
 	return true;
 }
 
-bool vertexbuffer_load(device_t device, vertbuffer_t vb)
+bool vertexbuffer_load(gs_device_t device, gs_vertbuffer_t vb)
 {
 	if (device->cur_vertex_buffer == vb)
 		return true;
@@ -268,7 +268,7 @@ bool vertexbuffer_load(device_t device, vertbuffer_t vb)
 	return true;
 }
 
-void device_load_vertexbuffer(device_t device, vertbuffer_t vb)
+void device_load_vertexbuffer(gs_device_t device, gs_vertbuffer_t vb)
 {
 	if (!vertexbuffer_load(device, vb))
 		blog(LOG_ERROR, "device_load_vertexbuffer (GL) failed");

libobs-opengl/gl-windows.c

@@ -350,7 +350,7 @@ static struct gl_windowinfo *gl_windowinfo_bare(struct gs_init_data *info)
 	return wi;
 }
 
-static bool init_default_swap(struct gl_platform *plat, device_t device,
+static bool init_default_swap(struct gl_platform *plat, gs_device_t device,
 		int pixel_format, PIXELFORMATDESCRIPTOR *pfd,
 		struct gs_init_data *info)
 {
@@ -366,13 +366,13 @@ static bool init_default_swap(struct gl_platform *plat, device_t device,
 	return true;
 }
 
-void gl_update(device_t device)
+void gl_update(gs_device_t device)
 {
 	/* does nothing on windows */
 	UNUSED_PARAMETER(device);
 }
 
-struct gl_platform *gl_platform_create(device_t device,
+struct gl_platform *gl_platform_create(gs_device_t device,
 		struct gs_init_data *info)
 {
 	struct gl_platform *plat = bzalloc(sizeof(struct gl_platform));
@@ -475,7 +475,7 @@ void gl_windowinfo_destroy(struct gl_windowinfo *wi)
 	}
 }
 
-void device_entercontext(device_t device)
+void device_enter_context(gs_device_t device)
 {
 	HDC hdc = device->plat->swap.wi->hdc;
 	if (device->cur_swap)
@@ -485,13 +485,13 @@ void device_entercontext(device_t device)
 		blog(LOG_ERROR, "device_load_swapchain (GL) failed");
 }
 
-void device_leavecontext(device_t device)
+void device_leave_context(gs_device_t device)
 {
 	wglMakeCurrent(NULL, NULL);
 	UNUSED_PARAMETER(device);
 }
 
-void device_load_swapchain(device_t device, swapchain_t swap)
+void device_load_swapchain(gs_device_t device, gs_swapchain_t swap)
 {
 	HDC hdc;
 	if (!swap)
@@ -510,7 +510,7 @@ void device_load_swapchain(device_t device, swapchain_t swap)
 	}
 }
 
-void device_present(device_t device)
+void device_present(gs_device_t device)
 {
 	if (!SwapBuffers(device->cur_swap->wi->hdc)) {
 		blog(LOG_ERROR, "SwapBuffers failed, GetLastError "
@@ -528,7 +528,7 @@ extern void gl_getclientsize(struct gs_swap_chain *swap,
 	*height = rc.bottom;
 }
 
-EXPORT bool gdi_texture_available(void)
+EXPORT bool device_gdi_texture_available(void)
 {
 	return false;
 }

libobs-opengl/gl-x11.c

@@ -135,7 +135,7 @@ static bool handle_x_error(Display *disp, const char *error_string)
 	return false;
 }
 
-struct gl_platform *gl_platform_create(device_t device,
+struct gl_platform *gl_platform_create(gs_device_t device,
 		struct gs_init_data *info)
 {
 	int num_configs = 0;
@@ -366,7 +366,7 @@ void gl_platform_cleanup_swapchain(struct gs_swap_chain *swap)
 	info->int_id = 0;
 }
 
-void device_entercontext(device_t device)
+void device_enter_context(gs_device_t device)
 {
 	GLXContext context = device->plat->context;
 	XID window = device->cur_swap->wi->glxid;
@@ -377,7 +377,7 @@ void device_entercontext(device_t device)
 	}
 }
 
-void device_leavecontext(device_t device)
+void device_leave_context(gs_device_t device)
 {
 	Display *display = device->cur_swap->wi->display;
 
@@ -386,7 +386,7 @@ void device_leavecontext(device_t device)
 	}
 }
 
-void gl_update(device_t device)
+void gl_update(gs_device_t device)
 {
 	Display *display = device->cur_swap->wi->display;
 	XID window = device->cur_swap->wi->int_id;
@@ -395,7 +395,7 @@ void gl_update(device_t device)
 			device->cur_swap->info.cx, device->cur_swap->info.cy);
 }
 
-void device_load_swapchain(device_t device, swapchain_t swap)
+void device_load_swapchain(gs_device_t device, gs_swapchain_t swap)
 {
 	if (!swap)
 		swap = &device->plat->swap;
@@ -414,7 +414,7 @@ void device_load_swapchain(device_t device, swapchain_t swap)
 	}
 }
 
-void device_present(device_t device)
+void device_present(gs_device_t device)
 {
 	Display *display = device->cur_swap->wi->display;
 	XID window = device->cur_swap->wi->glxid;

libobs-opengl/gl-zstencil.c

@@ -48,7 +48,7 @@ static inline GLenum get_attachment(enum gs_zstencil_format format)
 	return 0;
 }
 
-zstencil_t device_create_zstencil(device_t device, uint32_t width,
+gs_zstencil_t device_zstencil_create(gs_device_t device, uint32_t width,
 		uint32_t height, enum gs_zstencil_format format)
 {
 	struct gs_zstencil_buffer *zs;
@@ -59,15 +59,15 @@ zstencil_t device_create_zstencil(device_t device, uint32_t width,
 	zs->device     = device;
 
 	if (!gl_init_zsbuffer(zs, width, height)) {
-		blog(LOG_ERROR, "device_create_zstencil (GL) failed");
-		zstencil_destroy(zs);
+		blog(LOG_ERROR, "device_zstencil_create (GL) failed");
+		gs_zstencil_destroy(zs);
 		return NULL;
 	}
 
 	return zs;
 }
 
-void zstencil_destroy(zstencil_t zs)
+void gs_zstencil_destroy(gs_zstencil_t zs)
 {
 	if (zs) {
 		if (zs->buffer) {