src/gallium/drivers/r600/r600_state.c

   1 /*
   2  * Copyright 2010 Jerome Glisse <glisse@freedesktop.org>
   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  * Authors:
  24  *      Jerome Glisse
  25  */
  26 #include <stdio.h>
  27 #include <util/u_inlines.h>
  28 #include <util/u_format.h>
  29 #include <util/u_memory.h>
  30 #include "r600_screen.h"
  31 #include "r600_texture.h"
  32 #include "r600_context.h"
  33 #include "r600d.h"
  34
  35
  36 static void r600_delete_state(struct pipe_context *ctx, void *state)
  37 {
  38         struct radeon_state *rstate = state;
  39
  40         radeon_state_decref(rstate);
  41 }
  42
  43 static void *r600_create_blend_state(struct pipe_context *ctx,
  44                                         const struct pipe_blend_state *state)
  45 {
  46         struct r600_screen *rscreen = (struct r600_screen*)ctx->screen;
  47         struct radeon_state *rstate;
  48
  49         rstate = radeon_state(rscreen->rw, R600_BLEND_TYPE, R600_BLEND);
  50         if (rstate == NULL)
  51                 return NULL;
  52         rstate->states[R600_BLEND__CB_BLEND_RED] = 0x00000000;
  53         rstate->states[R600_BLEND__CB_BLEND_GREEN] = 0x00000000;
  54         rstate->states[R600_BLEND__CB_BLEND_BLUE] = 0x00000000;
  55         rstate->states[R600_BLEND__CB_BLEND_ALPHA] = 0x00000000;
  56         rstate->states[R600_BLEND__CB_BLEND0_CONTROL] = 0x00010001;
  57         rstate->states[R600_BLEND__CB_BLEND1_CONTROL] = 0x00000000;
  58         rstate->states[R600_BLEND__CB_BLEND2_CONTROL] = 0x00000000;
  59         rstate->states[R600_BLEND__CB_BLEND3_CONTROL] = 0x00000000;
  60         rstate->states[R600_BLEND__CB_BLEND4_CONTROL] = 0x00000000;
  61         rstate->states[R600_BLEND__CB_BLEND5_CONTROL] = 0x00000000;
  62         rstate->states[R600_BLEND__CB_BLEND6_CONTROL] = 0x00000000;
  63         rstate->states[R600_BLEND__CB_BLEND7_CONTROL] = 0x00000000;
  64         rstate->states[R600_BLEND__CB_BLEND_CONTROL] = 0x00000000;
  65         if (radeon_state_pm4(rstate)) {
  66                 radeon_state_decref(rstate);
  67                 return NULL;
  68         }
  69         return rstate;
  70 }
  71
  72 static void r600_bind_blend_state(struct pipe_context *ctx, void *state)
  73 {
  74         struct r600_context *rctx = (struct r600_context*)ctx;
  75         radeon_draw_set(rctx->draw, state);
  76 }
  77
  78 static void r600_set_blend_color(struct pipe_context *ctx,
  79                                         const struct pipe_blend_color *color)
  80 {
  81 }
  82
  83 static void r600_set_clip_state(struct pipe_context *ctx,
  84                                 const struct pipe_clip_state *state)
  85 {
  86 }
  87
  88 static void r600_set_framebuffer_state(struct pipe_context *ctx,
  89                                         const struct pipe_framebuffer_state *state)
  90 {
  91         struct r600_screen *rscreen = (struct r600_screen*)ctx->screen;
  92         struct r600_context *rctx = (struct r600_context*)ctx;
  93         struct r600_texture *rtex;
  94         struct r600_buffer *rbuffer;
  95         struct radeon_state *rstate;
  96         unsigned level = state->cbufs[0]->level;
  97         unsigned pitch, slice;
  98
  99         rstate = radeon_state(rscreen->rw, R600_CB0_TYPE, R600_CB0);
 100         if (rstate == NULL)
 101                 return;
 102         rtex = (struct r600_texture*)state->cbufs[0]->texture;
 103         rbuffer = (struct r600_buffer*)rtex->buffer;
 104         rstate->bo[0] = radeon_bo_incref(rscreen->rw, rbuffer->bo);
 105         rstate->bo[1] = radeon_bo_incref(rscreen->rw, rbuffer->bo);
 106         rstate->bo[2] = radeon_bo_incref(rscreen->rw, rbuffer->bo);
 107         rstate->placement[0] = RADEON_GEM_DOMAIN_GTT;
 108         rstate->placement[2] = RADEON_GEM_DOMAIN_GTT;
 109         rstate->placement[4] = RADEON_GEM_DOMAIN_GTT;
 110         rstate->nbo = 3;
 111         pitch = rtex->pitch[level] / 8 - 1;
 112         slice = rtex->pitch[level] * state->cbufs[0]->height / 64 - 1;
 113         rstate->states[R600_CB0__CB_COLOR0_BASE] = 0x00000000;
 114         rstate->states[R600_CB0__CB_COLOR0_INFO] = 0x08110068;
 115         rstate->states[R600_CB0__CB_COLOR0_SIZE] = S_028060_PITCH_TILE_MAX(pitch) |
 116                                                 S_028060_SLICE_TILE_MAX(slice);
 117         rstate->states[R600_CB0__CB_COLOR0_VIEW] = 0x00000000;
 118         rstate->states[R600_CB0__CB_COLOR0_FRAG] = 0x00000000;
 119         rstate->states[R600_CB0__CB_COLOR0_TILE] = 0x00000000;
 120         rstate->states[R600_CB0__CB_COLOR0_MASK] = 0x00000000;
 121         if (radeon_state_pm4(rstate)) {
 122                 radeon_state_decref(rstate);
 123                 return;
 124         }
 125         radeon_draw_set_new(rctx->draw, rstate);
 126         rctx->db = radeon_state_decref(rctx->db);
 127         rctx->db = radeon_state(rscreen->rw, R600_DB_TYPE, R600_DB);
 128         rctx->db->bo[0] = radeon_bo_incref(rscreen->rw, rstate->bo[0]);
 129         rctx->db->nbo = 1;
 130         rctx->db->placement[0] = RADEON_GEM_DOMAIN_GTT;
 131         rctx->fb_state = *state;
 132 }
 133
 134 static void *r600_create_fs_state(struct pipe_context *ctx,
 135                                         const struct pipe_shader_state *shader)
 136 {
 137         return r600_pipe_shader_create(ctx, C_PROGRAM_TYPE_FS, shader->tokens);
 138 }
 139
 140 static void r600_bind_fs_state(struct pipe_context *ctx, void *state)
 141 {
 142         struct r600_context *rctx = (struct r600_context*)ctx;
 143
 144         rctx->ps_shader = state;
 145 }
 146
 147 static void *r600_create_vs_state(struct pipe_context *ctx,
 148                                         const struct pipe_shader_state *shader)
 149 {
 150         return r600_pipe_shader_create(ctx, C_PROGRAM_TYPE_VS, shader->tokens);
 151 }
 152
 153 static void r600_bind_vs_state(struct pipe_context *ctx, void *state)
 154 {
 155         struct r600_context *rctx = (struct r600_context*)ctx;
 156
 157         rctx->vs_shader = state;
 158 }
 159
 160 static void r600_set_polygon_stipple(struct pipe_context *ctx,
 161                                          const struct pipe_poly_stipple *state)
 162 {
 163 }
 164
 165 static void *r600_create_rs_state(struct pipe_context *ctx,
 166                                         const struct pipe_rasterizer_state *state)
 167 {
 168         struct r600_screen *rscreen = (struct r600_screen*)ctx->screen;
 169         struct r600_context *rctx = (struct r600_context*)ctx;
 170         struct radeon_state *rstate;
 171
 172         rctx->flat_shade = state->flatshade;
 173         rstate = radeon_state(rscreen->rw, R600_RASTERIZER_TYPE, R600_RASTERIZER);
 174         if (rstate == NULL)
 175                 return NULL;
 176         rstate->states[R600_RASTERIZER__SPI_INTERP_CONTROL_0] = 0x00000001;
 177         rstate->states[R600_RASTERIZER__PA_CL_CLIP_CNTL] = 0x00000000;
 178         rstate->states[R600_RASTERIZER__PA_SU_SC_MODE_CNTL] = 0x00080000;
 179         rstate->states[R600_RASTERIZER__PA_CL_VS_OUT_CNTL] = 0x00000000;
 180         rstate->states[R600_RASTERIZER__PA_CL_NANINF_CNTL] = 0x00000000;
 181         rstate->states[R600_RASTERIZER__PA_SU_POINT_SIZE] = 0x00080008;
 182         rstate->states[R600_RASTERIZER__PA_SU_POINT_MINMAX] = 0x00000000;
 183         rstate->states[R600_RASTERIZER__PA_SU_LINE_CNTL] = 0x00000008;
 184         rstate->states[R600_RASTERIZER__PA_SC_LINE_STIPPLE] = 0x00000005;
 185         rstate->states[R600_RASTERIZER__PA_SC_MPASS_PS_CNTL] = 0x00000000;
 186         rstate->states[R600_RASTERIZER__PA_SC_LINE_CNTL] = 0x00000400;
 187         rstate->states[R600_RASTERIZER__PA_CL_GB_VERT_CLIP_ADJ] = 0x3F800000;
 188         rstate->states[R600_RASTERIZER__PA_CL_GB_VERT_DISC_ADJ] = 0x3F800000;
 189         rstate->states[R600_RASTERIZER__PA_CL_GB_HORZ_CLIP_ADJ] = 0x3F800000;
 190         rstate->states[R600_RASTERIZER__PA_CL_GB_HORZ_DISC_ADJ] = 0x3F800000;
 191         rstate->states[R600_RASTERIZER__PA_SU_POLY_OFFSET_DB_FMT_CNTL] = 0x00000000;
 192         rstate->states[R600_RASTERIZER__PA_SU_POLY_OFFSET_CLAMP] = 0x00000000;
 193         rstate->states[R600_RASTERIZER__PA_SU_POLY_OFFSET_FRONT_SCALE] = 0x00000000;
 194         rstate->states[R600_RASTERIZER__PA_SU_POLY_OFFSET_FRONT_OFFSET] = 0x00000000;
 195         rstate->states[R600_RASTERIZER__PA_SU_POLY_OFFSET_BACK_SCALE] = 0x00000000;
 196         rstate->states[R600_RASTERIZER__PA_SU_POLY_OFFSET_BACK_OFFSET] = 0x00000000;
 197         if (radeon_state_pm4(rstate)) {
 198                 radeon_state_decref(rstate);
 199                 return NULL;
 200         }
 201         return rstate;
 202 }
 203
 204 static void r600_bind_rs_state(struct pipe_context *ctx, void *state)
 205 {
 206         struct r600_context *rctx = (struct r600_context*)ctx;
 207         radeon_draw_set(rctx->draw, state);
 208 }
 209
 210 static void *r600_create_sampler_state(struct pipe_context *ctx,
 211                                         const struct pipe_sampler_state *state)
 212 {
 213         return NULL;
 214 }
 215
 216 static void r600_bind_sampler_states(struct pipe_context *ctx,
 217                                         unsigned count, void **states)
 218 {
 219 }
 220
 221 static struct pipe_sampler_view *r600_create_sampler_view(struct pipe_context *ctx,
 222                                                           struct pipe_resource *texture,
 223                                                           const struct pipe_sampler_view *templ)
 224 {
 225         struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view);
 226
 227         *view = *templ;
 228         return view;
 229 }
 230
 231 static void r600_sampler_view_destroy(struct pipe_context *ctx,
 232                                       struct pipe_sampler_view *view)
 233 {
 234         FREE(view);
 235 }
 236
 237 static void r600_set_fragment_sampler_views(struct pipe_context *ctx,
 238                                             unsigned count,
 239                                             struct pipe_sampler_view **views)
 240 {
 241 }
 242
 243 static void r600_set_vertex_sampler_views(struct pipe_context *ctx,
 244                                           unsigned count,
 245                                           struct pipe_sampler_view **views)
 246 {
 247 }
 248
 249 static void r600_set_scissor_state(struct pipe_context *ctx,
 250                                         const struct pipe_scissor_state *state)
 251 {
 252         struct r600_screen *rscreen = (struct r600_screen*)ctx->screen;
 253         struct r600_context *rctx = (struct r600_context*)ctx;
 254         struct radeon_state *rstate;
 255         u32 tl, br;
 256
 257         tl = S_028240_TL_X(state->minx) | S_028240_TL_Y(state->miny) | S_028240_WINDOW_OFFSET_DISABLE(1);
 258         br = S_028244_BR_X(state->maxx) | S_028244_BR_Y(state->maxy);
 259         rstate = radeon_state(rscreen->rw, R600_SCISSOR_TYPE, R600_SCISSOR);
 260         if (rstate == NULL)
 261                 return;
 262         rstate->states[R600_SCISSOR__PA_SC_SCREEN_SCISSOR_TL] = tl;
 263         rstate->states[R600_SCISSOR__PA_SC_SCREEN_SCISSOR_BR] = br;
 264         rstate->states[R600_SCISSOR__PA_SC_WINDOW_OFFSET] = 0x00000000;
 265         rstate->states[R600_SCISSOR__PA_SC_WINDOW_SCISSOR_TL] = tl;
 266         rstate->states[R600_SCISSOR__PA_SC_WINDOW_SCISSOR_BR] = br;
 267         rstate->states[R600_SCISSOR__PA_SC_CLIPRECT_RULE] = 0x0000FFFF;
 268         rstate->states[R600_SCISSOR__PA_SC_CLIPRECT_0_TL] = tl;
 269         rstate->states[R600_SCISSOR__PA_SC_CLIPRECT_0_BR] = br;
 270         rstate->states[R600_SCISSOR__PA_SC_CLIPRECT_1_TL] = tl;
 271         rstate->states[R600_SCISSOR__PA_SC_CLIPRECT_1_BR] = br;
 272         rstate->states[R600_SCISSOR__PA_SC_CLIPRECT_2_TL] = tl;
 273         rstate->states[R600_SCISSOR__PA_SC_CLIPRECT_2_BR] = br;
 274         rstate->states[R600_SCISSOR__PA_SC_CLIPRECT_3_TL] = tl;
 275         rstate->states[R600_SCISSOR__PA_SC_CLIPRECT_3_BR] = br;
 276         rstate->states[R600_SCISSOR__PA_SC_EDGERULE] = 0xAAAAAAAA;
 277         rstate->states[R600_SCISSOR__PA_SC_GENERIC_SCISSOR_TL] = tl;
 278         rstate->states[R600_SCISSOR__PA_SC_GENERIC_SCISSOR_BR] = br;
 279         rstate->states[R600_SCISSOR__PA_SC_VPORT_SCISSOR_0_TL] = tl;
 280         rstate->states[R600_SCISSOR__PA_SC_VPORT_SCISSOR_0_BR] = br;
 281         if (radeon_state_pm4(rstate)) {
 282                 radeon_state_decref(rstate);
 283                 return;
 284         }
 285         radeon_draw_set_new(rctx->draw, rstate);
 286 }
 287
 288 static void r600_set_viewport_state(struct pipe_context *ctx,
 289                                         const struct pipe_viewport_state *state)
 290 {
 291         struct r600_screen *rscreen = (struct r600_screen*)ctx->screen;
 292         struct r600_context *rctx = (struct r600_context*)ctx;
 293         struct radeon_state *rstate;
 294
 295         rstate = radeon_state(rscreen->rw, R600_VIEWPORT_TYPE, R600_VIEWPORT);
 296         if (rstate == NULL)
 297                 return;
 298         rstate->states[R600_VIEWPORT__PA_SC_VPORT_ZMIN_0] = 0x00000000;
 299         rstate->states[R600_VIEWPORT__PA_SC_VPORT_ZMAX_0] = 0x3F800000;
 300         rstate->states[R600_VIEWPORT__PA_CL_VPORT_XSCALE_0] = r600_float_to_u32(state->scale[0]);
 301         rstate->states[R600_VIEWPORT__PA_CL_VPORT_YSCALE_0] = r600_float_to_u32(state->scale[1]);
 302         rstate->states[R600_VIEWPORT__PA_CL_VPORT_ZSCALE_0] = r600_float_to_u32(state->scale[2]);
 303         rstate->states[R600_VIEWPORT__PA_CL_VPORT_XOFFSET_0] = r600_float_to_u32(state->translate[0]);
 304         rstate->states[R600_VIEWPORT__PA_CL_VPORT_YOFFSET_0] = r600_float_to_u32(state->translate[1]);
 305         rstate->states[R600_VIEWPORT__PA_CL_VPORT_ZOFFSET_0] = r600_float_to_u32(state->translate[2]);
 306         rstate->states[R600_VIEWPORT__PA_CL_VTE_CNTL] = 0x0000043F;
 307         if (radeon_state_pm4(rstate)) {
 308                 radeon_state_decref(rstate);
 309                 return;
 310         }
 311         radeon_draw_set_new(rctx->draw, rstate);
 312         rctx->viewport = state;
 313 }
 314
 315 static void r600_set_vertex_buffers(struct pipe_context *ctx,
 316                                         unsigned count,
 317                                         const struct pipe_vertex_buffer *buffers)
 318 {
 319         struct r600_context *rctx = (struct r600_context*)ctx;
 320
 321         memcpy(rctx->vertex_buffer, buffers, sizeof(struct pipe_vertex_buffer) * count);
 322         rctx->nvertex_buffer = count;
 323 }
 324
 325
 326 static void *r600_create_vertex_elements_state(struct pipe_context *ctx,
 327                                                unsigned count,
 328                                                const struct pipe_vertex_element *elements)
 329 {
 330         struct r600_vertex_elements_state *v = CALLOC_STRUCT(r600_vertex_elements_state);
 331
 332         assert(count < 32);
 333         v->count = count;
 334         memcpy(v->elements, elements, count * sizeof(struct pipe_vertex_element));
 335         return v;
 336 }
 337
 338 static void r600_bind_vertex_elements_state(struct pipe_context *ctx, void *state)
 339 {
 340         struct r600_context *rctx = (struct r600_context*)ctx;
 341         struct r600_vertex_elements_state *v = (struct r600_vertex_elements_state*)state;
 342
 343         rctx->vertex_elements = v;
 344 }
 345
 346 static void r600_delete_vertex_elements_state(struct pipe_context *ctx, void *state)
 347 {
 348         FREE(state);
 349 }
 350
 351 static void *r600_create_dsa_state(struct pipe_context *ctx,
 352                                         const struct pipe_depth_stencil_alpha_state *state)
 353 {
 354         struct r600_screen *rscreen = (struct r600_screen*)ctx->screen;
 355         struct radeon_state *rstate;
 356
 357         rstate = radeon_state(rscreen->rw, R600_DSA_TYPE, R600_DSA);
 358         if (rstate == NULL)
 359                 return NULL;
 360         rstate->states[R600_DSA__DB_STENCIL_CLEAR] = 0x00000000;
 361         rstate->states[R600_DSA__DB_DEPTH_CLEAR] = 0x3F800000;
 362         rstate->states[R600_DSA__SX_ALPHA_TEST_CONTROL] = 0x00000000;
 363         rstate->states[R600_DSA__DB_STENCILREFMASK] = 0xFFFFFF00;
 364         rstate->states[R600_DSA__DB_STENCILREFMASK_BF] = 0xFFFFFF00;
 365         rstate->states[R600_DSA__SX_ALPHA_REF] = 0x00000000;
 366         rstate->states[R600_DSA__SPI_FOG_FUNC_SCALE] = 0x00000000;
 367         rstate->states[R600_DSA__SPI_FOG_FUNC_BIAS] = 0x00000000;
 368         rstate->states[R600_DSA__SPI_FOG_CNTL] = 0x00000000;
 369         rstate->states[R600_DSA__DB_DEPTH_CONTROL] = 0x00700700;
 370         rstate->states[R600_DSA__DB_SHADER_CONTROL] = 0x00000210;
 371         rstate->states[R600_DSA__DB_RENDER_CONTROL] = 0x00000060;
 372         rstate->states[R600_DSA__DB_RENDER_OVERRIDE] = 0x0000002A;
 373         rstate->states[R600_DSA__DB_SRESULTS_COMPARE_STATE1] = 0x00000000;
 374         rstate->states[R600_DSA__DB_PRELOAD_CONTROL] = 0x00000000;
 375         rstate->states[R600_DSA__DB_ALPHA_TO_MASK] = 0x0000AA00;
 376         if (radeon_state_pm4(rstate)) {
 377                 radeon_state_decref(rstate);
 378                 return NULL;
 379         }
 380         return rstate;
 381 }
 382
 383 static void r600_bind_dsa_state(struct pipe_context *ctx, void *state)
 384 {
 385         struct r600_context *rctx = (struct r600_context*)ctx;
 386         radeon_draw_set(rctx->draw, state);
 387 }
 388
 389 static void r600_set_constant_buffer(struct pipe_context *ctx,
 390                                      uint shader, uint index,
 391                                      struct pipe_resource *buffer)
 392 {
 393         struct r600_screen *rscreen = (struct r600_screen*)ctx->screen;
 394         struct r600_context *rctx = (struct r600_context*)ctx;
 395         unsigned nconstant = 0, i, type, id;
 396         struct radeon_state *rstate;
 397         struct pipe_transfer *transfer;
 398         u32 *ptr;
 399
 400         switch (shader) {
 401         case PIPE_SHADER_VERTEX:
 402                 id = R600_VS_CONSTANT;
 403                 type = R600_VS_CONSTANT_TYPE;
 404                 break;
 405         case PIPE_SHADER_FRAGMENT:
 406                 id = R600_PS_CONSTANT;
 407                 type = R600_PS_CONSTANT_TYPE;
 408                 break;
 409         default:
 410                 fprintf(stderr, "%s:%d unsupported %d\n", __func__, __LINE__, shader);
 411                 return;
 412         }
 413         if (buffer && buffer->width0 > 0) {
 414                 nconstant = buffer->width0 / 16;
 415                 ptr = pipe_buffer_map(ctx, buffer, PIPE_TRANSFER_READ, &transfer);
 416                 if (ptr == NULL)
 417                         return;
 418                 for (i = 0; i < nconstant; i++) {
 419                         rstate = radeon_state(rscreen->rw, type, id + i);
 420                         if (rstate == NULL)
 421                                 return;
 422                         rstate->states[R600_PS_CONSTANT__SQ_ALU_CONSTANT0_0] = ptr[i * 4 + 0];
 423                         rstate->states[R600_PS_CONSTANT__SQ_ALU_CONSTANT1_0] = ptr[i * 4 + 1];
 424                         rstate->states[R600_PS_CONSTANT__SQ_ALU_CONSTANT2_0] = ptr[i * 4 + 2];
 425                         rstate->states[R600_PS_CONSTANT__SQ_ALU_CONSTANT3_0] = ptr[i * 4 + 3];
 426                         if (radeon_state_pm4(rstate))
 427                                 return;
 428                         if (radeon_draw_set_new(rctx->draw, rstate))
 429                                 return;
 430                 }
 431                 pipe_buffer_unmap(ctx, buffer, transfer);
 432         }
 433 }
 434
 435 static void r600_set_stencil_ref(struct pipe_context *ctx,
 436                                 const struct pipe_stencil_ref *sr)
 437 {
 438         struct r600_context *rctx = (struct r600_context*)ctx;
 439         rctx->stencil_ref = *sr;
 440 }
 441
 442 static void r600_set_sample_mask(struct pipe_context *pipe, unsigned sample_mask)
 443 {
 444 }
 445
 446 void r600_init_state_functions(struct r600_context *rctx)
 447 {
 448         rctx->context.set_sample_mask = r600_set_sample_mask;
 449         rctx->context.create_blend_state = r600_create_blend_state;
 450         rctx->context.bind_blend_state = r600_bind_blend_state;
 451         rctx->context.delete_blend_state = r600_delete_state;
 452         rctx->context.set_blend_color = r600_set_blend_color;
 453         rctx->context.set_clip_state = r600_set_clip_state;
 454         rctx->context.set_constant_buffer = r600_set_constant_buffer;
 455         rctx->context.create_depth_stencil_alpha_state = r600_create_dsa_state;
 456         rctx->context.bind_depth_stencil_alpha_state = r600_bind_dsa_state;
 457         rctx->context.delete_depth_stencil_alpha_state = r600_delete_state;
 458         rctx->context.set_framebuffer_state = r600_set_framebuffer_state;
 459         rctx->context.create_fs_state = r600_create_fs_state;
 460         rctx->context.bind_fs_state = r600_bind_fs_state;
 461         rctx->context.delete_fs_state = r600_delete_state;
 462         rctx->context.set_polygon_stipple = r600_set_polygon_stipple;
 463         rctx->context.create_rasterizer_state = r600_create_rs_state;
 464         rctx->context.bind_rasterizer_state = r600_bind_rs_state;
 465         rctx->context.delete_rasterizer_state = r600_delete_state;
 466         rctx->context.create_sampler_state = r600_create_sampler_state;
 467         rctx->context.bind_fragment_sampler_states = r600_bind_sampler_states;
 468         rctx->context.bind_vertex_sampler_states = r600_bind_sampler_states;
 469         rctx->context.delete_sampler_state = r600_delete_state;
 470         rctx->context.create_sampler_view = r600_create_sampler_view;
 471         rctx->context.sampler_view_destroy = r600_sampler_view_destroy;
 472         rctx->context.set_fragment_sampler_views = r600_set_fragment_sampler_views;
 473         rctx->context.set_vertex_sampler_views = r600_set_vertex_sampler_views;
 474         rctx->context.set_scissor_state = r600_set_scissor_state;
 475         rctx->context.set_viewport_state = r600_set_viewport_state;
 476         rctx->context.set_vertex_buffers = r600_set_vertex_buffers;
 477         rctx->context.create_vertex_elements_state = r600_create_vertex_elements_state;
 478         rctx->context.bind_vertex_elements_state = r600_bind_vertex_elements_state;
 479         rctx->context.delete_vertex_elements_state = r600_delete_vertex_elements_state;
 480         rctx->context.create_vs_state = r600_create_vs_state;
 481         rctx->context.bind_vs_state = r600_bind_vs_state;
 482         rctx->context.delete_vs_state = r600_delete_state;
 483         rctx->context.set_stencil_ref = r600_set_stencil_ref;
 484 }