fo_context.c File Reference

Include dependency graph for fo_context.c:

Go to the source code of this file.

Functions
static void	failover_destroy (struct pipe_context *pipe)
static boolean	failover_draw_elements (struct pipe_context *pipe, struct pipe_buffer *indexBuffer, unsigned indexSize, unsigned prim, unsigned start, unsigned count)
static boolean	failover_draw_arrays (struct pipe_context *pipe, unsigned prim, unsigned start, unsigned count)
struct pipe_context *	failover_create (struct pipe_context *hw, struct pipe_context *sw)

---

Function Documentation

struct pipe_context* failover_create	(	struct pipe_context *	hw,
		struct pipe_context *	sw
	)			[read]

Definition at line 110 of file fo_context.c.

References pipe_context::begin_query, CALLOC_STRUCT, pipe_context::clear, pipe_context::destroy, failover_context::dirty, pipe_context::draw_arrays, pipe_context::draw_elements, pipe_context::end_query, failover_destroy(), failover_draw_arrays(), failover_draw_elements(), failover_init_state_functions(), pipe_context::flush, failover_context::hw, failover_context::pipe, pipe_context::screen, pipe_context::surface_copy, pipe_context::surface_fill, failover_context::sw, and pipe_context::winsys.

{
   struct failover_context *failover = CALLOC_STRUCT(failover_context);
   if (failover == NULL)
      return NULL;

   failover->hw = hw;
   failover->sw = sw;
   failover->pipe.winsys = hw->winsys;
   failover->pipe.screen = hw->screen;
   failover->pipe.destroy = failover_destroy;
#if 0
   failover->pipe.is_format_supported = hw->is_format_supported;
   failover->pipe.get_name = hw->get_name;
   failover->pipe.get_vendor = hw->get_vendor;
   failover->pipe.get_param = hw->get_param;
   failover->pipe.get_paramf = hw->get_paramf;
#endif

   failover->pipe.draw_arrays = failover_draw_arrays;
   failover->pipe.draw_elements = failover_draw_elements;
   failover->pipe.clear = hw->clear;

   /* No software occlusion fallback (or other optional functionality)
    * at this point - if the hardware doesn't support it, don't
    * advertise it to the application.
    */
   failover->pipe.begin_query = hw->begin_query;
   failover->pipe.end_query = hw->end_query;

   failover_init_state_functions( failover );

   failover->pipe.surface_copy = hw->surface_copy;
   failover->pipe.surface_fill = hw->surface_fill;

#if 0
   failover->pipe.texture_create = hw->texture_create;
   failover->pipe.texture_release = hw->texture_release;
   failover->pipe.get_tex_surface = hw->get_tex_surface;
   failover->pipe.texture_update = hw->texture_update;
#endif

   failover->pipe.flush = hw->flush;

   failover->dirty = 0;

   return &failover->pipe;
}

static void failover_destroy

(

struct pipe_context *

pipe

)

[static]

Definition at line 39 of file fo_context.c.

References failover_context().

{
   struct failover_context *failover = failover_context( pipe );

   free( failover );
}

static boolean failover_draw_arrays	(	struct pipe_context *	pipe,
		unsigned	prim,
		unsigned	start,
		unsigned	count
	)			[static]

Definition at line 102 of file fo_context.c.

References failover_draw_elements().

{
   return failover_draw_elements(pipe, NULL, 0, prim, start, count);
}

static boolean failover_draw_elements	(	struct pipe_context *	pipe,
		struct pipe_buffer *	indexBuffer,
		unsigned	indexSize,
		unsigned	prim,
		unsigned	start,
		unsigned	count
	)			[static]

Definition at line 48 of file fo_context.c.

References failover_context::dirty, pipe_context::draw_elements, failover_context(), failover_state_emit(), pipe_context::flush, FO_HW, FO_SW, failover_context::hw, failover_context::mode, failover_context::sw, and TRUE.

{
   struct failover_context *failover = failover_context( pipe );

   /* If there has been any statechange since last time, try hardware
    * rendering again:
    */
   if (failover->dirty) {
      failover->mode = FO_HW;
   }

   /* Try hardware:
    */
   if (failover->mode == FO_HW) {
      if (!failover->hw->draw_elements( failover->hw, 
                                        indexBuffer, 
                                        indexSize, 
                                        prim, 
                                        start, 
                                        count )) {

         failover->hw->flush( failover->hw, ~0, NULL );
         failover->mode = FO_SW;
      }
   }

   /* Possibly try software:
    */
   if (failover->mode == FO_SW) {

      if (failover->dirty) 
         failover_state_emit( failover );

      failover->sw->draw_elements( failover->sw, 
                                   indexBuffer, 
                                   indexSize, 
                                   prim, 
                                   start, 
                                   count );

      /* Be ready to switch back to hardware rendering without an
       * intervening flush.  Unlikely to be much performance impact to
       * this:
       */
      failover->sw->flush( failover->sw, ~0, NULL );
   }

   return TRUE;
}

---