st_context.c File Reference

Include dependency graph for st_context.c:

Go to the source code of this file.

Functions
void	st_invalidate_state (GLcontext *ctx, GLuint new_state)
	Called via ctx->Driver.UpdateState().
int	st_get_msaa (void)
	Check for multisample env var override.
static struct st_context *	st_create_context_priv (GLcontext *ctx, struct pipe_context *pipe)
struct st_context *	st_create_context (struct pipe_context *pipe, const __GLcontextModes *visual, struct st_context *share)
static void	st_destroy_context_priv (struct st_context *st)
void	st_destroy_context (struct st_context *st)
void	st_make_current (struct st_context *st, struct st_framebuffer *draw, struct st_framebuffer *read)
void	st_copy_context_state (struct st_context *dst, struct st_context *src, uint mask)
st_proc	st_get_proc_address (const char *procname)
void	st_init_driver_functions (struct dd_function_table *functions)

---

Function Documentation

void st_copy_context_state	(	struct st_context *	dst,
		struct st_context *	src,
		uint	mask
	)

Definition at line 278 of file st_context.c.

References st_context::ctx.

{
   _mesa_copy_context(dst->ctx, src->ctx, mask);
}

struct st_context* st_create_context	(	struct pipe_context *	pipe,
		const __GLcontextModes *	visual,
		struct st_context *	share
	)			[read]

Definition at line 167 of file st_context.c.

References st_context::ctx, st_create_context_priv(), and st_init_driver_functions().

{
   GLcontext *ctx;
   GLcontext *shareCtx = share ? share->ctx : NULL;
   struct dd_function_table funcs;

   memset(&funcs, 0, sizeof(funcs));
   st_init_driver_functions(&funcs);

   ctx = _mesa_create_context(visual, shareCtx, &funcs, NULL);

   return st_create_context_priv(ctx, pipe);
}

static struct st_context* st_create_context_priv	(	GLcontext *	ctx,
		struct pipe_context *	pipe
	)			[static, read]

Definition at line 105 of file st_context.c.

References st_context::cache, CALLOC_STRUCT, st_context::cso_context, cso_create_context(), st_context::ctx, st_context::dirty, st_context::draw, draw_create(), draw_enable_line_stipple(), draw_enable_point_sprites(), draw_wide_line_threshold(), draw_wide_point_threshold(), FALSE, st_context::force_msaa, st_state_flags::mesa, st_context::pipe, PIPE_MAX_SAMPLERS, st_context::pixel_xfer, st_context::sampler_list, st_context::samplers, st_state_flags::st, st_get_msaa(), st_init_atoms(), st_init_bitmap(), st_init_blit(), st_init_clear(), st_init_draw(), st_init_extensions(), st_init_generate_mipmap(), st_init_limits(), and st_context::state.

{
   uint i;
   struct st_context *st = CALLOC_STRUCT( st_context );
   
   ctx->st = st;

   st->ctx = ctx;
   st->pipe = pipe;

   /* state tracker needs the VBO module */
   _vbo_CreateContext(ctx);

#if FEATURE_feedback || FEATURE_drawpix
   st->draw = draw_create(); /* for selection/feedback */

   /* Disable draw options that might convert points/lines to tris, etc.
    * as that would foul-up feedback/selection mode.
    */
   draw_wide_line_threshold(st->draw, 1000.0f);
   draw_wide_point_threshold(st->draw, 1000.0f);
   draw_enable_line_stipple(st->draw, FALSE);
   draw_enable_point_sprites(st->draw, FALSE);
#endif

   st->dirty.mesa = ~0;
   st->dirty.st = ~0;

   st->cso_context = cso_create_context(pipe);

   st_init_atoms( st );
   st_init_bitmap(st);
   st_init_clear(st);
   st_init_draw( st );
   st_init_generate_mipmap(st);
   st_init_blit(st);

   for (i = 0; i < PIPE_MAX_SAMPLERS; i++)
      st->state.sampler_list[i] = &st->state.samplers[i];

   /* we want all vertex data to be placed in buffer objects */
   vbo_use_buffer_objects(ctx);

   /* Need these flags:
    */
   st->ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
   st->ctx->FragmentProgram._UseTexEnvProgram = GL_TRUE;

   st->ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;

   st->pixel_xfer.cache = _mesa_new_program_cache();

   st->force_msaa = st_get_msaa();

   /* GL limits and extensions */
   st_init_limits(st);
   st_init_extensions(st);

   return st;
}

void st_destroy_context

(

struct st_context *

st

)

Definition at line 225 of file st_context.c.

References st_context::cache, st_context::cso_context, cso_destroy_context(), cso_release_all(), st_context::ctx, pipe_context::destroy, st_context::fp, st_context::pipe, st_context::pixel_xfer, st_destroy_context_priv(), st_reference_fragprog(), st_reference_vertprog(), and st_context::vp.

{
   struct pipe_context *pipe = st->pipe;
   struct cso_context *cso = st->cso_context;
   GLcontext *ctx = st->ctx;

   /* need to unbind and destroy CSO objects before anything else */
   cso_release_all(st->cso_context);

   st_reference_fragprog(st, &st->fp, NULL);
   st_reference_vertprog(st, &st->vp, NULL);

   _mesa_delete_program_cache(st->ctx, st->pixel_xfer.cache);

   _vbo_DestroyContext(st->ctx);

   _mesa_free_context_data(ctx);

   st_destroy_context_priv(st);

   cso_destroy_context(cso);

   pipe->destroy( pipe );

   free(ctx);
}

