From 0a3ca14fde03527eb6690b3c25f7cd27585b9254 Mon Sep 17 00:00:00 2001
From: twinaphex <libretro@gmail.com>
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 = {