/**
* Get/create geometry program variant.
*/
struct st_gp_variant *
st_get_gp_variant(struct st_context *st,
struct st_geometry_program *stgp,
const struct st_gp_variant_key *key)
{
struct st_gp_variant *gpv;
/* Search for existing variant */
for (gpv = stgp->variants; gpv; gpv = gpv->next) {
if (memcmp(&gpv->key, key, sizeof(*key)) == 0) {
break;
}
}
if (!gpv) {
/* create new */
gpv = st_translate_geometry_program(st, stgp, key);
if (gpv) {
/* insert into list */
gpv->next = stgp->variants;
stgp->variants = gpv;
}
}
return gpv;
}
/**
* Called via ctx->Driver.ProgramStringNotify()
* Called when the program's text/code is changed. We have to free
* all shader variants and corresponding gallium shaders when this happens.
*/
static GLboolean
st_program_string_notify( struct gl_context *ctx,
GLenum target,
struct gl_program *prog )
{
struct st_context *st = st_context(ctx);
gl_shader_stage stage = _mesa_program_enum_to_shader_stage(target);
if (target == GL_FRAGMENT_PROGRAM_ARB) {
struct st_fragment_program *stfp = (struct st_fragment_program *) prog;
st_release_fp_variants(st, stfp);
if (!st_translate_fragment_program(st, stfp))
return false;
if (st->fp == stfp)
st->dirty.st |= ST_NEW_FRAGMENT_PROGRAM;
}
else if (target == GL_GEOMETRY_PROGRAM_NV) {
struct st_geometry_program *stgp = (struct st_geometry_program *) prog;
st_release_basic_variants(st, stgp->Base.Base.Target,
&stgp->variants, &stgp->tgsi);
if (!st_translate_geometry_program(st, stgp))
return false;
if (st->gp == stgp)
st->dirty.st |= ST_NEW_GEOMETRY_PROGRAM;
}
else if (target == GL_VERTEX_PROGRAM_ARB) {
struct st_vertex_program *stvp = (struct st_vertex_program *) prog;
st_release_vp_variants(st, stvp);
if (!st_translate_vertex_program(st, stvp))
return false;
if (st->vp == stvp)
st->dirty.st |= ST_NEW_VERTEX_PROGRAM;
}
else if (target == GL_TESS_CONTROL_PROGRAM_NV) {
struct st_tessctrl_program *sttcp =
(struct st_tessctrl_program *) prog;
st_release_basic_variants(st, sttcp->Base.Base.Target,
&sttcp->variants, &sttcp->tgsi);
if (!st_translate_tessctrl_program(st, sttcp))
return false;
if (st->tcp == sttcp)
st->dirty.st |= ST_NEW_TESSCTRL_PROGRAM;
}
else if (target == GL_TESS_EVALUATION_PROGRAM_NV) {
struct st_tesseval_program *sttep =
(struct st_tesseval_program *) prog;
st_release_basic_variants(st, sttep->Base.Base.Target,
&sttep->variants, &sttep->tgsi);
if (!st_translate_tesseval_program(st, sttep))
return false;
if (st->tep == sttep)
st->dirty.st |= ST_NEW_TESSEVAL_PROGRAM;
}
else if (target == GL_COMPUTE_PROGRAM_NV) {
struct st_compute_program *stcp =
(struct st_compute_program *) prog;
st_release_cp_variants(st, stcp);
if (!st_translate_compute_program(st, stcp))
return false;
if (st->cp == stcp)
st->dirty_cp.st |= ST_NEW_COMPUTE_PROGRAM;
}
else if (target == GL_FRAGMENT_SHADER_ATI) {
assert(prog);
struct st_fragment_program *stfp = (struct st_fragment_program *) prog;
assert(stfp->ati_fs);
assert(stfp->ati_fs->Program == prog);
st_init_atifs_prog(ctx, prog);
st_release_fp_variants(st, stfp);
if (!st_translate_fragment_program(st, stfp))
return false;
if (st->fp == stfp)
st->dirty.st |= ST_NEW_FRAGMENT_PROGRAM;
}
if (ST_DEBUG & DEBUG_PRECOMPILE ||
st->shader_has_one_variant[stage])
st_precompile_shader_variant(st, prog);
return GL_TRUE;
}
