static void svga_delete_vs_state(struct pipe_context *pipe, void *shader)
{
struct svga_context *svga = svga_context(pipe);
struct svga_vertex_shader *vs = (struct svga_vertex_shader *)shader;
struct svga_shader_result *result, *tmp;
enum pipe_error ret;
svga_hwtnl_flush_retry( svga );
draw_delete_vertex_shader(svga->swtnl.draw, vs->draw_shader);
for (result = vs->base.results; result; result = tmp ) {
tmp = result->next;
ret = SVGA3D_DestroyShader(svga->swc,
result->id,
SVGA3D_SHADERTYPE_VS );
if(ret != PIPE_OK) {
svga_context_flush(svga, NULL);
ret = SVGA3D_DestroyShader(svga->swc,
result->id,
SVGA3D_SHADERTYPE_VS );
assert(ret == PIPE_OK);
}
svga_destroy_shader_result( result );
}
FREE((void *)vs->base.tokens);
FREE(vs);
}
static void r300_delete_vs_state(struct pipe_context* pipe, void* shader)
{
struct r300_context* r300 = r300_context(pipe);
if (r300_screen(pipe->screen)->caps->has_tcl) {
struct r300_vertex_shader* vs = (struct r300_vertex_shader*)shader;
rc_constants_destroy(&vs->code.constants);
draw_delete_vertex_shader(r300->draw, vs->draw);
FREE((void*)vs->state.tokens);
FREE(shader);
} else {
draw_delete_vertex_shader(r300->draw,
(struct draw_vertex_shader*)shader);
}
}
static void i915_delete_vs_state(struct pipe_context *pipe, void *shader)
{
struct i915_context *i915 = i915_context(pipe);
/* just pass-through to draw module */
draw_delete_vertex_shader(i915->draw, (struct draw_vertex_shader *) shader);
}
void
st_delete_program(GLcontext *ctx, struct gl_program *prog)
{
struct st_context *st = st_context(ctx);
switch( prog->Target ) {
case GL_VERTEX_PROGRAM_ARB:
{
struct st_vertex_program *stvp = (struct st_vertex_program *) prog;
if (stvp->driver_shader) {
cso_delete_vertex_shader(st->cso_context, stvp->driver_shader);
stvp->driver_shader = NULL;
}
if (stvp->draw_shader) {
#if FEATURE_feedback || FEATURE_drawpix
/* this would only have been allocated for the RasterPos path */
draw_delete_vertex_shader(st->draw, stvp->draw_shader);
stvp->draw_shader = NULL;
#endif
}
if (stvp->state.tokens) {
st_free_tokens(stvp->state.tokens);
stvp->state.tokens = NULL;
}
}
break;
case GL_FRAGMENT_PROGRAM_ARB:
{
struct st_fragment_program *stfp = (struct st_fragment_program *) prog;
if (stfp->driver_shader) {
cso_delete_fragment_shader(st->cso_context, stfp->driver_shader);
stfp->driver_shader = NULL;
}
if (stfp->state.tokens) {
st_free_tokens(stfp->state.tokens);
stfp->state.tokens = NULL;
}
if (stfp->bitmap_program) {
struct gl_program *prg = &stfp->bitmap_program->Base.Base;
_mesa_reference_program(ctx, &prg, NULL);
stfp->bitmap_program = NULL;
}
st_free_translated_vertex_programs(st, stfp->vertex_programs);
}
break;
default:
assert(0); /* problem */
}
/* delete base class */
_mesa_delete_program( ctx, prog );
}
static void
llvmpipe_delete_vs_state(struct pipe_context *pipe, void *_vs)
{
struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
struct draw_vertex_shader *vs = (struct draw_vertex_shader *)_vs;
draw_delete_vertex_shader(llvmpipe->draw, vs);
}
/**
* Called via pipe->delete_vs_state()
*/
static void
cell_delete_vs_state(struct pipe_context *pipe, void *vs)
{
struct cell_context *cell = cell_context(pipe);
struct cell_vertex_shader_state *cvs = cell_vertex_shader_state(vs);
draw_delete_vertex_shader(cell->draw, cvs->draw_data);
FREE( (void *) cvs->shader.tokens );
FREE( cvs );
}
static void st_program_string_notify( GLcontext *ctx,
GLenum target,
struct gl_program *prog )
{
struct st_context *st = st_context(ctx);
if (target == GL_FRAGMENT_PROGRAM_ARB) {
struct st_fragment_program *stfp = (struct st_fragment_program *) prog;
stfp->serialNo++;
if (stfp->driver_shader) {
cso_delete_fragment_shader(st->cso_context, stfp->driver_shader);
stfp->driver_shader = NULL;
}
if (stfp->state.tokens) {
st_free_tokens(stfp->state.tokens);
stfp->state.tokens = NULL;
}
stfp->param_state = stfp->Base.Base.Parameters->StateFlags;
if (st->fp == stfp)
st->dirty.st |= ST_NEW_FRAGMENT_PROGRAM;
}
else if (target == GL_VERTEX_PROGRAM_ARB) {
struct st_vertex_program *stvp = (struct st_vertex_program *) prog;
stvp->serialNo++;
if (stvp->driver_shader) {
cso_delete_vertex_shader(st->cso_context, stvp->driver_shader);
stvp->driver_shader = NULL;
}
if (stvp->draw_shader) {
#if FEATURE_feedback || FEATURE_drawpix
/* this would only have been allocated for the RasterPos path */
draw_delete_vertex_shader(st->draw, stvp->draw_shader);
stvp->draw_shader = NULL;
#endif
}
if (stvp->state.tokens) {
st_free_tokens(stvp->state.tokens);
stvp->state.tokens = NULL;
}
stvp->param_state = stvp->Base.Base.Parameters->StateFlags;
if (st->vp == stvp)
st->dirty.st |= ST_NEW_VERTEX_PROGRAM;
}
}
static void
nv40_vp_state_delete(struct pipe_context *pipe, void *hwcso)
{
struct nv40_context *nv40 = nv40_context(pipe);
struct nv40_vertex_program *vp = hwcso;
draw_delete_vertex_shader(nv40->draw, vp->draw);
nv40_vertprog_destroy(nv40, vp);
FREE((void*)vp->pipe.tokens);
FREE(vp);
}
static void
llvmpipe_delete_vs_state(struct pipe_context *pipe, void *vs)
{
struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
struct lp_vertex_shader *state =
(struct lp_vertex_shader *)vs;
draw_delete_vertex_shader(llvmpipe->draw, state->draw_data);
FREE( (void *)state->shader.tokens );
FREE( state );
}
/**
* Delete a vertex program variant. Note the caller must unlink
* the variant from the linked list.
*/
static void
delete_vp_variant(struct st_context *st, struct st_vp_variant *vpv)
{
if (vpv->driver_shader)
cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
if (vpv->draw_shader)
draw_delete_vertex_shader( st->draw, vpv->draw_shader );
if (vpv->tgsi.tokens)
ureg_free_tokens(vpv->tgsi.tokens);
free( vpv );
}
static void
nv30_vp_state_delete(struct pipe_context *pipe, void *hwcso)
{
struct nv30_vertprog *vp = hwcso;
if (vp->translated)
nv30_vertprog_destroy(vp);
if (vp->draw)
draw_delete_vertex_shader(nv30_context(pipe)->draw, vp->draw);
FREE((void *)vp->pipe.tokens);
FREE(vp);
}
static void
svga_delete_vs_state(struct pipe_context *pipe, void *shader)
{
struct svga_context *svga = svga_context(pipe);
struct svga_vertex_shader *vs = (struct svga_vertex_shader *)shader;
struct svga_shader_variant *variant, *tmp;
enum pipe_error ret;
svga_hwtnl_flush_retry(svga);
assert(vs->base.parent == NULL);
/* Check if there is a generated geometry shader to go with this
* vertex shader. If there is, then delete the geometry shader as well.
*/
if (vs->gs != NULL) {
svga->pipe.delete_gs_state(&svga->pipe, vs->gs);
}
if (vs->base.stream_output != NULL)
svga_delete_stream_output(svga, vs->base.stream_output);
draw_delete_vertex_shader(svga->swtnl.draw, vs->draw_shader);
for (variant = vs->base.variants; variant; variant = tmp) {
tmp = variant->next;
/* Check if deleting currently bound shader */
if (variant == svga->state.hw_draw.vs) {
ret = svga_set_shader(svga, SVGA3D_SHADERTYPE_VS, NULL);
if (ret != PIPE_OK) {
svga_context_flush(svga, NULL);
ret = svga_set_shader(svga, SVGA3D_SHADERTYPE_VS, NULL);
assert(ret == PIPE_OK);
}
svga->state.hw_draw.vs = NULL;
}
ret = svga_destroy_shader_variant(svga, SVGA3D_SHADERTYPE_VS, variant);
if (ret != PIPE_OK) {
svga_context_flush(svga, NULL);
ret = svga_destroy_shader_variant(svga, SVGA3D_SHADERTYPE_VS, variant);
assert(ret == PIPE_OK);
}
}
FREE((void *)vs->base.tokens);
FREE(vs);
}
/**
* Delete a vertex program variant. Note the caller must unlink
* the variant from the linked list.
*/
static void
delete_vp_variant(struct st_context *st, struct st_vp_variant *vpv)
{
if (vpv->driver_shader)
cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
#if FEATURE_feedback || FEATURE_rastpos
if (vpv->draw_shader)
draw_delete_vertex_shader( st->draw, vpv->draw_shader );
#endif
if (vpv->tgsi.tokens)
st_free_tokens(vpv->tgsi.tokens);
FREE( vpv );
}
static void
svga_delete_vs_state(struct pipe_context *pipe, void *shader)
{
struct svga_context *svga = svga_context(pipe);
struct svga_vertex_shader *vs = (struct svga_vertex_shader *)shader;
struct svga_shader_result *result, *tmp;
enum pipe_error ret;
svga_hwtnl_flush_retry(svga);
draw_delete_vertex_shader(svga->swtnl.draw, vs->draw_shader);
for (result = vs->base.results; result; result = tmp) {
tmp = result->next;
ret = SVGA3D_DestroyShader(svga->swc, result->id, SVGA3D_SHADERTYPE_VS);
if (ret != PIPE_OK) {
svga_context_flush(svga, NULL);
ret = SVGA3D_DestroyShader(svga->swc, result->id,
SVGA3D_SHADERTYPE_VS);
assert(ret == PIPE_OK);
}
util_bitmask_clear(svga->vs_bm, result->id);
svga_destroy_shader_result(result);
/*
* Remove stale references to this result to ensure a new result on the
* same address will be detected as a change.
*/
if (result == svga->state.hw_draw.vs)
svga->state.hw_draw.vs = NULL;
}
FREE((void *)vs->base.tokens);
FREE(vs);
}
