From 0a3ca14fde03527eb6690b3c25f7cd27585b9254 Mon Sep 17 00:00:00 2001 From: twinaphex Date: Mon, 25 Apr 2016 12:51:01 +0200 Subject: [PATCH] (Cg) Rename cg_data to cg --- gfx/drivers_shader/shader_gl_cg.c | 572 +++++++++++++++--------------- 1 file changed, 286 insertions(+), 286 deletions(-) diff --git a/gfx/drivers_shader/shader_gl_cg.c b/gfx/drivers_shader/shader_gl_cg.c index 6f4d24440b..d9e6315dd7 100644 --- a/gfx/drivers_shader/shader_gl_cg.c +++ b/gfx/drivers_shader/shader_gl_cg.c @@ -68,7 +68,7 @@ struct cg_fbo_params CGparameter coord; }; -struct shader_program_cg_data +struct shader_program_cg { CGprogram vprg; CGprogram fprg; @@ -109,22 +109,22 @@ typedef struct cg_shader_data CGprofile cgVProf; CGprofile cgFProf; - struct shader_program_cg_data prg[GFX_MAX_SHADERS]; + struct shader_program_cg prg[GFX_MAX_SHADERS]; GLuint lut_textures[GFX_MAX_TEXTURES]; state_tracker_t *state_tracker; CGcontext cgCtx; } cg_shader_data_t; -struct uniform_cg_data +struct uniform_cg { CGparameter loc; }; -#define gl_cg_set_coord_array(param, cg_data, ptr, len) \ +#define gl_cg_set_coord_array(param, cg, ptr, len) \ { \ cgGLSetParameterPointer(param, len, GL_FLOAT, 0, ptr); \ cgGLEnableClientState(param); \ - cg_data->attribs.elems[cg_data->attribs.index++] = param; \ + cg->attribs.elems[cg->attribs.index++] = param; \ } #define cg_gl_set_texture_parameter(param, texture) \ @@ -143,7 +143,7 @@ static void gl_cg_set_uniform_parameter( void *uniform_data) { CGparameter location; - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; + cg_shader_data_t *cg = (cg_shader_data_t*)data; if (!param || !param->enabled) return; @@ -156,11 +156,11 @@ static void gl_cg_set_uniform_parameter( switch (param->lookup.type) { case SHADER_PROGRAM_VERTEX: - prog = cg_data->prg[param->lookup.idx].vprg; + prog = cg->prg[param->lookup.idx].vprg; break; case SHADER_PROGRAM_FRAGMENT: default: - prog = cg_data->prg[param->lookup.idx].fprg; + prog = cg->prg[param->lookup.idx].fprg; break; } @@ -170,7 +170,7 @@ static void gl_cg_set_uniform_parameter( } else { - struct uniform_cg_data *cg_param = (struct uniform_cg_data*)uniform_data; + struct uniform_cg *cg_param = (struct uniform_cg*)uniform_data; location = cg_param->loc; } @@ -236,23 +236,23 @@ static void cg_error_handler(CGcontext ctx, CGerror error, void *data) static void gl_cg_reset_attrib(void *data) { unsigned i; - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; + cg_shader_data_t *cg = (cg_shader_data_t*)data; /* Add sanity check that we did not overflow. */ - retro_assert(cg_data->attribs.index <= ARRAY_SIZE(cg_data->attribs.elems)); + retro_assert(cg->attribs.index <= ARRAY_SIZE(cg->attribs.elems)); - for (i = 0; i < cg_data->attribs.index; i++) - cgGLDisableClientState(cg_data->attribs.elems[i]); - cg_data->attribs.index = 0; + for (i = 0; i < cg->attribs.index; i++) + cgGLDisableClientState(cg->attribs.elems[i]); + cg->attribs.index = 0; } static bool gl_cg_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data; - if (!cg_data || !cg_data->prg[cg_data->active_idx].mvp) + cg_shader_data_t *cg = (cg_shader_data_t*)shader_data; + if (!cg || !cg->prg[cg->active_idx].mvp) goto fallback; - cgGLSetMatrixParameterfc(cg_data->prg[cg_data->active_idx].mvp, mat->data); + cgGLSetMatrixParameterfc(cg->prg[cg->active_idx].mvp, mat->data); return true; fallback: @@ -262,22 +262,22 @@ fallback: static bool gl_cg_set_coords(void *handle_data, void *shader_data, const struct gfx_coords *coords) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data; + cg_shader_data_t *cg = (cg_shader_data_t*)shader_data; - if (!cg_data || !coords) + if (!cg || !coords) goto fallback; - if (cg_data->prg[cg_data->active_idx].vertex) - gl_cg_set_coord_array(cg_data->prg[cg_data->active_idx].vertex, cg_data, coords->vertex, 2); + if (cg->prg[cg->active_idx].vertex) + gl_cg_set_coord_array(cg->prg[cg->active_idx].vertex, cg, coords->vertex, 2); - if (cg_data->prg[cg_data->active_idx].tex) - gl_cg_set_coord_array(cg_data->prg[cg_data->active_idx].tex, cg_data, coords->tex_coord, 2); + if (cg->prg[cg->active_idx].tex) + gl_cg_set_coord_array(cg->prg[cg->active_idx].tex, cg, coords->tex_coord, 2); - if (cg_data->prg[cg_data->active_idx].lut_tex) - gl_cg_set_coord_array(cg_data->prg[cg_data->active_idx].lut_tex, cg_data, coords->lut_tex_coord, 2); + if (cg->prg[cg->active_idx].lut_tex) + gl_cg_set_coord_array(cg->prg[cg->active_idx].lut_tex, cg, coords->lut_tex_coord, 2); - if (cg_data->prg[cg_data->active_idx].color) - gl_cg_set_coord_array(cg_data->prg[cg_data->active_idx].color, cg_data, coords->color, 4); + if (cg->prg[cg->active_idx].color) + gl_cg_set_coord_array(cg->prg[cg->active_idx].color, cg, coords->color, 4); return true; @@ -287,12 +287,12 @@ fallback: } static void gl_cg_set_texture_info( - cg_shader_data_t *cg_data, + cg_shader_data_t *cg, const struct cg_fbo_params *params, const struct gfx_tex_info *info) { unsigned i; - struct uniform_cg_data uniform_data[4]; + struct uniform_cg uniform_data[4]; struct uniform_info uniform_params[4] = {0}; CGparameter param = params->tex; @@ -327,10 +327,10 @@ static void gl_cg_set_texture_info( uniform_data[3].loc = params->tex_size_f; for (i = 0; i < 4; i++) - gl_cg_set_uniform_parameter(cg_data, &uniform_params[i], &uniform_data[i]); + gl_cg_set_uniform_parameter(cg, &uniform_params[i], &uniform_data[i]); if (params->coord) - gl_cg_set_coord_array(params->coord, cg_data, info->coord, 2); + gl_cg_set_coord_array(params->coord, cg, info->coord, 2); } static void gl_cg_set_params(void *data, void *shader_data, @@ -345,18 +345,18 @@ static void gl_cg_set_params(void *data, void *shader_data, unsigned fbo_info_cnt) { unsigned i; - struct uniform_cg_data uniform_data[10]; + struct uniform_cg uniform_data[10]; struct uniform_info uniform_params[10] = {0}; unsigned uniform_count = 0; const struct gfx_tex_info *info = (const struct gfx_tex_info*)_info; const struct gfx_tex_info *prev_info = (const struct gfx_tex_info*)_prev_info; const struct gfx_tex_info *feedback_info = (const struct gfx_tex_info*)_feedback_info; const struct gfx_tex_info *fbo_info = (const struct gfx_tex_info*)_fbo_info; - cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data; + cg_shader_data_t *cg = (cg_shader_data_t*)shader_data; - if (!cg_data || (cg_data->active_idx == 0)) + if (!cg || (cg->active_idx == 0)) return; - if (cg_data->active_idx == VIDEO_SHADER_STOCK_BLEND) + if (cg->active_idx == VIDEO_SHADER_STOCK_BLEND) return; /* Set frame. */ @@ -365,60 +365,60 @@ static void gl_cg_set_params(void *data, void *shader_data, uniform_params[0].type = UNIFORM_2F; uniform_params[0].result.f.v0 = width; uniform_params[0].result.f.v1 = height; - uniform_data[0].loc = cg_data->prg[cg_data->active_idx].vid_size_f; + uniform_data[0].loc = cg->prg[cg->active_idx].vid_size_f; uniform_params[1].location = 1; uniform_params[1].enabled = true; uniform_params[1].type = UNIFORM_2F; uniform_params[1].result.f.v0 = tex_width; uniform_params[1].result.f.v1 = tex_height; - uniform_data[1].loc = cg_data->prg[cg_data->active_idx].tex_size_f; + uniform_data[1].loc = cg->prg[cg->active_idx].tex_size_f; uniform_params[2].location = 2; uniform_params[2].enabled = true; uniform_params[2].type = UNIFORM_2F; uniform_params[2].result.f.v0 = out_width; uniform_params[2].result.f.v1 = out_height; - uniform_data[2].loc = cg_data->prg[cg_data->active_idx].out_size_f; + uniform_data[2].loc = cg->prg[cg->active_idx].out_size_f; uniform_params[3].location = 3; uniform_params[3].enabled = true; uniform_params[3].type = UNIFORM_1F; uniform_params[3].result.f.v0 = state_manager_frame_is_reversed() ? -1.0 : 1.0; - uniform_data[3].loc = cg_data->prg[cg_data->active_idx].frame_dir_f; + uniform_data[3].loc = cg->prg[cg->active_idx].frame_dir_f; uniform_params[4].location = 4; uniform_params[4].enabled = true; uniform_params[4].type = UNIFORM_2F; uniform_params[4].result.f.v0 = width; uniform_params[4].result.f.v1 = height; - uniform_data[4].loc = cg_data->prg[cg_data->active_idx].vid_size_v; + uniform_data[4].loc = cg->prg[cg->active_idx].vid_size_v; uniform_params[5].location = 5; uniform_params[5].enabled = true; uniform_params[5].type = UNIFORM_2F; uniform_params[5].result.f.v0 = tex_width; uniform_params[5].result.f.v1 = tex_height; - uniform_data[5].loc = cg_data->prg[cg_data->active_idx].tex_size_v; + uniform_data[5].loc = cg->prg[cg->active_idx].tex_size_v; uniform_params[6].location = 6; uniform_params[6].enabled = true; uniform_params[6].type = UNIFORM_2F; uniform_params[6].result.f.v0 = out_width; uniform_params[6].result.f.v1 = out_height; - uniform_data[6].loc = cg_data->prg[cg_data->active_idx].out_size_v; + uniform_data[6].loc = cg->prg[cg->active_idx].out_size_v; uniform_params[7].location = 7; uniform_params[7].enabled = true; uniform_params[7].type = UNIFORM_1F; uniform_params[7].result.f.v0 = state_manager_frame_is_reversed() ? -1.0 : 1.0; - uniform_data[7].loc = cg_data->prg[cg_data->active_idx].frame_dir_v; + uniform_data[7].loc = cg->prg[cg->active_idx].frame_dir_v; uniform_count += 8; - if (cg_data->prg[cg_data->active_idx].frame_cnt_f || cg_data->prg[cg_data->active_idx].frame_cnt_v) + if (cg->prg[cg->active_idx].frame_cnt_f || cg->prg[cg->active_idx].frame_cnt_v) { - unsigned modulo = cg_data->shader->pass[cg_data->active_idx - 1].frame_count_mod; + unsigned modulo = cg->shader->pass[cg->active_idx - 1].frame_count_mod; if (modulo) frame_count %= modulo; @@ -426,51 +426,51 @@ static void gl_cg_set_params(void *data, void *shader_data, uniform_params[8].enabled = true; uniform_params[8].type = UNIFORM_1F; uniform_params[8].result.f.v0 = (float)frame_count; - uniform_data[8].loc = cg_data->prg[cg_data->active_idx].frame_cnt_f; + uniform_data[8].loc = cg->prg[cg->active_idx].frame_cnt_f; uniform_params[9].location = 9; uniform_params[9].enabled = true; uniform_params[9].type = UNIFORM_1F; uniform_params[9].result.f.v0 = (float)frame_count; - uniform_data[9].loc = cg_data->prg[cg_data->active_idx].frame_cnt_v; + uniform_data[9].loc = cg->prg[cg->active_idx].frame_cnt_v; uniform_count += 2; } for (i = 0; i < uniform_count; i++) - gl_cg_set_uniform_parameter(cg_data, &uniform_params[i], &uniform_data[i]); + gl_cg_set_uniform_parameter(cg, &uniform_params[i], &uniform_data[i]); /* Set orig texture. */ - gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].orig, info); + gl_cg_set_texture_info(cg, &cg->prg[cg->active_idx].orig, info); /* Set feedback texture. */ - gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].feedback, feedback_info); + gl_cg_set_texture_info(cg, &cg->prg[cg->active_idx].feedback, feedback_info); /* Set previous textures. */ for (i = 0; i < PREV_TEXTURES; i++) - gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].prev[i], &prev_info[i]); + gl_cg_set_texture_info(cg, &cg->prg[cg->active_idx].prev[i], &prev_info[i]); /* Set lookup textures. */ - for (i = 0; i < cg_data->shader->luts; i++) + for (i = 0; i < cg->shader->luts; i++) { CGparameter fparam = cgGetNamedParameter( - cg_data->prg[cg_data->active_idx].fprg, cg_data->shader->lut[i].id); - CGparameter vparam = cgGetNamedParameter(cg_data->prg[cg_data->active_idx].vprg, - cg_data->shader->lut[i].id); + cg->prg[cg->active_idx].fprg, cg->shader->lut[i].id); + CGparameter vparam = cgGetNamedParameter(cg->prg[cg->active_idx].vprg, + cg->shader->lut[i].id); - cg_gl_set_texture_parameter(fparam, cg_data->lut_textures[i]); - cg_gl_set_texture_parameter(vparam, cg_data->lut_textures[i]); + cg_gl_set_texture_parameter(fparam, cg->lut_textures[i]); + cg_gl_set_texture_parameter(vparam, cg->lut_textures[i]); } /* Set FBO textures. */ - if (cg_data->active_idx) + if (cg->active_idx) { for (i = 0; i < fbo_info_cnt; i++) - gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].fbo[i], &fbo_info[i]); + gl_cg_set_texture_info(cg, &cg->prg[cg->active_idx].fbo[i], &fbo_info[i]); } /* #pragma parameters. */ - for (i = 0; i < cg_data->shader->num_parameters; i++) + for (i = 0; i < cg->shader->num_parameters; i++) { unsigned j; @@ -480,25 +480,25 @@ static void gl_cg_set_params(void *data, void *shader_data, for (j = 0; j < 2; j++) { uniform_params[j].lookup.enable = true; - uniform_params[j].lookup.idx = cg_data->active_idx; - uniform_params[j].lookup.ident = cg_data->shader->parameters[i].id; + uniform_params[j].lookup.idx = cg->active_idx; + uniform_params[j].lookup.ident = cg->shader->parameters[i].id; uniform_params[j].location = j; uniform_params[j].enabled = true; uniform_params[j].type = UNIFORM_1F; - uniform_params[j].result.f.v0 = cg_data->shader->parameters[i].current; - gl_cg_set_uniform_parameter(cg_data, &uniform_params[j], NULL); + uniform_params[j].result.f.v0 = cg->shader->parameters[i].current; + gl_cg_set_uniform_parameter(cg, &uniform_params[j], NULL); } } /* Set state parameters. */ - if (cg_data->state_tracker) + if (cg->state_tracker) { /* Only query uniforms in first pass. */ static struct state_tracker_uniform tracker_info[GFX_MAX_VARIABLES]; static unsigned cnt = 0; - if (cg_data->active_idx == 1) - cnt = state_tracker_get_uniform(cg_data->state_tracker, tracker_info, + if (cg->active_idx == 1) + cnt = state_tracker_get_uniform(cg->state_tracker, tracker_info, GFX_MAX_VARIABLES, frame_count); for (i = 0; i < cnt; i++) @@ -511,13 +511,13 @@ static void gl_cg_set_params(void *data, void *shader_data, for (j = 0; j < 2; j++) { uniform_params[j].lookup.enable = true; - uniform_params[j].lookup.idx = cg_data->active_idx; + uniform_params[j].lookup.idx = cg->active_idx; uniform_params[j].lookup.ident = tracker_info[i].id; uniform_params[j].location = j; uniform_params[j].enabled = true; uniform_params[j].type = UNIFORM_1F; uniform_params[j].result.f.v0 = tracker_info[i].value; - gl_cg_set_uniform_parameter(cg_data, &uniform_params[j], NULL); + gl_cg_set_uniform_parameter(cg, &uniform_params[j], NULL); } } } @@ -526,81 +526,81 @@ static void gl_cg_set_params(void *data, void *shader_data, static void gl_cg_deinit_progs(void *data) { unsigned i; - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; + cg_shader_data_t *cg = (cg_shader_data_t*)data; - if (!cg_data) + if (!cg) return; RARCH_LOG("CG: Destroying programs.\n"); - cgGLUnbindProgram(cg_data->cgFProf); - cgGLUnbindProgram(cg_data->cgVProf); + cgGLUnbindProgram(cg->cgFProf); + cgGLUnbindProgram(cg->cgVProf); /* Programs may alias [0]. */ for (i = 1; i < GFX_MAX_SHADERS; i++) { - if (cg_data->prg[i].fprg && cg_data->prg[i].fprg != cg_data->prg[0].fprg) - cgDestroyProgram(cg_data->prg[i].fprg); - if (cg_data->prg[i].vprg && cg_data->prg[i].vprg != cg_data->prg[0].vprg) - cgDestroyProgram(cg_data->prg[i].vprg); + if (cg->prg[i].fprg && cg->prg[i].fprg != cg->prg[0].fprg) + cgDestroyProgram(cg->prg[i].fprg); + if (cg->prg[i].vprg && cg->prg[i].vprg != cg->prg[0].vprg) + cgDestroyProgram(cg->prg[i].vprg); } - if (cg_data->prg[0].fprg) - cgDestroyProgram(cg_data->prg[0].fprg); - if (cg_data->prg[0].vprg) - cgDestroyProgram(cg_data->prg[0].vprg); + if (cg->prg[0].fprg) + cgDestroyProgram(cg->prg[0].fprg); + if (cg->prg[0].vprg) + cgDestroyProgram(cg->prg[0].vprg); - memset(cg_data->prg, 0, sizeof(cg_data->prg)); + memset(cg->prg, 0, sizeof(cg->prg)); } static void gl_cg_destroy_resources(void *data) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; - if (!cg_data) + cg_shader_data_t *cg = (cg_shader_data_t*)data; + if (!cg) return; gl_cg_reset_attrib(data); gl_cg_deinit_progs(data); - if (cg_data->shader && cg_data->shader->luts) + if (cg->shader && cg->shader->luts) { - glDeleteTextures(cg_data->shader->luts, cg_data->lut_textures); - memset(cg_data->lut_textures, 0, sizeof(cg_data->lut_textures)); + glDeleteTextures(cg->shader->luts, cg->lut_textures); + memset(cg->lut_textures, 0, sizeof(cg->lut_textures)); } - if (cg_data->state_tracker) + if (cg->state_tracker) { - state_tracker_free(cg_data->state_tracker); - cg_data->state_tracker = NULL; + state_tracker_free(cg->state_tracker); + cg->state_tracker = NULL; } - free(cg_data->shader); - cg_data->shader = NULL; + free(cg->shader); + cg->shader = NULL; } /* Final deinit. */ static void gl_cg_deinit_context_state(void *data) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; - if (cg_data->cgCtx) + cg_shader_data_t *cg = (cg_shader_data_t*)data; + if (cg->cgCtx) { RARCH_LOG("CG: Destroying context.\n"); - cgDestroyContext(cg_data->cgCtx); + cgDestroyContext(cg->cgCtx); } - cg_data->cgCtx = NULL; + cg->cgCtx = NULL; } /* Full deinit. */ static void gl_cg_deinit(void *data) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; - if (!cg_data) + cg_shader_data_t *cg = (cg_shader_data_t*)data; + if (!cg) return; - gl_cg_destroy_resources(cg_data); - gl_cg_deinit_context_state(cg_data); + gl_cg_destroy_resources(cg); + gl_cg_deinit_context_state(cg); - free(cg_data); + free(cg); } static bool gl_cg_compile_program( @@ -615,29 +615,29 @@ static bool gl_cg_compile_program( char *listing_f = NULL; char *listing_v = NULL; unsigned i, argc = 0; - struct shader_program_cg_data *program = (struct shader_program_cg_data*)program_data; - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; + struct shader_program_cg *program = (struct shader_program_cg*)program_data; + cg_shader_data_t *cg = (cg_shader_data_t*)data; if (!program) - program = &cg_data->prg[idx]; + program = &cg->prg[idx]; argv[argc++] = "-DPARAMETER_UNIFORM"; for (i = 0; i < GFX_MAX_SHADERS; i++) { - if (*(cg_data->alias_define[i])) - argv[argc++] = cg_data->alias_define[i]; + if (*(cg->alias_define[i])) + argv[argc++] = cg->alias_define[i]; } argv[argc] = NULL; if (program_info->is_file) program->fprg = cgCreateProgramFromFile( - cg_data->cgCtx, CG_SOURCE, - program_info->combined, cg_data->cgFProf, "main_fragment", argv); + cg->cgCtx, CG_SOURCE, + program_info->combined, cg->cgFProf, "main_fragment", argv); else - program->fprg = cgCreateProgram(cg_data->cgCtx, CG_SOURCE, - program_info->combined, cg_data->cgFProf, "main_fragment", argv); + program->fprg = cgCreateProgram(cg->cgCtx, CG_SOURCE, + program_info->combined, cg->cgFProf, "main_fragment", argv); - list = cgGetLastListing(cg_data->cgCtx); + list = cgGetLastListing(cg->cgCtx); if (list) listing_f = strdup(list); @@ -646,13 +646,13 @@ static bool gl_cg_compile_program( if (program_info->is_file) program->vprg = cgCreateProgramFromFile( - cg_data->cgCtx, CG_SOURCE, - program_info->combined, cg_data->cgVProf, "main_vertex", argv); + cg->cgCtx, CG_SOURCE, + program_info->combined, cg->cgVProf, "main_vertex", argv); else - program->vprg = cgCreateProgram(cg_data->cgCtx, CG_SOURCE, - program_info->combined, cg_data->cgVProf, "main_vertex", argv); + program->vprg = cgCreateProgram(cg->cgCtx, CG_SOURCE, + program_info->combined, cg->cgVProf, "main_vertex", argv); - list = cgGetLastListing(cg_data->cgCtx); + list = cgGetLastListing(cg->cgCtx); if (list) listing_v = strdup(list); @@ -680,9 +680,9 @@ end: static void gl_cg_set_program_base_attrib(void *data, unsigned i) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; + cg_shader_data_t *cg = (cg_shader_data_t*)data; CGparameter param = cgGetFirstParameter( - cg_data->prg[i].vprg, CG_PROGRAM); + cg->prg[i].vprg, CG_PROGRAM); for (; param; param = cgGetNextParameter(param)) { @@ -704,40 +704,40 @@ static void gl_cg_set_program_base_attrib(void *data, unsigned i) { case SEMANTIC_TEXCOORD: case SEMANTIC_TEXCOORD0: - cg_data->prg[i].tex = param; + cg->prg[i].tex = param; break; case SEMANTIC_COLOR: case SEMANTIC_COLOR0: - cg_data->prg[i].color = param; + cg->prg[i].color = param; break; case SEMANTIC_POSITION: - cg_data->prg[i].vertex = param; + cg->prg[i].vertex = param; break; case SEMANTIC_TEXCOORD1: - cg_data->prg[i].lut_tex = param; + cg->prg[i].lut_tex = param; break; } } - if (!cg_data->prg[i].tex) - cg_data->prg[i].tex = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.tex_coord"); - if (!cg_data->prg[i].color) - cg_data->prg[i].color = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.color"); - if (!cg_data->prg[i].vertex) - cg_data->prg[i].vertex = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.vertex_coord"); - if (!cg_data->prg[i].lut_tex) - cg_data->prg[i].lut_tex = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.lut_tex_coord"); + if (!cg->prg[i].tex) + cg->prg[i].tex = cgGetNamedParameter(cg->prg[i].vprg, "IN.tex_coord"); + if (!cg->prg[i].color) + cg->prg[i].color = cgGetNamedParameter(cg->prg[i].vprg, "IN.color"); + if (!cg->prg[i].vertex) + cg->prg[i].vertex = cgGetNamedParameter(cg->prg[i].vprg, "IN.vertex_coord"); + if (!cg->prg[i].lut_tex) + cg->prg[i].lut_tex = cgGetNamedParameter(cg->prg[i].vprg, "IN.lut_tex_coord"); } static bool gl_cg_load_stock(void *data) { struct shader_program_info program_info; - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; + cg_shader_data_t *cg = (cg_shader_data_t*)data; program_info.combined = stock_cg_gl_program; program_info.is_file = false; - if (!gl_cg_compile_program(data, 0, &cg_data->prg[0], &program_info)) + if (!gl_cg_compile_program(data, 0, &cg->prg[0], &program_info)) goto error; gl_cg_set_program_base_attrib(data, 0); @@ -751,16 +751,16 @@ error: static bool gl_cg_load_plain(void *data, const char *path) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; - if (!gl_cg_load_stock(cg_data)) + cg_shader_data_t *cg = (cg_shader_data_t*)data; + if (!gl_cg_load_stock(cg)) return false; - cg_data->shader = (struct video_shader*) - calloc(1, sizeof(*cg_data->shader)); - if (!cg_data->shader) + cg->shader = (struct video_shader*) + calloc(1, sizeof(*cg->shader)); + if (!cg->shader) return false; - cg_data->shader->passes = 1; + cg->shader->passes = 1; if (path) { @@ -770,18 +770,18 @@ static bool gl_cg_load_plain(void *data, const char *path) program_info.is_file = true; RARCH_LOG("Loading Cg file: %s\n", path); - strlcpy(cg_data->shader->pass[0].source.path, path, - sizeof(cg_data->shader->pass[0].source.path)); - if (!gl_cg_compile_program(data, 1, &cg_data->prg[1], &program_info)) + strlcpy(cg->shader->pass[0].source.path, path, + sizeof(cg->shader->pass[0].source.path)); + if (!gl_cg_compile_program(data, 1, &cg->prg[1], &program_info)) return false; } else { RARCH_LOG("Loading stock Cg file.\n"); - cg_data->prg[1] = cg_data->prg[0]; + cg->prg[1] = cg->prg[0]; } - video_shader_resolve_parameters(NULL, cg_data->shader); + video_shader_resolve_parameters(NULL, cg->shader); return true; } @@ -790,16 +790,16 @@ static bool gl_cg_load_imports(void *data) unsigned i; retro_ctx_memory_info_t mem_info; struct state_tracker_info tracker_info = {0}; - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; + cg_shader_data_t *cg = (cg_shader_data_t*)data; - if (!cg_data->shader->variables) + if (!cg->shader->variables) return true; - for (i = 0; i < cg_data->shader->variables; i++) + for (i = 0; i < cg->shader->variables; i++) { unsigned memtype; - switch (cg_data->shader->variable[i].ram_type) + switch (cg->shader->variable[i].ram_type) { case RARCH_STATE_WRAM: memtype = RETRO_MEMORY_SYSTEM_RAM; @@ -814,7 +814,7 @@ static bool gl_cg_load_imports(void *data) core_ctl(CORE_CTL_RETRO_GET_MEMORY, &mem_info); if ((memtype != -1u) && - (cg_data->shader->variable[i].addr >= mem_info.size)) + (cg->shader->variable[i].addr >= mem_info.size)) { RARCH_ERR("Address out of bounds.\n"); return false; @@ -828,22 +828,22 @@ static bool gl_cg_load_imports(void *data) core_ctl(CORE_CTL_RETRO_GET_MEMORY, &mem_info); tracker_info.wram = (uint8_t*)mem_info.data; - tracker_info.info = cg_data->shader->variable; - tracker_info.info_elem = cg_data->shader->variables; + tracker_info.info = cg->shader->variable; + tracker_info.info_elem = cg->shader->variables; #ifdef HAVE_PYTHON - if (*cg_data->shader->script_path) + if (*cg->shader->script_path) { - tracker_info.script = cg_data->shader->script_path; + tracker_info.script = cg->shader->script_path; tracker_info.script_is_file = true; } tracker_info.script_class = - *cg_data->shader->script_class ? cg_data->shader->script_class : NULL; + *cg->shader->script_class ? cg->shader->script_class : NULL; #endif - cg_data->state_tracker = state_tracker_init(&tracker_info); - if (!cg_data->state_tracker) + cg->state_tracker = state_tracker_init(&tracker_info); + if (!cg->state_tracker) RARCH_WARN("Failed to initialize state tracker.\n"); return true; @@ -852,15 +852,15 @@ static bool gl_cg_load_imports(void *data) static bool gl_cg_load_shader(void *data, unsigned i) { struct shader_program_info program_info; - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; + cg_shader_data_t *cg = (cg_shader_data_t*)data; - program_info.combined = cg_data->shader->pass[i].source.path; + program_info.combined = cg->shader->pass[i].source.path; program_info.is_file = true; RARCH_LOG("Loading Cg shader: \"%s\".\n", - cg_data->shader->pass[i].source.path); + cg->shader->pass[i].source.path); - if (!gl_cg_compile_program(data, i + 1, &cg_data->prg[i + 1],&program_info)) + if (!gl_cg_compile_program(data, i + 1, &cg->prg[i + 1],&program_info)) return false; return true; @@ -870,9 +870,9 @@ static bool gl_cg_load_preset(void *data, const char *path) { unsigned i; config_file_t *conf = NULL; - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; + cg_shader_data_t *cg = (cg_shader_data_t*)data; - if (!gl_cg_load_stock(cg_data)) + if (!gl_cg_load_stock(cg)) return false; RARCH_LOG("Loading Cg meta-shader: %s\n", path); @@ -883,54 +883,54 @@ static bool gl_cg_load_preset(void *data, const char *path) return false; } - cg_data->shader = (struct video_shader*)calloc(1, sizeof(*cg_data->shader)); - if (!cg_data->shader) + cg->shader = (struct video_shader*)calloc(1, sizeof(*cg->shader)); + if (!cg->shader) { config_file_free(conf); return false; } - if (!video_shader_read_conf_cgp(conf, cg_data->shader)) + if (!video_shader_read_conf_cgp(conf, cg->shader)) { RARCH_ERR("Failed to parse CGP file.\n"); config_file_free(conf); return false; } - video_shader_resolve_relative(cg_data->shader, path); - video_shader_resolve_parameters(conf, cg_data->shader); + video_shader_resolve_relative(cg->shader, path); + video_shader_resolve_parameters(conf, cg->shader); config_file_free(conf); - if (cg_data->shader->passes > GFX_MAX_SHADERS - 3) + if (cg->shader->passes > GFX_MAX_SHADERS - 3) { RARCH_WARN("Too many shaders ... Capping shader amount to %d.\n", GFX_MAX_SHADERS - 3); - cg_data->shader->passes = GFX_MAX_SHADERS - 3; + cg->shader->passes = GFX_MAX_SHADERS - 3; } - for (i = 0; i < cg_data->shader->passes; i++) - if (*cg_data->shader->pass[i].alias) - snprintf(cg_data->alias_define[i], - sizeof(cg_data->alias_define[i]), + for (i = 0; i < cg->shader->passes; i++) + if (*cg->shader->pass[i].alias) + snprintf(cg->alias_define[i], + sizeof(cg->alias_define[i]), "-D%s_ALIAS", - cg_data->shader->pass[i].alias); + cg->shader->pass[i].alias); - for (i = 0; i < cg_data->shader->passes; i++) + for (i = 0; i < cg->shader->passes; i++) { - if (!gl_cg_load_shader(cg_data, i)) + if (!gl_cg_load_shader(cg, i)) { RARCH_ERR("Failed to load shaders ...\n"); return false; } } - if (!gl_load_luts(cg_data->shader, cg_data->lut_textures)) + if (!gl_load_luts(cg->shader, cg->lut_textures)) { RARCH_ERR("Failed to load lookup textures ...\n"); return false; } - if (!gl_cg_load_imports(cg_data)) + if (!gl_cg_load_imports(cg)) { RARCH_ERR("Failed to load imports ...\n"); return false; @@ -940,7 +940,7 @@ static bool gl_cg_load_preset(void *data, const char *path) } static void gl_cg_set_pass_attrib( - struct shader_program_cg_data *program, + struct shader_program_cg *program, struct cg_fbo_params *fbo, const char *attr) { @@ -976,50 +976,50 @@ static INLINE void gl_cg_set_shaders(CGprogram frag, CGprogram vert) static void gl_cg_set_program_attributes(void *data, unsigned i) { unsigned j; - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; + cg_shader_data_t *cg = (cg_shader_data_t*)data; - if (!cg_data) + if (!cg) return; - gl_cg_set_shaders(cg_data->prg[i].fprg, cg_data->prg[i].vprg); + gl_cg_set_shaders(cg->prg[i].fprg, cg->prg[i].vprg); - gl_cg_set_program_base_attrib(cg_data, i); + gl_cg_set_program_base_attrib(cg, i); - cg_data->prg[i].vid_size_f = cgGetNamedParameter (cg_data->prg[i].fprg, "IN.video_size"); - cg_data->prg[i].tex_size_f = cgGetNamedParameter (cg_data->prg[i].fprg, "IN.texture_size"); - cg_data->prg[i].out_size_f = cgGetNamedParameter (cg_data->prg[i].fprg, "IN.output_size"); - cg_data->prg[i].frame_cnt_f = cgGetNamedParameter(cg_data->prg[i].fprg, "IN.frame_count"); - cg_data->prg[i].frame_dir_f = cgGetNamedParameter(cg_data->prg[i].fprg, "IN.frame_direction"); - cg_data->prg[i].vid_size_v = cgGetNamedParameter (cg_data->prg[i].vprg, "IN.video_size"); - cg_data->prg[i].tex_size_v = cgGetNamedParameter (cg_data->prg[i].vprg, "IN.texture_size"); - cg_data->prg[i].out_size_v = cgGetNamedParameter (cg_data->prg[i].vprg, "IN.output_size"); - cg_data->prg[i].frame_cnt_v = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.frame_count"); - cg_data->prg[i].frame_dir_v = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.frame_direction"); + cg->prg[i].vid_size_f = cgGetNamedParameter (cg->prg[i].fprg, "IN.video_size"); + cg->prg[i].tex_size_f = cgGetNamedParameter (cg->prg[i].fprg, "IN.texture_size"); + cg->prg[i].out_size_f = cgGetNamedParameter (cg->prg[i].fprg, "IN.output_size"); + cg->prg[i].frame_cnt_f = cgGetNamedParameter(cg->prg[i].fprg, "IN.frame_count"); + cg->prg[i].frame_dir_f = cgGetNamedParameter(cg->prg[i].fprg, "IN.frame_direction"); + cg->prg[i].vid_size_v = cgGetNamedParameter (cg->prg[i].vprg, "IN.video_size"); + cg->prg[i].tex_size_v = cgGetNamedParameter (cg->prg[i].vprg, "IN.texture_size"); + cg->prg[i].out_size_v = cgGetNamedParameter (cg->prg[i].vprg, "IN.output_size"); + cg->prg[i].frame_cnt_v = cgGetNamedParameter(cg->prg[i].vprg, "IN.frame_count"); + cg->prg[i].frame_dir_v = cgGetNamedParameter(cg->prg[i].vprg, "IN.frame_direction"); - cg_data->prg[i].mvp = cgGetNamedParameter(cg_data->prg[i].vprg, "modelViewProj"); - if (!cg_data->prg[i].mvp) - cg_data->prg[i].mvp = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.mvp_matrix"); + cg->prg[i].mvp = cgGetNamedParameter(cg->prg[i].vprg, "modelViewProj"); + if (!cg->prg[i].mvp) + cg->prg[i].mvp = cgGetNamedParameter(cg->prg[i].vprg, "IN.mvp_matrix"); - cg_data->prg[i].orig.tex = cgGetNamedParameter(cg_data->prg[i].fprg, "ORIG.texture"); - cg_data->prg[i].orig.vid_size_v = cgGetNamedParameter(cg_data->prg[i].vprg, "ORIG.video_size"); - cg_data->prg[i].orig.vid_size_f = cgGetNamedParameter(cg_data->prg[i].fprg, "ORIG.video_size"); - cg_data->prg[i].orig.tex_size_v = cgGetNamedParameter(cg_data->prg[i].vprg, "ORIG.texture_size"); - cg_data->prg[i].orig.tex_size_f = cgGetNamedParameter(cg_data->prg[i].fprg, "ORIG.texture_size"); - cg_data->prg[i].orig.coord = cgGetNamedParameter(cg_data->prg[i].vprg, "ORIG.tex_coord"); + cg->prg[i].orig.tex = cgGetNamedParameter(cg->prg[i].fprg, "ORIG.texture"); + cg->prg[i].orig.vid_size_v = cgGetNamedParameter(cg->prg[i].vprg, "ORIG.video_size"); + cg->prg[i].orig.vid_size_f = cgGetNamedParameter(cg->prg[i].fprg, "ORIG.video_size"); + cg->prg[i].orig.tex_size_v = cgGetNamedParameter(cg->prg[i].vprg, "ORIG.texture_size"); + cg->prg[i].orig.tex_size_f = cgGetNamedParameter(cg->prg[i].fprg, "ORIG.texture_size"); + cg->prg[i].orig.coord = cgGetNamedParameter(cg->prg[i].vprg, "ORIG.tex_coord"); - cg_data->prg[i].feedback.tex = cgGetNamedParameter(cg_data->prg[i].fprg, "FEEDBACK.texture"); - cg_data->prg[i].feedback.vid_size_v = cgGetNamedParameter(cg_data->prg[i].vprg, "FEEDBACK.video_size"); - cg_data->prg[i].feedback.vid_size_f = cgGetNamedParameter(cg_data->prg[i].fprg, "FEEDBACK.video_size"); - cg_data->prg[i].feedback.tex_size_v = cgGetNamedParameter(cg_data->prg[i].vprg, "FEEDBACK.texture_size"); - cg_data->prg[i].feedback.tex_size_f = cgGetNamedParameter(cg_data->prg[i].fprg, "FEEDBACK.texture_size"); - cg_data->prg[i].feedback.coord = cgGetNamedParameter(cg_data->prg[i].vprg, "FEEDBACK.tex_coord"); + cg->prg[i].feedback.tex = cgGetNamedParameter(cg->prg[i].fprg, "FEEDBACK.texture"); + cg->prg[i].feedback.vid_size_v = cgGetNamedParameter(cg->prg[i].vprg, "FEEDBACK.video_size"); + cg->prg[i].feedback.vid_size_f = cgGetNamedParameter(cg->prg[i].fprg, "FEEDBACK.video_size"); + cg->prg[i].feedback.tex_size_v = cgGetNamedParameter(cg->prg[i].vprg, "FEEDBACK.texture_size"); + cg->prg[i].feedback.tex_size_f = cgGetNamedParameter(cg->prg[i].fprg, "FEEDBACK.texture_size"); + cg->prg[i].feedback.coord = cgGetNamedParameter(cg->prg[i].vprg, "FEEDBACK.tex_coord"); if (i > 1) { char pass_str[64] = {0}; snprintf(pass_str, sizeof(pass_str), "PASSPREV%u", i); - gl_cg_set_pass_attrib(&cg_data->prg[i], &cg_data->prg[i].orig, pass_str); + gl_cg_set_pass_attrib(&cg->prg[i], &cg->prg[i].orig, pass_str); } for (j = 0; j < PREV_TEXTURES; j++) @@ -1047,20 +1047,20 @@ static void gl_cg_set_program_attributes(void *data, unsigned i) snprintf(attr_buf_coord, sizeof(attr_buf_coord), "%s.tex_coord", prev_names[j]); - cg_data->prg[i].prev[j].tex = cgGetNamedParameter(cg_data->prg[i].fprg, + cg->prg[i].prev[j].tex = cgGetNamedParameter(cg->prg[i].fprg, attr_buf_tex); - cg_data->prg[i].prev[j].vid_size_v = - cgGetNamedParameter(cg_data->prg[i].vprg, attr_buf_vid_size); - cg_data->prg[i].prev[j].vid_size_f = - cgGetNamedParameter(cg_data->prg[i].fprg, attr_buf_vid_size); + cg->prg[i].prev[j].vid_size_v = + cgGetNamedParameter(cg->prg[i].vprg, attr_buf_vid_size); + cg->prg[i].prev[j].vid_size_f = + cgGetNamedParameter(cg->prg[i].fprg, attr_buf_vid_size); - cg_data->prg[i].prev[j].tex_size_v = - cgGetNamedParameter(cg_data->prg[i].vprg, attr_buf_tex_size); - cg_data->prg[i].prev[j].tex_size_f = - cgGetNamedParameter(cg_data->prg[i].fprg, attr_buf_tex_size); + cg->prg[i].prev[j].tex_size_v = + cgGetNamedParameter(cg->prg[i].vprg, attr_buf_tex_size); + cg->prg[i].prev[j].tex_size_f = + cgGetNamedParameter(cg->prg[i].fprg, attr_buf_tex_size); - cg_data->prg[i].prev[j].coord = cgGetNamedParameter(cg_data->prg[i].vprg, + cg->prg[i].prev[j].coord = cgGetNamedParameter(cg->prg[i].vprg, attr_buf_coord); } @@ -1069,13 +1069,13 @@ static void gl_cg_set_program_attributes(void *data, unsigned i) char pass_str[64] = {0}; snprintf(pass_str, sizeof(pass_str), "PASS%u", j + 1); - gl_cg_set_pass_attrib(&cg_data->prg[i], &cg_data->prg[i].fbo[j], pass_str); + gl_cg_set_pass_attrib(&cg->prg[i], &cg->prg[i].fbo[j], pass_str); snprintf(pass_str, sizeof(pass_str), "PASSPREV%u", i - (j + 1)); - gl_cg_set_pass_attrib(&cg_data->prg[i], &cg_data->prg[i].fbo[j], pass_str); + gl_cg_set_pass_attrib(&cg->prg[i], &cg->prg[i].fbo[j], pass_str); - if (*cg_data->shader->pass[j].alias) - gl_cg_set_pass_attrib(&cg_data->prg[i], &cg_data->prg[i].fbo[j], - cg_data->shader->pass[j].alias); + if (*cg->shader->pass[j].alias) + gl_cg_set_pass_attrib(&cg->prg[i], &cg->prg[i].fbo[j], + cg->shader->pass[j].alias); } } @@ -1083,19 +1083,19 @@ static void *gl_cg_init(void *data, const char *path) { unsigned i; struct shader_program_info shader_prog_info; - cg_shader_data_t *cg_data = (cg_shader_data_t*) + cg_shader_data_t *cg = (cg_shader_data_t*) calloc(1, sizeof(cg_shader_data_t)); - if (!cg_data) + if (!cg) return NULL; #ifdef HAVE_CG_RUNTIME_COMPILER cgRTCgcInit(); #endif - cg_data->cgCtx = cgCreateContext(); + cg->cgCtx = cgCreateContext(); - if (!cg_data->cgCtx) + if (!cg->cgCtx) { RARCH_ERR("Failed to create Cg context.\n"); goto error; @@ -1106,113 +1106,113 @@ static void *gl_cg_init(void *data, const char *path) cgSetErrorHandler(cg_error_handler, NULL); #endif - cg_data->cgFProf = cgGLGetLatestProfile(CG_GL_FRAGMENT); - cg_data->cgVProf = cgGLGetLatestProfile(CG_GL_VERTEX); + cg->cgFProf = cgGLGetLatestProfile(CG_GL_FRAGMENT); + cg->cgVProf = cgGLGetLatestProfile(CG_GL_VERTEX); if ( - cg_data->cgFProf == CG_PROFILE_UNKNOWN || - cg_data->cgVProf == CG_PROFILE_UNKNOWN) + cg->cgFProf == CG_PROFILE_UNKNOWN || + cg->cgVProf == CG_PROFILE_UNKNOWN) { RARCH_ERR("Invalid profile type\n"); goto error; } - RARCH_LOG("[Cg]: Vertex profile: %s\n", cgGetProfileString(cg_data->cgVProf)); - RARCH_LOG("[Cg]: Fragment profile: %s\n", cgGetProfileString(cg_data->cgFProf)); - cgGLSetOptimalOptions(cg_data->cgFProf); - cgGLSetOptimalOptions(cg_data->cgVProf); - cgGLEnableProfile(cg_data->cgFProf); - cgGLEnableProfile(cg_data->cgVProf); + RARCH_LOG("[Cg]: Vertex profile: %s\n", cgGetProfileString(cg->cgVProf)); + RARCH_LOG("[Cg]: Fragment profile: %s\n", cgGetProfileString(cg->cgFProf)); + cgGLSetOptimalOptions(cg->cgFProf); + cgGLSetOptimalOptions(cg->cgVProf); + cgGLEnableProfile(cg->cgFProf); + cgGLEnableProfile(cg->cgVProf); - memset(cg_data->alias_define, 0, sizeof(cg_data->alias_define)); + memset(cg->alias_define, 0, sizeof(cg->alias_define)); if (path && string_is_equal(path_get_extension(path), "cgp")) { - if (!gl_cg_load_preset(cg_data, path)) + if (!gl_cg_load_preset(cg, path)) goto error; } else { - if (!gl_cg_load_plain(cg_data, path)) + if (!gl_cg_load_plain(cg, path)) goto error; } - cg_data->prg[0].mvp = cgGetNamedParameter(cg_data->prg[0].vprg, "IN.mvp_matrix"); + cg->prg[0].mvp = cgGetNamedParameter(cg->prg[0].vprg, "IN.mvp_matrix"); - for (i = 1; i <= cg_data->shader->passes; i++) - gl_cg_set_program_attributes(cg_data, i); + for (i = 1; i <= cg->shader->passes; i++) + gl_cg_set_program_attributes(cg, i); /* If we aren't using last pass non-FBO shader, * this shader will be assumed to be "fixed-function". * * Just use prg[0] for that pass, which will be * pass-through. */ - cg_data->prg[cg_data->shader->passes + 1] = cg_data->prg[0]; + cg->prg[cg->shader->passes + 1] = cg->prg[0]; /* No need to apply Android hack in Cg. */ - cg_data->prg[VIDEO_SHADER_STOCK_BLEND] = cg_data->prg[0]; + cg->prg[VIDEO_SHADER_STOCK_BLEND] = cg->prg[0]; - gl_cg_set_shaders(cg_data->prg[1].fprg, cg_data->prg[1].vprg); + gl_cg_set_shaders(cg->prg[1].fprg, cg->prg[1].vprg); shader_prog_info.combined = stock_xmb_simple; shader_prog_info.is_file = false; gl_cg_compile_program( - cg_data, + cg, VIDEO_SHADER_MENU, - &cg_data->prg[VIDEO_SHADER_MENU], + &cg->prg[VIDEO_SHADER_MENU], &shader_prog_info); shader_prog_info.combined = stock_xmb_simple; gl_cg_compile_program( - cg_data, + cg, VIDEO_SHADER_MENU_SEC, - &cg_data->prg[VIDEO_SHADER_MENU_SEC], + &cg->prg[VIDEO_SHADER_MENU_SEC], &shader_prog_info); - gl_cg_reset_attrib(cg_data); + gl_cg_reset_attrib(cg); - return cg_data; + return cg; error: - gl_cg_destroy_resources(cg_data); - if (!cg_data) - free(cg_data); + gl_cg_destroy_resources(cg); + if (!cg) + free(cg); return NULL; } static void gl_cg_use(void *data, void *shader_data, unsigned idx, bool set_active) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data; - if (cg_data && cg_data->prg[idx].vprg && cg_data->prg[idx].fprg) + cg_shader_data_t *cg = (cg_shader_data_t*)shader_data; + if (cg && cg->prg[idx].vprg && cg->prg[idx].fprg) { if (set_active) { - gl_cg_reset_attrib(cg_data); - cg_data->active_idx = idx; + gl_cg_reset_attrib(cg); + cg->active_idx = idx; } - gl_cg_set_shaders(cg_data->prg[idx].fprg, cg_data->prg[idx].vprg); + gl_cg_set_shaders(cg->prg[idx].fprg, cg->prg[idx].vprg); } } static unsigned gl_cg_num(void *data) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; - if (!cg_data) + cg_shader_data_t *cg = (cg_shader_data_t*)data; + if (!cg) return 0; - return cg_data->shader->passes; + return cg->shader->passes; } static bool gl_cg_filter_type(void *data, unsigned idx, bool *smooth) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; - if (cg_data && idx && - (cg_data->shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC) + cg_shader_data_t *cg = (cg_shader_data_t*)data; + if (cg && idx && + (cg->shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC) ) { - *smooth = (cg_data->shader->pass[idx - 1].filter == RARCH_FILTER_LINEAR); + *smooth = (cg->shader->pass[idx - 1].filter == RARCH_FILTER_LINEAR); return true; } @@ -1221,17 +1221,17 @@ static bool gl_cg_filter_type(void *data, unsigned idx, bool *smooth) static enum gfx_wrap_type gl_cg_wrap_type(void *data, unsigned idx) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; - if (cg_data && idx) - return cg_data->shader->pass[idx - 1].wrap; + cg_shader_data_t *cg = (cg_shader_data_t*)data; + if (cg && idx) + return cg->shader->pass[idx - 1].wrap; return RARCH_WRAP_BORDER; } static void gl_cg_shader_scale(void *data, unsigned idx, struct gfx_fbo_scale *scale) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; - if (cg_data && idx) - *scale = cg_data->shader->pass[idx - 1].fbo; + cg_shader_data_t *cg = (cg_shader_data_t*)data; + if (cg && idx) + *scale = cg->shader->pass[idx - 1].fbo; else scale->valid = false; } @@ -1240,14 +1240,14 @@ static unsigned gl_cg_get_prev_textures(void *data) { unsigned i, j; unsigned max_prev = 0; - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; + cg_shader_data_t *cg = (cg_shader_data_t*)data; - if (!cg_data) + if (!cg) return 0; - for (i = 1; i <= cg_data->shader->passes; i++) + for (i = 1; i <= cg->shader->passes; i++) for (j = 0; j < PREV_TEXTURES; j++) - if (cg_data->prg[i].prev[j].tex) + if (cg->prg[i].prev[j].tex) max_prev = MAX(j + 1, max_prev); return max_prev; @@ -1255,28 +1255,28 @@ static unsigned gl_cg_get_prev_textures(void *data) static bool gl_cg_get_feedback_pass(void *data, unsigned *pass) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; - if (!cg_data || cg_data->shader->feedback_pass < 0) + cg_shader_data_t *cg = (cg_shader_data_t*)data; + if (!cg || cg->shader->feedback_pass < 0) return false; - *pass = cg_data->shader->feedback_pass; + *pass = cg->shader->feedback_pass; return true; } static bool gl_cg_mipmap_input(void *data, unsigned idx) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; - if (cg_data && idx) - return cg_data->shader->pass[idx - 1].mipmap; + cg_shader_data_t *cg = (cg_shader_data_t*)data; + if (cg && idx) + return cg->shader->pass[idx - 1].mipmap; return false; } static struct video_shader *gl_cg_get_current_shader(void *data) { - cg_shader_data_t *cg_data = (cg_shader_data_t*)data; - if (!cg_data) + cg_shader_data_t *cg = (cg_shader_data_t*)data; + if (!cg) return NULL; - return cg_data->shader; + return cg->shader; } const shader_backend_t gl_cg_backend = {