src/gallium/drivers/noop/noop_state.c

   1 /*
   2  * Copyright 2010 Red Hat Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  */
  23 #include <stdio.h>
  24 #include <errno.h>
  25 #include "pipe/p_defines.h"
  26 #include "pipe/p_state.h"
  27 #include "pipe/p_context.h"
  28 #include "pipe/p_screen.h"
  29 #include "util/u_memory.h"
  30 #include "util/u_inlines.h"
  31 #include "util/u_transfer.h"
  32
  33 static void noop_draw_vbo(struct pipe_context *ctx, const struct pipe_draw_info *info)
  34 {
  35 }
  36
  37 static void noop_set_blend_color(struct pipe_context *ctx,
  38                                         const struct pipe_blend_color *state)
  39 {
  40 }
  41
  42 static void *noop_create_blend_state(struct pipe_context *ctx,
  43                                         const struct pipe_blend_state *state)
  44 {
  45         struct pipe_blend_state *nstate = CALLOC_STRUCT(pipe_blend_state);
  46
  47         if (nstate == NULL) {
  48                 return NULL;
  49         }
  50         *nstate = *state;
  51         return nstate;
  52 }
  53
  54 static void *noop_create_dsa_state(struct pipe_context *ctx,
  55                                    const struct pipe_depth_stencil_alpha_state *state)
  56 {
  57         struct pipe_depth_stencil_alpha_state *nstate = CALLOC_STRUCT(pipe_depth_stencil_alpha_state);
  58
  59         if (nstate == NULL) {
  60                 return NULL;
  61         }
  62         *nstate = *state;
  63         return nstate;
  64 }
  65
  66 static void *noop_create_rs_state(struct pipe_context *ctx,
  67                                         const struct pipe_rasterizer_state *state)
  68 {
  69         struct pipe_rasterizer_state *nstate = CALLOC_STRUCT(pipe_rasterizer_state);
  70
  71         if (nstate == NULL) {
  72                 return NULL;
  73         }
  74         *nstate = *state;
  75         return nstate;
  76 }
  77
  78 static void *noop_create_sampler_state(struct pipe_context *ctx,
  79                                         const struct pipe_sampler_state *state)
  80 {
  81         struct pipe_sampler_state *nstate = CALLOC_STRUCT(pipe_sampler_state);
  82
  83         if (nstate == NULL) {
  84                 return NULL;
  85         }
  86         *nstate = *state;
  87         return nstate;
  88 }
  89
  90 static struct pipe_sampler_view *noop_create_sampler_view(struct pipe_context *ctx,
  91                                                         struct pipe_resource *texture,
  92                                                         const struct pipe_sampler_view *state)
  93 {
  94         struct pipe_sampler_view *sampler_view = CALLOC_STRUCT(pipe_sampler_view);
  95
  96         if (sampler_view == NULL)
  97                 return NULL;
  98         /* initialize base object */
  99         pipe_resource_reference(&sampler_view->texture, texture);
 100         pipe_reference_init(&sampler_view->reference, 1);
 101         sampler_view->context = ctx;
 102         return sampler_view;
 103 }
 104
 105 static struct pipe_surface *noop_create_surface(struct pipe_context *ctx,
 106                                                 struct pipe_resource *texture,
 107                                                 const struct pipe_surface *surf_tmpl)
 108 {
 109         struct pipe_surface *surface = CALLOC_STRUCT(pipe_surface);
 110
 111         if (surface == NULL)
 112                 return NULL;
 113         pipe_reference_init(&surface->reference, 1);
 114         pipe_resource_reference(&surface->texture, texture);
 115         surface->context = ctx;
 116         surface->format = surf_tmpl->format;
 117         surface->width = texture->width0;
 118         surface->height = texture->height0;
 119         surface->texture = texture;
 120         surface->u.tex.first_layer = surf_tmpl->u.tex.first_layer;
 121         surface->u.tex.last_layer = surf_tmpl->u.tex.last_layer;
 122         surface->u.tex.level = surf_tmpl->u.tex.level;
 123
 124         return surface;
 125 }
 126
 127 static void noop_set_vs_sampler_view(struct pipe_context *ctx, unsigned count,
 128                                         struct pipe_sampler_view **views)
 129 {
 130 }
 131
 132 static void noop_set_ps_sampler_view(struct pipe_context *ctx, unsigned count,
 133                                         struct pipe_sampler_view **views)
 134 {
 135 }
 136
 137 static void noop_bind_sampler_states(struct pipe_context *ctx, unsigned shader,
 138                                      unsigned start, unsigned count,
 139                                      void **states)
 140 {
 141 }
 142
 143 static void noop_set_clip_state(struct pipe_context *ctx,
 144                                 const struct pipe_clip_state *state)
 145 {
 146 }
 147
 148 static void noop_set_polygon_stipple(struct pipe_context *ctx,
 149                                          const struct pipe_poly_stipple *state)
 150 {
 151 }
 152
 153 static void noop_set_sample_mask(struct pipe_context *pipe, unsigned sample_mask)
 154 {
 155 }
 156
 157 static void noop_set_scissor_states(struct pipe_context *ctx,
 158                                     unsigned start_slot,
 159                                     unsigned num_scissors,
 160                                     const struct pipe_scissor_state *state)
 161 {
 162 }
 163
 164 static void noop_set_stencil_ref(struct pipe_context *ctx,
 165                                 const struct pipe_stencil_ref *state)
 166 {
 167 }
 168
 169 static void noop_set_viewport_states(struct pipe_context *ctx,
 170                                      unsigned start_slot,
 171                                      unsigned num_viewports,
 172                                      const struct pipe_viewport_state *state)
 173 {
 174 }
 175
 176 static void noop_set_framebuffer_state(struct pipe_context *ctx,
 177                                         const struct pipe_framebuffer_state *state)
 178 {
 179 }
 180
 181 static void noop_set_constant_buffer(struct pipe_context *ctx,
 182                                         uint shader, uint index,
 183                                         struct pipe_constant_buffer *cb)
 184 {
 185 }
 186
 187
 188 static void noop_sampler_view_destroy(struct pipe_context *ctx,
 189                                 struct pipe_sampler_view *state)
 190 {
 191         pipe_resource_reference(&state->texture, NULL);
 192         FREE(state);
 193 }
 194
 195
 196 static void noop_surface_destroy(struct pipe_context *ctx,
 197                                  struct pipe_surface *surface)
 198 {
 199         pipe_resource_reference(&surface->texture, NULL);
 200         FREE(surface);
 201 }
 202
 203 static void noop_bind_state(struct pipe_context *ctx, void *state)
 204 {
 205 }
 206
 207 static void noop_delete_state(struct pipe_context *ctx, void *state)
 208 {
 209         FREE(state);
 210 }
 211
 212 static void noop_delete_vertex_element(struct pipe_context *ctx, void *state)
 213 {
 214         FREE(state);
 215 }
 216
 217
 218 static void noop_set_index_buffer(struct pipe_context *ctx,
 219                                         const struct pipe_index_buffer *ib)
 220 {
 221 }
 222
 223 static void noop_set_vertex_buffers(struct pipe_context *ctx,
 224                                     unsigned start_slot, unsigned count,
 225                                     const struct pipe_vertex_buffer *buffers)
 226 {
 227 }
 228
 229 static void *noop_create_vertex_elements(struct pipe_context *ctx,
 230                                         unsigned count,
 231                                         const struct pipe_vertex_element *state)
 232 {
 233         struct pipe_vertex_element *nstate = CALLOC_STRUCT(pipe_vertex_element);
 234
 235         if (nstate == NULL) {
 236                 return NULL;
 237         }
 238         *nstate = *state;
 239         return nstate;
 240 }
 241
 242 static void *noop_create_shader_state(struct pipe_context *ctx,
 243                                         const struct pipe_shader_state *state)
 244 {
 245         struct pipe_shader_state *nstate = CALLOC_STRUCT(pipe_shader_state);
 246
 247         if (nstate == NULL) {
 248                 return NULL;
 249         }
 250         *nstate = *state;
 251         return nstate;
 252 }
 253
 254 static struct pipe_stream_output_target *noop_create_stream_output_target(
 255       struct pipe_context *ctx,
 256       struct pipe_resource *res,
 257       unsigned buffer_offset,
 258       unsigned buffer_size)
 259 {
 260    struct pipe_stream_output_target *t = CALLOC_STRUCT(pipe_stream_output_target);
 261    if (!t)
 262       return NULL;
 263
 264    pipe_reference_init(&t->reference, 1);
 265    pipe_resource_reference(&t->buffer, res);
 266    t->buffer_offset = buffer_offset;
 267    t->buffer_size = buffer_size;
 268    return t;
 269 }
 270
 271 static void noop_stream_output_target_destroy(struct pipe_context *ctx,
 272                                       struct pipe_stream_output_target *t)
 273 {
 274    pipe_resource_reference(&t->buffer, NULL);
 275    FREE(t);
 276 }
 277
 278 static void noop_set_stream_output_targets(struct pipe_context *ctx,
 279                            unsigned num_targets,
 280                            struct pipe_stream_output_target **targets,
 281                            unsigned append_bitmask)
 282 {
 283 }
 284
 285 void noop_init_state_functions(struct pipe_context *ctx);
 286
 287 void noop_init_state_functions(struct pipe_context *ctx)
 288 {
 289         ctx->create_blend_state = noop_create_blend_state;
 290         ctx->create_depth_stencil_alpha_state = noop_create_dsa_state;
 291         ctx->create_fs_state = noop_create_shader_state;
 292         ctx->create_rasterizer_state = noop_create_rs_state;
 293         ctx->create_sampler_state = noop_create_sampler_state;
 294         ctx->create_sampler_view = noop_create_sampler_view;
 295         ctx->create_surface = noop_create_surface;
 296         ctx->create_vertex_elements_state = noop_create_vertex_elements;
 297         ctx->create_vs_state = noop_create_shader_state;
 298         ctx->bind_blend_state = noop_bind_state;
 299         ctx->bind_depth_stencil_alpha_state = noop_bind_state;
 300         ctx->bind_sampler_states = noop_bind_sampler_states;
 301         ctx->bind_fs_state = noop_bind_state;
 302         ctx->bind_rasterizer_state = noop_bind_state;
 303         ctx->bind_vertex_elements_state = noop_bind_state;
 304         ctx->bind_vs_state = noop_bind_state;
 305         ctx->delete_blend_state = noop_delete_state;
 306         ctx->delete_depth_stencil_alpha_state = noop_delete_state;
 307         ctx->delete_fs_state = noop_delete_state;
 308         ctx->delete_rasterizer_state = noop_delete_state;
 309         ctx->delete_sampler_state = noop_delete_state;
 310         ctx->delete_vertex_elements_state = noop_delete_vertex_element;
 311         ctx->delete_vs_state = noop_delete_state;
 312         ctx->set_blend_color = noop_set_blend_color;
 313         ctx->set_clip_state = noop_set_clip_state;
 314         ctx->set_constant_buffer = noop_set_constant_buffer;
 315         ctx->set_fragment_sampler_views = noop_set_ps_sampler_view;
 316         ctx->set_framebuffer_state = noop_set_framebuffer_state;
 317         ctx->set_polygon_stipple = noop_set_polygon_stipple;
 318         ctx->set_sample_mask = noop_set_sample_mask;
 319         ctx->set_scissor_states = noop_set_scissor_states;
 320         ctx->set_stencil_ref = noop_set_stencil_ref;
 321         ctx->set_vertex_buffers = noop_set_vertex_buffers;
 322         ctx->set_index_buffer = noop_set_index_buffer;
 323         ctx->set_vertex_sampler_views = noop_set_vs_sampler_view;
 324         ctx->set_viewport_states = noop_set_viewport_states;
 325         ctx->sampler_view_destroy = noop_sampler_view_destroy;
 326         ctx->surface_destroy = noop_surface_destroy;
 327         ctx->draw_vbo = noop_draw_vbo;
 328         ctx->create_stream_output_target = noop_create_stream_output_target;
 329         ctx->stream_output_target_destroy = noop_stream_output_target_destroy;
 330         ctx->set_stream_output_targets = noop_set_stream_output_targets;
 331 }