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
33static void noop_draw_vbo(struct pipe_context *ctx, const struct pipe_draw_info *info)
34{
35}
36
37static void noop_launch_grid(struct pipe_context *ctx,
38                             const struct pipe_grid_info *info)
39{
40}
41
42static void noop_set_blend_color(struct pipe_context *ctx,
43                                 const struct pipe_blend_color *state)
44{
45}
46
47static void *noop_create_blend_state(struct pipe_context *ctx,
48                                     const struct pipe_blend_state *state)
49{
50   return MALLOC(1);
51}
52
53static 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
59static void *noop_create_rs_state(struct pipe_context *ctx,
60                                  const struct pipe_rasterizer_state *state)
61{
62   return MALLOC(1);
63}
64
65static void *noop_create_sampler_state(struct pipe_context *ctx,
66                                       const struct pipe_sampler_state *state)
67{
68   return MALLOC(1);
69}
70
71static 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
89static 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
111static 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
118static 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
125static void noop_set_clip_state(struct pipe_context *ctx,
126                                const struct pipe_clip_state *state)
127{
128}
129
130static void noop_set_polygon_stipple(struct pipe_context *ctx,
131                                     const struct pipe_poly_stipple *state)
132{
133}
134
135static void noop_set_sample_mask(struct pipe_context *pipe, unsigned sample_mask)
136{
137}
138
139static 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
146static void noop_set_stencil_ref(struct pipe_context *ctx,
147                                 const struct pipe_stencil_ref *state)
148{
149}
150
151static 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
158static void noop_set_framebuffer_state(struct pipe_context *ctx,
159                                       const struct pipe_framebuffer_state *state)
160{
161}
162
163static 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
170static 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
178static 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
185static void noop_bind_state(struct pipe_context *ctx, void *state)
186{
187}
188
189static void noop_delete_state(struct pipe_context *ctx, void *state)
190{
191   FREE(state);
192}
193
194static 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
200static 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
207static void *noop_create_shader_state(struct pipe_context *ctx,
208                                      const struct pipe_shader_state *state)
209{
210   return MALLOC(1);
211}
212
213static void *noop_create_compute_state(struct pipe_context *ctx,
214                                       const struct pipe_compute_state *state)
215{
216   return MALLOC(1);
217}
218
219static 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
236static 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
243static 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
250static void noop_set_window_rectangles(struct pipe_context *ctx,
251                                       boolean include,
252                                       unsigned num_rectangles,
253                                       const struct pipe_scissor_state *rects)
254{
255}
256
257void noop_init_state_functions(struct pipe_context *ctx);
258
259void 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}
316