cso_context.h File Reference

Include dependency graph for cso_context.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
struct cso_context *	cso_create_context (struct pipe_context *pipe)
void	cso_release_all (struct cso_context *ctx)
	Prior to context destruction, this function unbinds all state objects.
void	cso_destroy_context (struct cso_context *cso)
enum pipe_error	cso_set_blend (struct cso_context *cso, const struct pipe_blend_state *blend)
void	cso_save_blend (struct cso_context *cso)
void	cso_restore_blend (struct cso_context *cso)
enum pipe_error	cso_set_depth_stencil_alpha (struct cso_context *cso, const struct pipe_depth_stencil_alpha_state *dsa)
void	cso_save_depth_stencil_alpha (struct cso_context *cso)
void	cso_restore_depth_stencil_alpha (struct cso_context *cso)
enum pipe_error	cso_set_rasterizer (struct cso_context *cso, const struct pipe_rasterizer_state *rasterizer)
void	cso_save_rasterizer (struct cso_context *cso)
void	cso_restore_rasterizer (struct cso_context *cso)
enum pipe_error	cso_set_samplers (struct cso_context *cso, unsigned count, const struct pipe_sampler_state **states)
void	cso_save_samplers (struct cso_context *cso)
void	cso_restore_samplers (struct cso_context *cso)
enum pipe_error	cso_single_sampler (struct cso_context *cso, unsigned nr, const struct pipe_sampler_state *states)
void	cso_single_sampler_done (struct cso_context *cso)
enum pipe_error	cso_set_sampler_textures (struct cso_context *cso, uint count, struct pipe_texture **textures)
void	cso_save_sampler_textures (struct cso_context *cso)
void	cso_restore_sampler_textures (struct cso_context *cso)
enum pipe_error	cso_set_fragment_shader_handle (struct cso_context *ctx, void *handle)
void	cso_delete_fragment_shader (struct cso_context *ctx, void *handle)
void	cso_save_fragment_shader (struct cso_context *cso)
void	cso_restore_fragment_shader (struct cso_context *cso)
enum pipe_error	cso_set_vertex_shader_handle (struct cso_context *ctx, void *handle)
void	cso_delete_vertex_shader (struct cso_context *ctx, void *handle)
void	cso_save_vertex_shader (struct cso_context *cso)
void	cso_restore_vertex_shader (struct cso_context *cso)
enum pipe_error	cso_set_framebuffer (struct cso_context *cso, const struct pipe_framebuffer_state *fb)
void	cso_save_framebuffer (struct cso_context *cso)
void	cso_restore_framebuffer (struct cso_context *cso)
enum pipe_error	cso_set_viewport (struct cso_context *cso, const struct pipe_viewport_state *vp)
void	cso_save_viewport (struct cso_context *cso)
void	cso_restore_viewport (struct cso_context *cso)
enum pipe_error	cso_set_blend_color (struct cso_context *cso, const struct pipe_blend_color *bc)

---

Function Documentation

struct cso_context* cso_create_context

(

struct pipe_context *

pipe

)

[read]

Definition at line 212 of file cso_context.c.

References cso_context::cache, CALLOC_STRUCT, cso_cache_create(), cso_cache_set_sanitize_callback(), cso_destroy_context(), cso_set_maximum_cache_size(), cso_context::pipe, and sanitize_hash().

{
   struct cso_context *ctx = CALLOC_STRUCT(cso_context);
   if (ctx == NULL)
      goto out;

   ctx->cache = cso_cache_create();
   if (ctx->cache == NULL)
      goto out;
   cso_cache_set_sanitize_callback(ctx->cache,
                                   sanitize_hash,
                                   ctx);

   ctx->pipe = pipe;

   /* Enable for testing: */
   if (0) cso_set_maximum_cache_size( ctx->cache, 4 );

   return ctx;

out:
   cso_destroy_context( ctx );      
   return NULL;
}

void cso_delete_fragment_shader	(	struct cso_context *	ctx,
		void *	handle
	)

Definition at line 625 of file cso_context.c.

References pipe_context::bind_fs_state, pipe_context::delete_fs_state, cso_context::fragment_shader, and cso_context::pipe.

