st_atom.c File Reference

Include dependency graph for st_atom.c:

Go to the source code of this file.

Functions
void	st_init_atoms (struct st_context *st)
void	st_destroy_atoms (struct st_context *st)
static GLboolean	check_state (const struct st_state_flags *a, const struct st_state_flags *b)
static void	accumulate_state (struct st_state_flags *a, const struct st_state_flags *b)
static void	xor_states (struct st_state_flags *result, const struct st_state_flags *a, const struct st_state_flags *b)
static void	check_program_state (struct st_context *st)
void	st_validate_state (struct st_context *st)
Variables
static struct st_tracked_state *	atoms []

---

Function Documentation

static void accumulate_state	(	struct st_state_flags *	a,
		const struct st_state_flags *	b
	)			[static]

Definition at line 111 of file st_atom.c.

References st_state_flags::mesa, and st_state_flags::st.

{
   a->mesa |= b->mesa;
   a->st |= b->st;
}

static void check_program_state

(

struct st_context *

st

)

[static]

Definition at line 130 of file st_atom.c.

References st_fragment_program::Base, st_vertex_program::Base, st_context::ctx, st_context::dirty, st_context::fp, st_state_flags::st, ST_NEW_FRAGMENT_PROGRAM, ST_NEW_VERTEX_PROGRAM, and st_context::vp.

{
   GLcontext *ctx = st->ctx;

   if (ctx->VertexProgram._Current != &st->vp->Base)
      st->dirty.st |= ST_NEW_VERTEX_PROGRAM;

   if (ctx->FragmentProgram._Current != &st->fp->Base)
      st->dirty.st |= ST_NEW_FRAGMENT_PROGRAM;

}

static GLboolean check_state	(	const struct st_state_flags *	a,
		const struct st_state_flags *	b
	)			[static]

Definition at line 104 of file st_atom.c.

References st_state_flags::mesa, and st_state_flags::st.

{
   return ((a->mesa & b->mesa) ||
           (a->st & b->st));
}

void st_destroy_atoms

(

struct st_context *

st

)

Definition at line 92 of file st_atom.c.

References st_context::atoms.

{
   if (st->atoms) {
      free(st->atoms);
      st->atoms = NULL;
   }
}

void st_init_atoms

(

struct st_context *

st

)

Definition at line 68 of file st_atom.c.

References st_context::atoms, st_context::constants, st_context::nr_atoms, PIPE_SHADER_FRAGMENT, PIPE_SHADER_VERTEX, st_update_fs_constants, and st_update_vs_constants.

{
   GLuint i;

   st->atoms = malloc(sizeof(atoms));
   st->nr_atoms = sizeof(atoms)/sizeof(*atoms);
   memcpy(st->atoms, atoms, sizeof(atoms));

   /* Patch in a pointer to the dynamic state atom:
    */
   for (i = 0; i < st->nr_atoms; i++) {
      if (st->atoms[i] == &st_update_vs_constants) {
         st->atoms[i] = &st->constants.tracked_state[PIPE_SHADER_VERTEX];
         st->atoms[i][0] = st_update_vs_constants;
      }

      if (st->atoms[i] == &st_update_fs_constants) {
         st->atoms[i] = &st->constants.tracked_state[PIPE_SHADER_FRAGMENT];
         st->atoms[i][0] = st_update_fs_constants;
      }
   }
}

void st_validate_state

(

struct st_context *

st

)

Definition at line 147 of file st_atom.c.

References accumulate_state(), assert, st_context::atoms, check_program_state(), check_state(), st_tracked_state::dirty, st_context::dirty, st_state_flags::mesa, st_tracked_state::name, st_context::nr_atoms, st_state_flags::st, st_flush_bitmap_cache(), st_tracked_state::update, and xor_states().

{
   struct st_state_flags *state = &st->dirty;
   GLuint i;

   /* The bitmap cache is immune to pixel unpack changes.
    * Note that GLUT makes several calls to glPixelStore for each
    * bitmap char it draws so this is an important check.
    */
   if (state->mesa & ~_NEW_PACKUNPACK)
      st_flush_bitmap_cache(st);

   check_program_state( st );

   if (state->st == 0)
      return;

//   _mesa_printf("%s %x/%x\n", __FUNCTION__, state->mesa, state->st);

   if (1) {
      /* Debug version which enforces various sanity checks on the
       * state flags which are generated and checked to help ensure
       * state atoms are ordered correctly in the list.
       */
      struct st_state_flags examined, prev;      
      memset(&examined, 0, sizeof(examined));
      prev = *state;

      for (i = 0; i < st->nr_atoms; i++) {       
         const struct st_tracked_state *atom = st->atoms[i];
         struct st_state_flags generated;
         
//       _mesa_printf("atom %s %x/%x\n", atom->name, atom->dirty.mesa, atom->dirty.st);

         if (!(atom->dirty.mesa || atom->dirty.st) ||
             !atom->update) {
            _mesa_printf("malformed atom %s\n", atom->name);
            assert(0);
         }

         if (check_state(state, &atom->dirty)) {
            st->atoms[i]->update( st );
//          _mesa_printf("after: %x\n", atom->dirty.mesa);
         }

         accumulate_state(&examined, &atom->dirty);

         /* generated = (prev ^ state)
          * if (examined & generated)
          *     fail;
          */
         xor_states(&generated, &prev, state);
         assert(!check_state(&examined, &generated));
         prev = *state;
      }
//      _mesa_printf("\n");

   }
   else {
      const GLuint nr = st->nr_atoms;

      for (i = 0; i < nr; i++) {         
         if (check_state(state, &st->atoms[i]->dirty))
            st->atoms[i]->update( st );
      }
   }

   memset(state, 0, sizeof(*state));
}

static void xor_states	(	struct st_state_flags *	result,
		const struct st_state_flags *	a,
		const struct st_state_flags *	b
	)			[static]

Definition at line 119 of file st_atom.c.

References st_state_flags::mesa, and st_state_flags::st.

{
   result->mesa = a->mesa ^ b->mesa;
   result->st = a->st ^ b->st;
}

---

Variable Documentation

struct st_tracked_state* atoms[] [static]

Initial value:

{
   &st_update_depth_stencil_alpha,
   &st_update_clip,

   &st_finalize_textures,
   &st_update_shader,

   &st_update_rasterizer,
   &st_update_polygon_stipple,
   &st_update_viewport,
   &st_update_scissor,
   &st_update_blend,
   &st_update_sampler,
   &st_update_texture,
   &st_update_framebuffer,
   &st_update_vs_constants,
   &st_update_fs_constants,
   &st_update_pixel_transfer
}

Definition at line 46 of file st_atom.c.

---