(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
2014-08-07 23:42:07 -07:00
parent 50ec8b0d55
commit 5780f3f177
64 changed files with 1933 additions and 1859 deletions
--- a/libobs-opengl/gl-shader.c
+++ b/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);
 }