{
   if (handle == ctx->fragment_shader) {
      /* unbind before deleting */
      ctx->pipe->bind_fs_state(ctx->pipe, NULL);
      ctx->fragment_shader = NULL;
   }
   ctx->pipe->delete_fs_state(ctx->pipe, handle);
}

void cso_delete_vertex_shader	(	struct cso_context *	ctx,
		void *	handle
	)

Definition at line 706 of file cso_context.c.

References pipe_context::bind_vs_state, pipe_context::delete_vs_state, cso_context::pipe, and cso_context::vertex_shader.

{
   if (handle == ctx->vertex_shader) {
      /* unbind before deleting */
      ctx->pipe->bind_vs_state(ctx->pipe, NULL);
      ctx->vertex_shader = NULL;
   }
   ctx->pipe->delete_vs_state(ctx->pipe, handle);
}

void cso_destroy_context

(

struct cso_context *

cso

)

Definition at line 269 of file cso_context.c.

References FREE.

{
   if (ctx) {
      //cso_release_all( ctx );
      FREE( ctx );
   }
}

void cso_release_all

(

struct cso_context *

ctx

)

Prior to context destruction, this function unbinds all state objects.

Definition at line 241 of file cso_context.c.

References pipe_context::bind_blend_state, pipe_context::bind_depth_stencil_alpha_state, pipe_context::bind_fs_state, pipe_context::bind_rasterizer_state, pipe_context::bind_sampler_states, pipe_context::bind_vs_state, cso_context::cache, cso_cache_delete(), cso_context::fb_saved, free_framebuffer_state(), cso_context::pipe, PIPE_MAX_SAMPLERS, pipe_texture_reference(), cso_context::textures, and cso_context::textures_saved.

{
   unsigned i;
   
   if (ctx->pipe) {
      ctx->pipe->bind_blend_state( ctx->pipe, NULL );
      ctx->pipe->bind_rasterizer_state( ctx->pipe, NULL );
      ctx->pipe->bind_sampler_states( ctx->pipe, 0, NULL );
      ctx->pipe->bind_depth_stencil_alpha_state( ctx->pipe, NULL );
      ctx->pipe->bind_fs_state( ctx->pipe, NULL );
      ctx->pipe->bind_vs_state( ctx->pipe, NULL );
   }

   for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
      pipe_texture_reference(&ctx->textures[i], NULL);
      pipe_texture_reference(&ctx->textures_saved[i], NULL);
   }

   free_framebuffer_state(&ctx->fb);
   free_framebuffer_state(&ctx->fb_saved);

   if (ctx->cache) {
      cso_cache_delete( ctx->cache );
      ctx->cache = NULL;
   }
}

void cso_restore_blend

(

struct cso_context *

cso

)

Definition at line 332 of file cso_context.c.

References pipe_context::bind_blend_state, cso_context::blend, cso_context::blend_saved, and cso_context::pipe.

{
   if (ctx->blend != ctx->blend_saved) {
      ctx->blend = ctx->blend_saved;
      ctx->pipe->bind_blend_state(ctx->pipe, ctx->blend_saved);
   }
   ctx->blend_saved = NULL;
}

void cso_restore_depth_stencil_alpha

(

struct cso_context *

cso

)

Definition at line 548 of file cso_context.c.

References pipe_context::bind_depth_stencil_alpha_state, cso_context::depth_stencil, cso_context::depth_stencil_saved, and cso_context::pipe.

{
   if (ctx->depth_stencil != ctx->depth_stencil_saved) {
      ctx->depth_stencil = ctx->depth_stencil_saved;
      ctx->pipe->bind_depth_stencil_alpha_state(ctx->pipe, ctx->depth_stencil_saved);
   }
   ctx->depth_stencil_saved = NULL;
}

void cso_restore_fragment_shader

(

struct cso_context *

cso

)

Definition at line 686 of file cso_context.c.

References pipe_context::bind_fs_state, cso_context::fragment_shader, cso_context::fragment_shader_saved, and cso_context::pipe.

{
   if (ctx->fragment_shader_saved != ctx->fragment_shader) {
      ctx->pipe->bind_fs_state(ctx->pipe, ctx->fragment_shader_saved);
      ctx->fragment_shader = ctx->fragment_shader_saved;
   }
   ctx->fragment_shader_saved = NULL;
}

