src/gallium/auxiliary/driver_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_launch_grid(struct pipe_context *ctx,
  38                              const struct pipe_grid_info *info)
  39 {
  40 }
  41
  42 static void noop_set_blend_color(struct pipe_context *ctx,
  43                                  const struct pipe_blend_color *state)
  44 {
  45 }
  46
  47 static void *noop_create_blend_state(struct pipe_context *ctx,
  48                                      const struct pipe_blend_state *state)
  49 {
  50    return MALLOC(1);
  51 }
  52
  53 static void *noop_create_dsa_state(struct pipe_context *ctx,
  54                                    const struct pipe_depth_stencil_alpha_state *state)
  55 {
  56    return MALLOC(1);
  57 }
  58
  59 static void *noop_create_rs_state(struct pipe_context *ctx,
  60                                   const struct pipe_rasterizer_state *state)
  61 {
  62    return MALLOC(1);
  63 }
  64
  65 static void *noop_create_sampler_state(struct pipe_context *ctx,
  66                                        const struct pipe_sampler_state *state)
  67 {
  68    return MALLOC(1);
  69 }
  70
  71 static struct pipe_sampler_view *noop_create_sampler_view(struct pipe_context *ctx,
  72                                                           struct pipe_resource *texture,
  73                                                           const struct pipe_sampler_view *state)
  74 {
  75    struct pipe_sampler_view *sampler_view = CALLOC_STRUCT(pipe_sampler_view);
  76
  77    if (!sampler_view)
  78       return NULL;
  79
  80    /* initialize base object */
  81    *sampler_view = *state;
  82    sampler_view->texture = NULL;
  83    pipe_resource_reference(&sampler_view->texture, texture);
  84    pipe_reference_init(&sampler_view->reference, 1);
  85    sampler_view->context = ctx;
  86    return sampler_view;
  87 }
  88
  89 static struct pipe_surface *noop_create_surface(struct pipe_context *ctx,
  90                                                 struct pipe_resource *texture,
  91                                                 const struct pipe_surface *surf_tmpl)
  92 {
  93    struct pipe_surface *surface = CALLOC_STRUCT(pipe_surface);
  94
  95    if (!surface)
  96       return NULL;
  97    pipe_reference_init(&surface->reference, 1);
  98    pipe_resource_reference(&surface->texture, texture);
  99    surface->context = ctx;
 100    surface->format = surf_tmpl->format;
 101    surface->width = texture->width0;
 102    surface->height = texture->height0;
 103    surface->texture = texture;
 104    surface->u.tex.first_layer = surf_tmpl->u.tex.first_layer;
 105    surface->u.tex.last_layer = surf_tmpl->u.tex.last_layer;
 106    surface->u.tex.level = surf_tmpl->u.tex.level;
 107
 108    return surface;
 109 }
 110
 111 static void noop_set_sampler_views(struct pipe_context *ctx,
 112                                    enum pipe_shader_type shader,
 113                                    unsigned start, unsigned count,
 114                                    struct pipe_sampler_view **views)
 115 {
 116 }
 117
 118 static void noop_bind_sampler_states(struct pipe_context *ctx,
 119                                      enum pipe_shader_type shader,
 120                                      unsigned start, unsigned count,
 121                                      void **states)
 122 {
 123 }
 124
 125 static void noop_set_clip_state(struct pipe_context *ctx,
 126                                 const struct pipe_clip_state *state)
 127 {
 128 }
 129
 130 static void noop_set_polygon_stipple(struct pipe_context *ctx,
 131                                      const struct pipe_poly_stipple *state)
 132 {
 133 }
 134
 135 static void noop_set_sample_mask(struct pipe_context *pipe, unsigned sample_mask)
 136 {
 137 }
 138
 139 static void noop_set_scissor_states(struct pipe_context *ctx,
 140                                     unsigned start_slot,
 141                                     unsigned num_scissors,
 142                                     const struct pipe_scissor_state *state)
 143 {
 144 }
 145
 146 static void noop_set_stencil_ref(struct pipe_context *ctx,
 147                                  const struct pipe_stencil_ref *state)
 148 {
 149 }
 150
 151 static void noop_set_viewport_states(struct pipe_context *ctx,
 152                                      unsigned start_slot,
 153                                      unsigned num_viewports,
 154                                      const struct pipe_viewport_state *state)
 155 {
 156 }
 157
 158 static void noop_set_framebuffer_state(struct pipe_context *ctx,
 159                                        const struct pipe_framebuffer_state *state)
 160 {
 161 }
 162
 163 static void noop_set_constant_buffer(struct pipe_context *ctx,
 164                                      enum pipe_shader_type shader, uint index,
 165                                      const struct pipe_constant_buffer *cb)
 166 {
 167 }
 168
 169
 170 static void noop_sampler_view_destroy(struct pipe_context *ctx,
 171                                       struct pipe_sampler_view *state)
 172 {
 173    pipe_resource_reference(&state->texture, NULL);
 174    FREE(state);
 175 }
 176
 177
 178 static void noop_surface_destroy(struct pipe_context *ctx,
 179                                  struct pipe_surface *surface)
 180 {
 181    pipe_resource_reference(&surface->texture, NULL);
 182    FREE(surface);
 183 }
 184
 185 static void noop_bind_state(struct pipe_context *ctx, void *state)
 186 {
 187 }
 188
 189 static void noop_delete_state(struct pipe_context *ctx, void *state)
 190 {
 191    FREE(state);
 192 }
 193
 194 static void noop_set_vertex_buffers(struct pipe_context *ctx,
 195                                     unsigned start_slot, unsigned count,
 196                                     const struct pipe_vertex_buffer *buffers)
 197 {
 198 }
 199
 200 static void *noop_create_vertex_elements(struct pipe_context *ctx,
 201                                          unsigned count,
 202                                          const struct pipe_vertex_element *state)
 203 {
 204    return MALLOC(1);
 205 }
 206
 207 static void *noop_create_shader_state(struct pipe_context *ctx,
 208                                       const struct pipe_shader_state *state)
 209 {
 210    return MALLOC(1);
 211 }
 212
 213 static void *noop_create_compute_state(struct pipe_context *ctx,
 214                                        const struct pipe_compute_state *state)
 215 {
 216    return MALLOC(1);
 217 }
 218
 219 static struct pipe_stream_output_target *noop_create_stream_output_target(
 220       struct pipe_context *ctx,
 221       struct pipe_resource *res,
 222       unsigned buffer_offset,
 223       unsigned buffer_size)
 224 {
 225    struct pipe_stream_output_target *t = CALLOC_STRUCT(pipe_stream_output_target);
 226    if (!t)
 227       return NULL;
 228
 229    pipe_reference_init(&t->reference, 1);
 230    pipe_resource_reference(&t->buffer, res);
 231    t->buffer_offset = buffer_offset;
 232    t->buffer_size = buffer_size;
 233    return t;
 234 }
 235
 236 static void noop_stream_output_target_destroy(struct pipe_context *ctx,
 237                                               struct pipe_stream_output_target *t)
 238 {
 239    pipe_resource_reference(&t->buffer, NULL);
 240    FREE(t);
 241 }
 242
 243 static void noop_set_stream_output_targets(struct pipe_context *ctx,
 244                                            unsigned num_targets,
 245                                            struct pipe_stream_output_target **targets,
 246                                            const unsigned *offsets)
 247 {
 248 }
 249
 250 static void noop_set_window_rectangles(struct pipe_context *ctx,
 251                                        bool include,
 252                                        unsigned num_rectangles,
 253                                        const struct pipe_scissor_state *rects)
 254 {
 255 }
 256
 257 void noop_init_state_functions(struct pipe_context *ctx);
 258
 259 void noop_init_state_functions(struct pipe_context *ctx)
 260 {
 261    ctx->create_blend_state = noop_create_blend_state;
 262    ctx->create_depth_stencil_alpha_state = noop_create_dsa_state;
 263    ctx->create_fs_state = noop_create_shader_state;
 264    ctx->create_rasterizer_state = noop_create_rs_state;
 265    ctx->create_sampler_state = noop_create_sampler_state;
 266    ctx->create_sampler_view = noop_create_sampler_view;
 267    ctx->create_surface = noop_create_surface;
 268    ctx->create_vertex_elements_state = noop_create_vertex_elements;
 269    ctx->create_compute_state = noop_create_compute_state;
 270    ctx->create_tcs_state = noop_create_shader_state;
 271    ctx->create_tes_state = noop_create_shader_state;
 272    ctx->create_gs_state = noop_create_shader_state;
 273    ctx->create_vs_state = noop_create_shader_state;
 274    ctx->bind_blend_state = noop_bind_state;
 275    ctx->bind_depth_stencil_alpha_state = noop_bind_state;
 276    ctx->bind_sampler_states = noop_bind_sampler_states;
 277    ctx->bind_fs_state = noop_bind_state;
 278    ctx->bind_rasterizer_state = noop_bind_state;
 279    ctx->bind_vertex_elements_state = noop_bind_state;
 280    ctx->bind_compute_state = noop_bind_state;
 281    ctx->bind_tcs_state = noop_bind_state;
 282    ctx->bind_tes_state = noop_bind_state;
 283    ctx->bind_gs_state = noop_bind_state;
 284    ctx->bind_vs_state = noop_bind_state;
 285    ctx->delete_blend_state = noop_delete_state;
 286    ctx->delete_depth_stencil_alpha_state = noop_delete_state;
 287    ctx->delete_fs_state = noop_delete_state;
 288    ctx->delete_rasterizer_state = noop_delete_state;
 289    ctx->delete_sampler_state = noop_delete_state;
 290    ctx->delete_vertex_elements_state = noop_delete_state;
 291    ctx->delete_compute_state = noop_delete_state;
 292    ctx->delete_tcs_state = noop_delete_state;
 293    ctx->delete_tes_state = noop_delete_state;
 294    ctx->delete_gs_state = noop_delete_state;
 295    ctx->delete_vs_state = noop_delete_state;
 296    ctx->set_blend_color = noop_set_blend_color;
 297    ctx->set_clip_state = noop_set_clip_state;
 298    ctx->set_constant_buffer = noop_set_constant_buffer;
 299    ctx->set_sampler_views = noop_set_sampler_views;
 300    ctx->set_framebuffer_state = noop_set_framebuffer_state;
 301    ctx->set_polygon_stipple = noop_set_polygon_stipple;
 302    ctx->set_sample_mask = noop_set_sample_mask;
 303    ctx->set_scissor_states = noop_set_scissor_states;
 304    ctx->set_stencil_ref = noop_set_stencil_ref;
 305    ctx->set_vertex_buffers = noop_set_vertex_buffers;
 306    ctx->set_viewport_states = noop_set_viewport_states;
 307    ctx->set_window_rectangles = noop_set_window_rectangles;
 308    ctx->sampler_view_destroy = noop_sampler_view_destroy;
 309    ctx->surface_destroy = noop_surface_destroy;
 310    ctx->draw_vbo = noop_draw_vbo;
 311    ctx->launch_grid = noop_launch_grid;
 312    ctx->create_stream_output_target = noop_create_stream_output_target;
 313    ctx->stream_output_target_destroy = noop_stream_output_target_destroy;
 314    ctx->set_stream_output_targets = noop_set_stream_output_targets;
 315 }