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