void cso_restore_framebuffer

(

struct cso_context *

cso

)

Definition at line 821 of file cso_context.c.

References copy_framebuffer_state(), cso_context::fb_saved, free_framebuffer_state(), cso_context::pipe, and pipe_context::set_framebuffer_state.

{
   if (memcmp(&ctx->fb, &ctx->fb_saved, sizeof(ctx->fb))) {
      copy_framebuffer_state(&ctx->fb, &ctx->fb_saved);
      ctx->pipe->set_framebuffer_state(ctx->pipe, &ctx->fb);
      free_framebuffer_state(&ctx->fb_saved);
   }
}

void cso_restore_rasterizer

(

struct cso_context *

cso

)

Definition at line 604 of file cso_context.c.

References pipe_context::bind_rasterizer_state, cso_context::pipe, cso_context::rasterizer, and cso_context::rasterizer_saved.

{
   if (ctx->rasterizer != ctx->rasterizer_saved) {
      ctx->rasterizer = ctx->rasterizer_saved;
      ctx->pipe->bind_rasterizer_state(ctx->pipe, ctx->rasterizer_saved);
   }
   ctx->rasterizer_saved = NULL;
}

void cso_restore_sampler_textures

(

struct cso_context *

cso

)

Definition at line 481 of file cso_context.c.

References cso_context::nr_textures, cso_context::nr_textures_saved, cso_context::pipe, PIPE_MAX_SAMPLERS, pipe_texture_reference(), pipe_context::set_sampler_textures, cso_context::textures, and cso_context::textures_saved.

{
   uint i;

   ctx->nr_textures = ctx->nr_textures_saved;

   for (i = 0; i < ctx->nr_textures; i++) {
      pipe_texture_reference(&ctx->textures[i], NULL);
      ctx->textures[i] = ctx->textures_saved[i];
      ctx->textures_saved[i] = NULL;
   }
   for ( ; i < PIPE_MAX_SAMPLERS; i++)
      pipe_texture_reference(&ctx->textures[i], NULL);

   ctx->pipe->set_sampler_textures(ctx->pipe, ctx->nr_textures, ctx->textures);

   ctx->nr_textures_saved = 0;
}

void cso_restore_samplers

(

struct cso_context *

cso

)

Definition at line 444 of file cso_context.c.

References cso_single_sampler_done(), cso_context::nr_samplers, cso_context::nr_samplers_saved, cso_context::samplers, and cso_context::samplers_saved.

{
   ctx->nr_samplers = ctx->nr_samplers_saved;
   memcpy(ctx->samplers, ctx->samplers_saved, sizeof(ctx->samplers));
   cso_single_sampler_done( ctx );
}

void cso_restore_vertex_shader

(

struct cso_context *

cso

)

Definition at line 765 of file cso_context.c.

References pipe_context::bind_vs_state, cso_context::pipe, cso_context::vertex_shader, and cso_context::vertex_shader_saved.

{
   if (ctx->vertex_shader_saved != ctx->vertex_shader) {
      ctx->pipe->bind_vs_state(ctx->pipe, ctx->vertex_shader_saved);
      ctx->vertex_shader = ctx->vertex_shader_saved;
   }
   ctx->vertex_shader_saved = NULL;
}

void cso_restore_viewport

(

struct cso_context *

cso

)

Definition at line 847 of file cso_context.c.

References cso_context::pipe, pipe_context::set_viewport_state, and cso_context::vp_saved.

{
   if (memcmp(&ctx->vp, &ctx->vp_saved, sizeof(ctx->vp))) {
      ctx->vp = ctx->vp_saved;
      ctx->pipe->set_viewport_state(ctx->pipe, &ctx->vp);
   }
}

void cso_save_blend

(

struct cso_context *

cso

)

Definition at line 326 of file cso_context.c.

References assert, cso_context::blend, and cso_context::blend_saved.

{
   assert(!ctx->blend_saved);
   ctx->blend_saved = ctx->blend;
}

void cso_save_depth_stencil_alpha

(

struct cso_context *

cso

)

Definition at line 542 of file cso_context.c.