static void st_destroy_context_priv

(

struct st_context *

st

)

[static]

Definition at line 184 of file st_context.c.

References pipe_constant_buffer::buffer, st_context::constants, st_context::ctx, st_context::default_texture, st_context::draw, draw_destroy(), Elements, st_context::pipe, pipe_buffer_reference(), pipe_texture_reference(), st_context::sampler_texture, pipe_context::screen, st_destroy_atoms(), st_destroy_bitmap(), st_destroy_blit(), st_destroy_clear(), st_destroy_draw(), st_destroy_drawpix(), st_destroy_generate_mipmap(), and st_context::state.

{
   uint i;

#if FEATURE_feedback || FEATURE_drawpix
   draw_destroy(st->draw);
#endif
   st_destroy_atoms( st );
   st_destroy_draw( st );
   st_destroy_generate_mipmap(st);
#if FEATURE_EXT_framebuffer_blit
   st_destroy_blit(st);
#endif
   st_destroy_clear(st);
#if FEATURE_drawpix
   st_destroy_bitmap(st);
   st_destroy_drawpix(st);
#endif
#ifdef FEATURE_OES_draw_texture
   st_destroy_drawtex(st);
#endif

   for (i = 0; i < Elements(st->state.sampler_texture); i++) {
      pipe_texture_reference(&st->state.sampler_texture[i], NULL);
   }

   for (i = 0; i < Elements(st->state.constants); i++) {
      if (st->state.constants[i].buffer) {
         pipe_buffer_reference(st->pipe->screen, &st->state.constants[i].buffer, NULL);
      }
   }

   if (st->default_texture) {
      st->ctx->Driver.DeleteTexture(st->ctx, st->default_texture);
      st->default_texture = NULL;
   }

   free( st );
}

int st_get_msaa

(

void

)

Check for multisample env var override.

Definition at line 95 of file st_context.c.

{
   const char *msaa = _mesa_getenv("__GL_FSAA_MODE");
   if (msaa)
      return atoi(msaa);
   return 0;
}

st_proc st_get_proc_address

(

const char *

procname

)

Definition at line 287 of file st_context.c.

{
   return (st_proc) _glapi_get_proc_address(procname);
}

void st_init_driver_functions

(

struct dd_function_table *

functions

)

Definition at line 294 of file st_context.c.

References st_init_accum_functions(), st_init_bitmap_functions(), st_init_blit_functions(), st_init_bufferobject_functions(), st_init_clear_functions(), st_init_drawpixels_functions(), st_init_fbo_functions(), st_init_feedback_functions(), st_init_flush_functions(), st_init_get_functions(), st_init_program_functions(), st_init_query_functions(), st_init_rasterpos_functions(), st_init_readpixels_functions(), st_init_string_functions(), st_init_texture_functions(), and st_invalidate_state().

{
   _mesa_init_glsl_driver_functions(functions);

#if FEATURE_accum
   st_init_accum_functions(functions);
#endif
#if FEATURE_EXT_framebuffer_blit
   st_init_blit_functions(functions);
#endif
   st_init_bufferobject_functions(functions);
   st_init_clear_functions(functions);
#if FEATURE_drawpix
   st_init_bitmap_functions(functions);
   st_init_drawpixels_functions(functions);
   st_init_rasterpos_functions(functions);
#endif
   st_init_fbo_functions(functions);
   st_init_get_functions(functions);
#if FEATURE_feedback
   st_init_feedback_functions(functions);
#endif
   st_init_program_functions(functions);
#if FEATURE_ARB_occlusion_query
   st_init_query_functions(functions);
#endif
   st_init_readpixels_functions(functions);
   st_init_texture_functions(functions);
   st_init_flush_functions(functions);
   st_init_string_functions(functions);

   functions->UpdateState = st_invalidate_state;
}

void st_invalidate_state	(	GLcontext *	ctx,
		GLuint	new_state
	)

Called via ctx->Driver.UpdateState().

Definition at line 77 of file st_context.c.

References st_context::dirty, st_state_flags::mesa, st_state_flags::st, st_context(), and ST_NEW_MESA.

{
   struct st_context *st = st_context(ctx);

   st->dirty.mesa |= new_state;
   st->dirty.st |= ST_NEW_MESA;

   /* This is the only core Mesa module we depend upon.
    * No longer use swrast, swsetup, tnl.
    */
   _vbo_InvalidateState(ctx, new_state);
}

void st_make_current	(	struct st_context *	st,
		struct st_framebuffer *	draw,
		struct st_framebuffer *	read
	)

Definition at line 253 of file st_context.c.

References st_framebuffer::Base, st_context::ctx, st_framebuffer::InitHeight, and st_framebuffer::InitWidth.

{
   if (st) {
      GLboolean firstTime = st->ctx->FirstTimeCurrent;
      _mesa_make_current(st->ctx, &draw->Base, &read->Base);
      /* Need to initialize viewport here since draw->Base->Width/Height
       * will still be zero at this point.
       * This could be improved, but would require rather extensive work
       * elsewhere (allocate rb surface storage sooner)
       */
      if (firstTime) {
         GLuint w = draw->InitWidth, h = draw->InitHeight;
         _mesa_set_viewport(st->ctx, 0, 0, w, h);
         _mesa_set_scissor(st->ctx, 0, 0, w, h);

      }
   }
   else {
      _mesa_make_current(NULL, NULL, NULL);
   }
}

---