References assert, cso_context::depth_stencil, and cso_context::depth_stencil_saved.

{
   assert(!ctx->depth_stencil_saved);
   ctx->depth_stencil_saved = ctx->depth_stencil;
}

void cso_save_fragment_shader

(

struct cso_context *

cso

)

Definition at line 680 of file cso_context.c.

References assert, cso_context::fragment_shader, and cso_context::fragment_shader_saved.

{
   assert(!ctx->fragment_shader_saved);
   ctx->fragment_shader_saved = ctx->fragment_shader;
}

void cso_save_framebuffer

(

struct cso_context *

cso

)

Definition at line 816 of file cso_context.c.

References copy_framebuffer_state(), and cso_context::fb_saved.

{
   copy_framebuffer_state(&ctx->fb_saved, &ctx->fb);
}

void cso_save_rasterizer

(

struct cso_context *

cso

)

Definition at line 598 of file cso_context.c.

References assert, cso_context::rasterizer, and cso_context::rasterizer_saved.

{
   assert(!ctx->rasterizer_saved);
   ctx->rasterizer_saved = ctx->rasterizer;
}

void cso_save_sampler_textures

(

struct cso_context *

cso

)

Definition at line 470 of file cso_context.c.

References assert, cso_context::nr_textures, cso_context::nr_textures_saved, pipe_texture_reference(), cso_context::textures, and cso_context::textures_saved.

{
   uint i;

   ctx->nr_textures_saved = ctx->nr_textures;
   for (i = 0; i < ctx->nr_textures; i++) {
      assert(!ctx->textures_saved[i]);
      pipe_texture_reference(&ctx->textures_saved[i], ctx->textures[i]);
   }
}

void cso_save_samplers

(

struct cso_context *

cso

)

Definition at line 438 of file cso_context.c.

References cso_context::nr_samplers, cso_context::nr_samplers_saved, cso_context::samplers, and cso_context::samplers_saved.

{
   ctx->nr_samplers_saved = ctx->nr_samplers;
   memcpy(ctx->samplers_saved, ctx->samplers, sizeof(ctx->samplers));
}

void cso_save_vertex_shader

(

struct cso_context *

cso

)

Definition at line 759 of file cso_context.c.

References assert, cso_context::vertex_shader, and cso_context::vertex_shader_saved.

{
   assert(!ctx->vertex_shader_saved);
   ctx->vertex_shader_saved = ctx->vertex_shader;
}

void cso_save_viewport

(

struct cso_context *

cso

)

Definition at line 841 of file cso_context.c.

References cso_context::vp_saved.

{
   ctx->vp_saved = ctx->vp;
}

enum pipe_error cso_set_blend	(	struct cso_context *	cso,
		const struct pipe_blend_state *	blend
	)

Definition at line 288 of file cso_context.c.

References pipe_context::bind_blend_state, cso_context::blend, cso_context::cache, cso_blend::context, pipe_context::create_blend_state, CSO_BLEND, cso_construct_key(), cso_find_state_template(), cso_hash_iter_data(), cso_hash_iter_is_null(), cso_insert_state(), cso_blend::data, pipe_context::delete_blend_state, cso_blend::delete_state, FREE, hash_key(), MALLOC, cso_context::pipe, PIPE_ERROR_OUT_OF_MEMORY, PIPE_OK, and cso_blend::state.

{
   unsigned hash_key = cso_construct_key((void*)templ, sizeof(struct pipe_blend_state));
   struct cso_hash_iter iter = cso_find_state_template(ctx->cache,
                                                       hash_key, CSO_BLEND,
                                                       (void*)templ);
   void *handle;

   if (cso_hash_iter_is_null(iter)) {
      struct cso_blend *cso = MALLOC(sizeof(struct cso_blend));
      if (!cso)
         return PIPE_ERROR_OUT_OF_MEMORY;

      memcpy(&cso->state, templ, sizeof(*templ));
      cso->data = ctx->pipe->create_blend_state(ctx->pipe, &cso->state);
      cso->delete_state = (cso_state_callback)ctx->pipe->delete_blend_state;
      cso->context = ctx->pipe;

      iter = cso_insert_state(ctx->cache, hash_key, CSO_BLEND, cso);
      if (cso_hash_iter_is_null(iter)) {
         FREE(cso);
         return PIPE_ERROR_OUT_OF_MEMORY;
      }

      handle = cso->data;
   }
   else {
      handle = ((struct cso_blend *)cso_hash_iter_data(iter))->data;
   }

   if (ctx->blend != handle) {
      ctx->blend = handle;
      ctx->pipe->bind_blend_state(ctx->pipe, handle);
   }
   return PIPE_OK;
}

enum pipe_error cso_set_blend_color	(	struct cso_context *	cso,
		const struct pipe_blend_color *	bc
	)

Definition at line 858 of file cso_context.c.

References cso_context::blend_color, cso_context::pipe, PIPE_OK, and pipe_context::set_blend_color.

{
   if (memcmp(&ctx->blend_color, bc, sizeof(ctx->blend_color))) {
      ctx->blend_color = *bc;
      ctx->pipe->set_blend_color(ctx->pipe, bc);
   }
   return PIPE_OK;
}

enum pipe_error cso_set_depth_stencil_alpha	(	struct cso_context *	cso,
		const struct pipe_depth_stencil_alpha_state *	dsa
	)

Definition at line 502 of file cso_context.c.

References pipe_context::bind_depth_stencil_alpha_state, cso_context::cache, cso_depth_stencil_alpha::context, pipe_context::create_depth_stencil_alpha_state, cso_construct_key(), CSO_DEPTH_STENCIL_ALPHA, cso_find_state_template(), cso_hash_iter_data(), cso_hash_iter_is_null(), cso_insert_state(), cso_depth_stencil_alpha::data, pipe_context::delete_depth_stencil_alpha_state, cso_depth_stencil_alpha::delete_state, cso_context::depth_stencil, FREE, hash_key(), MALLOC, cso_context::pipe, PIPE_ERROR_OUT_OF_MEMORY, PIPE_OK, and cso_depth_stencil_alpha::state.

{
   unsigned hash_key = cso_construct_key((void*)templ,
                                         sizeof(struct pipe_depth_stencil_alpha_state));
   struct cso_hash_iter iter = cso_find_state_template(ctx->cache,
                                                       hash_key, 
                                                       CSO_DEPTH_STENCIL_ALPHA,
                                                       (void*)templ);
   void *handle;

   if (cso_hash_iter_is_null(iter)) {
      struct cso_depth_stencil_alpha *cso = MALLOC(sizeof(struct cso_depth_stencil_alpha));
      if (!cso)
         return PIPE_ERROR_OUT_OF_MEMORY;

      memcpy(&cso->state, templ, sizeof(*templ));
      cso->data = ctx->pipe->create_depth_stencil_alpha_state(ctx->pipe, &cso->state);
      cso->delete_state = (cso_state_callback)ctx->pipe->delete_depth_stencil_alpha_state;
      cso->context = ctx->pipe;

      iter = cso_insert_state(ctx->cache, hash_key, CSO_DEPTH_STENCIL_ALPHA, cso);
      if (cso_hash_iter_is_null(iter)) {
         FREE(cso);
         return PIPE_ERROR_OUT_OF_MEMORY;
      }

      handle = cso->data;
   }
   else {
      handle = ((struct cso_depth_stencil_alpha *)cso_hash_iter_data(iter))->data;
   }

   if (ctx->depth_stencil != handle) {
      ctx->depth_stencil = handle;
      ctx->pipe->bind_depth_stencil_alpha_state(ctx->pipe, handle);
   }
   return PIPE_OK;
}

enum pipe_error cso_set_fragment_shader_handle	(	struct cso_context *	ctx,
		void *	handle
	)

Definition at line 615 of file cso_context.c.

References pipe_context::bind_fs_state, cso_context::fragment_shader, cso_context::pipe, and PIPE_OK.

{
   if (ctx->fragment_shader != handle) {
      ctx->fragment_shader = handle;
      ctx->pipe->bind_fs_state(ctx->pipe, handle);
   }
   return PIPE_OK;
}

enum pipe_error cso_set_framebuffer	(	struct cso_context *	cso,
		const struct pipe_framebuffer_state *	fb
	)

Definition at line 806 of file cso_context.c.

References copy_framebuffer_state(), cso_context::pipe, PIPE_OK, and pipe_context::set_framebuffer_state.

{
   if (memcmp(&ctx->fb, fb, sizeof(*fb)) != 0) {
      copy_framebuffer_state(&ctx->fb, fb);
      ctx->pipe->set_framebuffer_state(ctx->pipe, fb);
   }
   return PIPE_OK;
}

enum pipe_error cso_set_rasterizer	(	struct cso_context *	cso,
		const struct pipe_rasterizer_state *	rasterizer
	)

Definition at line 559 of file cso_context.c.

References pipe_context::bind_rasterizer_state, cso_context::cache, cso_rasterizer::context, pipe_context::create_rasterizer_state, cso_construct_key(), cso_find_state_template(), cso_hash_iter_data(), cso_hash_iter_is_null(), cso_insert_state(), CSO_RASTERIZER, cso_rasterizer::data, pipe_context::delete_rasterizer_state, cso_rasterizer::delete_state, FREE, hash_key(), MALLOC, cso_context::pipe, PIPE_ERROR_OUT_OF_MEMORY, PIPE_OK, cso_context::rasterizer, and cso_rasterizer::state.

{
   unsigned hash_key = cso_construct_key((void*)templ,
                                         sizeof(struct pipe_rasterizer_state));
   struct cso_hash_iter iter = cso_find_state_template(ctx->cache,
                                                       hash_key, CSO_RASTERIZER,
                                                       (void*)templ);
   void *handle = NULL;

   if (cso_hash_iter_is_null(iter)) {
      struct cso_rasterizer *cso = MALLOC(sizeof(struct cso_rasterizer));
      if (!cso)
         return PIPE_ERROR_OUT_OF_MEMORY;

      memcpy(&cso->state, templ, sizeof(*templ));
      cso->data = ctx->pipe->create_rasterizer_state(ctx->pipe, &cso->state);
      cso->delete_state = (cso_state_callback)ctx->pipe->delete_rasterizer_state;
      cso->context = ctx->pipe;

      iter = cso_insert_state(ctx->cache, hash_key, CSO_RASTERIZER, cso);
      if (cso_hash_iter_is_null(iter)) {
         FREE(cso);
         return PIPE_ERROR_OUT_OF_MEMORY;
      }

      handle = cso->data;
   }
   else {
      handle = ((struct cso_rasterizer *)cso_hash_iter_data(iter))->data;
   }

   if (ctx->rasterizer != handle) {
      ctx->rasterizer = handle;
      ctx->pipe->bind_rasterizer_state(ctx->pipe, handle);
   }
   return PIPE_OK;
}

enum pipe_error cso_set_sampler_textures	(	struct cso_context *	cso,
		uint	count,
		struct pipe_texture **	textures
	)

Definition at line 452 of file cso_context.c.

References cso_context::nr_textures, cso_context::pipe, PIPE_MAX_SAMPLERS, PIPE_OK, pipe_texture_reference(), pipe_context::set_sampler_textures, and cso_context::textures.

{
   uint i;

   ctx->nr_textures = count;

   for (i = 0; i < count; i++)
      pipe_texture_reference(&ctx->textures[i], textures[i]);
   for ( ; i < PIPE_MAX_SAMPLERS; i++)
      pipe_texture_reference(&ctx->textures[i], NULL);

   ctx->pipe->set_sampler_textures(ctx->pipe, count, textures);

   return PIPE_OK;
}

enum pipe_error cso_set_samplers	(	struct cso_context *	cso,
		unsigned	count,
		const struct pipe_sampler_state **	states
	)

Definition at line 411 of file cso_context.c.

References cso_single_sampler(), cso_single_sampler_done(), cso_context::nr_samplers, and PIPE_OK.

{
   unsigned i;
   enum pipe_error temp, error = PIPE_OK;

   /* TODO: fastpath
    */

   for (i = 0; i < nr; i++) {
      temp = cso_single_sampler( ctx, i, templates[i] );
      if (temp != PIPE_OK)
         error = temp;
   }

   for ( ; i < ctx->nr_samplers; i++) {
      temp = cso_single_sampler( ctx, i, NULL );
      if (temp != PIPE_OK)
         error = temp;
   }

   cso_single_sampler_done( ctx );

   return error;
}

enum pipe_error cso_set_vertex_shader_handle	(	struct cso_context *	ctx,
		void *	handle
	)

Definition at line 696 of file cso_context.c.

References pipe_context::bind_vs_state, cso_context::pipe, PIPE_OK, and cso_context::vertex_shader.

{
   if (ctx->vertex_shader != handle) {
      ctx->vertex_shader = handle;
      ctx->pipe->bind_vs_state(ctx->pipe, handle);
   }
   return PIPE_OK;
}

enum pipe_error cso_set_viewport	(	struct cso_context *	cso,
		const struct pipe_viewport_state *	vp
	)

Definition at line 831 of file cso_context.c.

References cso_context::pipe, PIPE_OK, and pipe_context::set_viewport_state.

{
   if (memcmp(&ctx->vp, vp, sizeof(*vp))) {
      ctx->vp = *vp;
      ctx->pipe->set_viewport_state(ctx->pipe, vp);
   }
   return PIPE_OK;
}

enum pipe_error cso_single_sampler	(	struct cso_context *	cso,
		unsigned	nr,
		const struct pipe_sampler_state *	states
	)

Definition at line 343 of file cso_context.c.

References cso_context::cache, cso_sampler::context, pipe_context::create_sampler_state, cso_construct_key(), cso_find_state_template(), cso_hash_iter_data(), cso_hash_iter_is_null(), cso_insert_state(), CSO_SAMPLER, cso_sampler::data, pipe_context::delete_sampler_state, cso_sampler::delete_state, FREE, hash_key(), MALLOC, cso_context::pipe, PIPE_ERROR_OUT_OF_MEMORY, PIPE_OK, cso_context::samplers, and cso_sampler::state.

{
   void *handle = NULL;

   if (templ != NULL) {
      unsigned hash_key = cso_construct_key((void*)templ, sizeof(struct pipe_sampler_state));
      struct cso_hash_iter iter = cso_find_state_template(ctx->cache,
                                                          hash_key, CSO_SAMPLER,
                                                          (void*)templ);

      if (cso_hash_iter_is_null(iter)) {
         struct cso_sampler *cso = MALLOC(sizeof(struct cso_sampler));
         if (!cso)
            return PIPE_ERROR_OUT_OF_MEMORY;

         memcpy(&cso->state, templ, sizeof(*templ));
         cso->data = ctx->pipe->create_sampler_state(ctx->pipe, &cso->state);
         cso->delete_state = (cso_state_callback)ctx->pipe->delete_sampler_state;
         cso->context = ctx->pipe;

         iter = cso_insert_state(ctx->cache, hash_key, CSO_SAMPLER, cso);
         if (cso_hash_iter_is_null(iter)) {
            FREE(cso);
            return PIPE_ERROR_OUT_OF_MEMORY;
         }

         handle = cso->data;
      }
      else {
         handle = ((struct cso_sampler *)cso_hash_iter_data(iter))->data;
      }
   }

   ctx->samplers[idx] = handle;
   return PIPE_OK;
}

void cso_single_sampler_done

(

struct cso_context *

cso

)

Definition at line 382 of file cso_context.c.

References pipe_context::bind_sampler_states, cso_context::hw, cso_context::nr_samplers, cso_context::pipe, PIPE_MAX_SAMPLERS, and cso_context::samplers.

{
   unsigned i;

   /* find highest non-null sampler */
   for (i = PIPE_MAX_SAMPLERS; i > 0; i--) {
      if (ctx->samplers[i - 1] != NULL)
         break;
   }

   ctx->nr_samplers = i;

   if (ctx->hw.nr_samplers != ctx->nr_samplers ||
       memcmp(ctx->hw.samplers,
              ctx->samplers,
              ctx->nr_samplers * sizeof(void *)) != 0) 
   {
      memcpy(ctx->hw.samplers, ctx->samplers, ctx->nr_samplers * sizeof(void *));
      ctx->hw.nr_samplers = ctx->nr_samplers;

      ctx->pipe->bind_sampler_states(ctx->pipe, ctx->nr_samplers, ctx->samplers);
   }
}

---