r300_state.c revision 13131adbf1beb3e4222ce16c32ac7910a4a5331b
1/* 2 * Copyright 2008 Corbin Simpson <MostAwesomeDude@gmail.com> 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 "util/u_math.h" 24#include "util/u_pack_color.h" 25 26#include "util/u_debug.h" 27#include "pipe/internal/p_winsys_screen.h" 28 29#include "r300_context.h" 30#include "r300_reg.h" 31#include "r300_state_inlines.h" 32#include "r300_state_shader.h" 33 34/* r300_state: Functions used to intialize state context by translating 35 * Gallium state objects into semi-native r300 state objects. */ 36 37/* Create a new blend state based on the CSO blend state. 38 * 39 * This encompasses alpha blending, logic/raster ops, and blend dithering. */ 40static void* r300_create_blend_state(struct pipe_context* pipe, 41 const struct pipe_blend_state* state) 42{ 43 struct r300_blend_state* blend = CALLOC_STRUCT(r300_blend_state); 44 45 if (state->blend_enable) { 46 /* XXX for now, always do separate alpha... 47 * is it faster to do it with one reg? */ 48 blend->blend_control = R300_ALPHA_BLEND_ENABLE | 49 R300_SEPARATE_ALPHA_ENABLE | 50 R300_READ_ENABLE | 51 r300_translate_blend_function(state->rgb_func) | 52 (r300_translate_blend_factor(state->rgb_src_factor) << 53 R300_SRC_BLEND_SHIFT) | 54 (r300_translate_blend_factor(state->rgb_dst_factor) << 55 R300_DST_BLEND_SHIFT); 56 blend->alpha_blend_control = 57 r300_translate_blend_function(state->alpha_func) | 58 (r300_translate_blend_factor(state->alpha_src_factor) << 59 R300_SRC_BLEND_SHIFT) | 60 (r300_translate_blend_factor(state->alpha_dst_factor) << 61 R300_DST_BLEND_SHIFT); 62 } 63 64 /* PIPE_LOGICOP_* don't need to be translated, fortunately. */ 65 /* XXX are logicops still allowed if blending's disabled? 66 * Does Gallium take care of it for us? */ 67 if (state->logicop_enable) { 68 blend->rop = R300_RB3D_ROPCNTL_ROP_ENABLE | 69 (state->logicop_func) << R300_RB3D_ROPCNTL_ROP_SHIFT; 70 } 71 72 if (state->dither) { 73 blend->dither = R300_RB3D_DITHER_CTL_DITHER_MODE_LUT | 74 R300_RB3D_DITHER_CTL_ALPHA_DITHER_MODE_LUT; 75 } 76 77 return (void*)blend; 78} 79 80/* Bind blend state. */ 81static void r300_bind_blend_state(struct pipe_context* pipe, 82 void* state) 83{ 84 struct r300_context* r300 = r300_context(pipe); 85 86 r300->blend_state = (struct r300_blend_state*)state; 87 r300->dirty_state |= R300_NEW_BLEND; 88} 89 90/* Free blend state. */ 91static void r300_delete_blend_state(struct pipe_context* pipe, 92 void* state) 93{ 94 FREE(state); 95} 96 97/* Set blend color. 98 * Setup both R300 and R500 registers, figure out later which one to write. */ 99static void r300_set_blend_color(struct pipe_context* pipe, 100 const struct pipe_blend_color* color) 101{ 102 struct r300_context* r300 = r300_context(pipe); 103 ubyte ur, ug, ub, ua; 104 105 ur = float_to_ubyte(color->color[0]); 106 ug = float_to_ubyte(color->color[1]); 107 ub = float_to_ubyte(color->color[2]); 108 ua = float_to_ubyte(color->color[3]); 109 110 util_pack_color(color->color, PIPE_FORMAT_A8R8G8B8_UNORM, 111 &r300->blend_color_state->blend_color); 112 113 /* XXX this is wrong */ 114 r300->blend_color_state->blend_color_red_alpha = ur | (ua << 16); 115 r300->blend_color_state->blend_color_green_blue = ub | (ug << 16); 116 117 r300->dirty_state |= R300_NEW_BLEND_COLOR; 118} 119 120static void r300_set_clip_state(struct pipe_context* pipe, 121 const struct pipe_clip_state* state) 122{ 123 struct r300_context* r300 = r300_context(pipe); 124 /* XXX Draw */ 125 draw_flush(r300->draw); 126 draw_set_clip_state(r300->draw, state); 127} 128 129static void 130 r300_set_constant_buffer(struct pipe_context* pipe, 131 uint shader, uint index, 132 const struct pipe_constant_buffer* buffer) 133{ 134 struct r300_context* r300 = r300_context(pipe); 135 int i = r300->shader_constants[shader].user_count; 136 137 /* This entire chunk of code seems ever-so-slightly baked. 138 * It's as if I've got pipe_buffer* matryoshkas... */ 139 if (buffer && buffer->buffer && buffer->buffer->size) { 140 void* map = pipe->winsys->buffer_map(pipe->winsys, buffer->buffer, 141 PIPE_BUFFER_USAGE_CPU_READ); 142 memcpy(r300->shader_constants[shader].constants, 143 map, buffer->buffer->size); 144 pipe->winsys->buffer_unmap(pipe->winsys, buffer->buffer); 145 146 r300->shader_constants[shader].user_count = 147 buffer->buffer->size / (sizeof(float) * 4); 148 } else { 149 r300->shader_constants[shader].user_count = 0; 150 } 151 152 r300->dirty_state |= R300_NEW_CONSTANTS; 153 154 /* If the number of constants have changed, invalidate the shader. */ 155 if (r300->shader_constants[shader].user_count != i) { 156 if (shader == PIPE_SHADER_FRAGMENT && r300->fs) { 157 r300->fs->translated = FALSE; 158 r300_translate_fragment_shader(r300, r300->fs); 159 } else if (shader == PIPE_SHADER_VERTEX && r300->vs) { 160 r300->vs->translated = FALSE; 161 r300_translate_vertex_shader(r300, r300->vs); 162 } 163 } 164} 165 166/* Create a new depth, stencil, and alpha state based on the CSO dsa state. 167 * 168 * This contains the depth buffer, stencil buffer, alpha test, and such. 169 * On the Radeon, depth and stencil buffer setup are intertwined, which is 170 * the reason for some of the strange-looking assignments across registers. */ 171static void* 172 r300_create_dsa_state(struct pipe_context* pipe, 173 const struct pipe_depth_stencil_alpha_state* state) 174{ 175 struct r300_dsa_state* dsa = CALLOC_STRUCT(r300_dsa_state); 176 177 /* Depth test setup. */ 178 if (state->depth.enabled) { 179 dsa->z_buffer_control |= R300_Z_ENABLE; 180 181 if (state->depth.writemask) { 182 dsa->z_buffer_control |= R300_Z_WRITE_ENABLE; 183 } 184 185 dsa->z_stencil_control |= 186 (r300_translate_depth_stencil_function(state->depth.func) << 187 R300_Z_FUNC_SHIFT); 188 } 189 190 /* Stencil buffer setup. */ 191 if (state->stencil[0].enabled) { 192 dsa->z_buffer_control |= R300_STENCIL_ENABLE; 193 dsa->z_stencil_control |= 194 (r300_translate_depth_stencil_function(state->stencil[0].func) << 195 R300_S_FRONT_FUNC_SHIFT) | 196 (r300_translate_stencil_op(state->stencil[0].fail_op) << 197 R300_S_FRONT_SFAIL_OP_SHIFT) | 198 (r300_translate_stencil_op(state->stencil[0].zpass_op) << 199 R300_S_FRONT_ZPASS_OP_SHIFT) | 200 (r300_translate_stencil_op(state->stencil[0].zfail_op) << 201 R300_S_FRONT_ZFAIL_OP_SHIFT); 202 203 dsa->stencil_ref_mask = (state->stencil[0].ref_value) | 204 (state->stencil[0].valuemask << R300_STENCILMASK_SHIFT) | 205 (state->stencil[0].writemask << R300_STENCILWRITEMASK_SHIFT); 206 207 if (state->stencil[1].enabled) { 208 dsa->z_buffer_control |= R300_STENCIL_FRONT_BACK; 209 dsa->z_stencil_control |= 210 (r300_translate_depth_stencil_function(state->stencil[1].func) << 211 R300_S_BACK_FUNC_SHIFT) | 212 (r300_translate_stencil_op(state->stencil[1].fail_op) << 213 R300_S_BACK_SFAIL_OP_SHIFT) | 214 (r300_translate_stencil_op(state->stencil[1].zpass_op) << 215 R300_S_BACK_ZPASS_OP_SHIFT) | 216 (r300_translate_stencil_op(state->stencil[1].zfail_op) << 217 R300_S_BACK_ZFAIL_OP_SHIFT); 218 219 dsa->stencil_ref_bf = (state->stencil[1].ref_value) | 220 (state->stencil[1].valuemask << R300_STENCILMASK_SHIFT) | 221 (state->stencil[1].writemask << R300_STENCILWRITEMASK_SHIFT); 222 } 223 } 224 225 /* Alpha test setup. */ 226 if (state->alpha.enabled) { 227 dsa->alpha_function = 228 r300_translate_alpha_function(state->alpha.func) | 229 R300_FG_ALPHA_FUNC_ENABLE; 230 dsa->alpha_reference = CLAMP(state->alpha.ref_value * 1023.0f, 231 0, 1023); 232 } else { 233 dsa->z_buffer_top = R300_ZTOP_ENABLE; 234 } 235 236 return (void*)dsa; 237} 238 239/* Bind DSA state. */ 240static void r300_bind_dsa_state(struct pipe_context* pipe, 241 void* state) 242{ 243 struct r300_context* r300 = r300_context(pipe); 244 245 r300->dsa_state = (struct r300_dsa_state*)state; 246 r300->dirty_state |= R300_NEW_DSA; 247} 248 249/* Free DSA state. */ 250static void r300_delete_dsa_state(struct pipe_context* pipe, 251 void* state) 252{ 253 FREE(state); 254} 255 256static void r300_set_edgeflags(struct pipe_context* pipe, 257 const unsigned* bitfield) 258{ 259 /* XXX you know it's bad when i915 has this blank too */ 260} 261 262static void 263 r300_set_framebuffer_state(struct pipe_context* pipe, 264 const struct pipe_framebuffer_state* state) 265{ 266 struct r300_context* r300 = r300_context(pipe); 267 268 draw_flush(r300->draw); 269 270 r300->framebuffer_state = *state; 271 272 r300->dirty_state |= R300_NEW_FRAMEBUFFERS; 273} 274 275/* Create fragment shader state. */ 276static void* r300_create_fs_state(struct pipe_context* pipe, 277 const struct pipe_shader_state* shader) 278{ 279 struct r300_context* r300 = r300_context(pipe); 280 struct r3xx_fragment_shader* fs = NULL; 281 282 if (r300_screen(r300->context.screen)->caps->is_r500) { 283 fs = 284 (struct r3xx_fragment_shader*)CALLOC_STRUCT(r500_fragment_shader); 285 } else { 286 fs = 287 (struct r3xx_fragment_shader*)CALLOC_STRUCT(r300_fragment_shader); 288 } 289 290 /* Copy state directly into shader. */ 291 fs->state = *shader; 292 fs->state.tokens = tgsi_dup_tokens(shader->tokens); 293 294 tgsi_scan_shader(shader->tokens, &fs->info); 295 296 return (void*)fs; 297} 298 299/* Bind fragment shader state. */ 300static void r300_bind_fs_state(struct pipe_context* pipe, void* shader) 301{ 302 struct r300_context* r300 = r300_context(pipe); 303 struct r3xx_fragment_shader* fs = (struct r3xx_fragment_shader*)shader; 304 305 if (fs == NULL) { 306 r300->fs = NULL; 307 return; 308 } else if (!fs->translated) { 309 r300_translate_fragment_shader(r300, fs); 310 } 311 312 fs->translated = TRUE; 313 r300->fs = fs; 314 315 r300->dirty_state |= R300_NEW_FRAGMENT_SHADER; 316} 317 318/* Delete fragment shader state. */ 319static void r300_delete_fs_state(struct pipe_context* pipe, void* shader) 320{ 321 struct r3xx_fragment_shader* fs = (struct r3xx_fragment_shader*)shader; 322 FREE(fs->state.tokens); 323 FREE(shader); 324} 325 326static void r300_set_polygon_stipple(struct pipe_context* pipe, 327 const struct pipe_poly_stipple* state) 328{ 329 /* XXX */ 330} 331 332/* Create a new rasterizer state based on the CSO rasterizer state. 333 * 334 * This is a very large chunk of state, and covers most of the graphics 335 * backend (GB), geometry assembly (GA), and setup unit (SU) blocks. 336 * 337 * In a not entirely unironic sidenote, this state has nearly nothing to do 338 * with the actual block on the Radeon called the rasterizer (RS). */ 339static void* r300_create_rs_state(struct pipe_context* pipe, 340 const struct pipe_rasterizer_state* state) 341{ 342 struct r300_rs_state* rs = CALLOC_STRUCT(r300_rs_state); 343 344 /* Copy rasterizer state for Draw. */ 345 rs->rs = *state; 346 347 /* If bypassing TCL, or if no TCL engine is present, turn off the HW TCL. 348 * Else, enable HW TCL and force Draw's TCL off. */ 349 if (state->bypass_vs_clip_and_viewport || 350 !r300_screen(pipe->screen)->caps->has_tcl) { 351 rs->vap_control_status = R300_VAP_TCL_BYPASS; 352 } else { 353 rs->rs.bypass_vs_clip_and_viewport = TRUE; 354 rs->vap_control_status = 0; 355 } 356 357 rs->point_size = pack_float_16_6x(state->point_size) | 358 (pack_float_16_6x(state->point_size) << R300_POINTSIZE_X_SHIFT); 359 360 rs->point_minmax = 361 ((int)(state->point_size_min * 6.0) << 362 R300_GA_POINT_MINMAX_MIN_SHIFT) | 363 ((int)(state->point_size_max * 6.0) << 364 R300_GA_POINT_MINMAX_MAX_SHIFT); 365 366 rs->line_control = pack_float_16_6x(state->line_width) | 367 R300_GA_LINE_CNTL_END_TYPE_COMP; 368 369 /* Radeons don't think in "CW/CCW", they think in "front/back". */ 370 if (state->front_winding == PIPE_WINDING_CW) { 371 rs->cull_mode = R300_FRONT_FACE_CW; 372 373 if (state->offset_cw) { 374 rs->polygon_offset_enable |= R300_FRONT_ENABLE; 375 } 376 if (state->offset_ccw) { 377 rs->polygon_offset_enable |= R300_BACK_ENABLE; 378 } 379 } else { 380 rs->cull_mode = R300_FRONT_FACE_CCW; 381 382 if (state->offset_ccw) { 383 rs->polygon_offset_enable |= R300_FRONT_ENABLE; 384 } 385 if (state->offset_cw) { 386 rs->polygon_offset_enable |= R300_BACK_ENABLE; 387 } 388 } 389 if (state->front_winding & state->cull_mode) { 390 rs->cull_mode |= R300_CULL_FRONT; 391 } 392 if (~(state->front_winding) & state->cull_mode) { 393 rs->cull_mode |= R300_CULL_BACK; 394 } 395 396 if (rs->polygon_offset_enable) { 397 rs->depth_offset_front = rs->depth_offset_back = 398 fui(state->offset_units); 399 rs->depth_scale_front = rs->depth_scale_back = 400 fui(state->offset_scale); 401 } 402 403 if (state->line_stipple_enable) { 404 rs->line_stipple_config = 405 R300_GA_LINE_STIPPLE_CONFIG_LINE_RESET_LINE | 406 (fui((float)state->line_stipple_factor) & 407 R300_GA_LINE_STIPPLE_CONFIG_STIPPLE_SCALE_MASK); 408 /* XXX this might need to be scaled up */ 409 rs->line_stipple_value = state->line_stipple_pattern; 410 } 411 412 if (state->flatshade) { 413 rs->color_control = R300_SHADE_MODEL_FLAT; 414 } else { 415 rs->color_control = R300_SHADE_MODEL_SMOOTH; 416 } 417 418 return (void*)rs; 419} 420 421/* Bind rasterizer state. */ 422static void r300_bind_rs_state(struct pipe_context* pipe, void* state) 423{ 424 struct r300_context* r300 = r300_context(pipe); 425 struct r300_rs_state* rs = (struct r300_rs_state*)state; 426 427 draw_flush(r300->draw); 428 draw_set_rasterizer_state(r300->draw, &rs->rs); 429 430 r300->rs_state = rs; 431 r300->dirty_state |= R300_NEW_RASTERIZER; 432} 433 434/* Free rasterizer state. */ 435static void r300_delete_rs_state(struct pipe_context* pipe, void* state) 436{ 437 FREE(state); 438} 439 440static void* 441 r300_create_sampler_state(struct pipe_context* pipe, 442 const struct pipe_sampler_state* state) 443{ 444 struct r300_context* r300 = r300_context(pipe); 445 struct r300_sampler_state* sampler = CALLOC_STRUCT(r300_sampler_state); 446 int lod_bias; 447 448 sampler->filter0 |= 449 (r300_translate_wrap(state->wrap_s) << R300_TX_WRAP_S_SHIFT) | 450 (r300_translate_wrap(state->wrap_t) << R300_TX_WRAP_T_SHIFT) | 451 (r300_translate_wrap(state->wrap_r) << R300_TX_WRAP_R_SHIFT); 452 453 sampler->filter0 |= r300_translate_tex_filters(state->min_img_filter, 454 state->mag_img_filter, 455 state->min_mip_filter); 456 457 lod_bias = CLAMP((int)(state->lod_bias * 32), -(1 << 9), (1 << 9) - 1); 458 459 sampler->filter1 |= lod_bias << R300_LOD_BIAS_SHIFT; 460 461 sampler->filter1 |= r300_anisotropy(state->max_anisotropy); 462 463 util_pack_color(state->border_color, PIPE_FORMAT_A8R8G8B8_UNORM, 464 &sampler->border_color); 465 466 /* R500-specific fixups and optimizations */ 467 if (r300_screen(r300->context.screen)->caps->is_r500) { 468 sampler->filter1 |= R500_BORDER_FIX; 469 } 470 471 return (void*)sampler; 472} 473 474static void r300_bind_sampler_states(struct pipe_context* pipe, 475 unsigned count, 476 void** states) 477{ 478 struct r300_context* r300 = r300_context(pipe); 479 int i; 480 481 if (count > 8) { 482 return; 483 } 484 485 for (i = 0; i < count; i++) { 486 if (r300->sampler_states[i] != states[i]) { 487 r300->sampler_states[i] = (struct r300_sampler_state*)states[i]; 488 r300->dirty_state |= (R300_NEW_SAMPLER << i); 489 } 490 } 491 492 r300->sampler_count = count; 493} 494 495static void r300_delete_sampler_state(struct pipe_context* pipe, void* state) 496{ 497 FREE(state); 498} 499 500static void r300_set_sampler_textures(struct pipe_context* pipe, 501 unsigned count, 502 struct pipe_texture** texture) 503{ 504 struct r300_context* r300 = r300_context(pipe); 505 int i; 506 507 /* XXX magic num */ 508 if (count > 8) { 509 return; 510 } 511 512 for (i = 0; i < count; i++) { 513 if (r300->textures[i] != (struct r300_texture*)texture[i]) { 514 pipe_texture_reference((struct pipe_texture**)&r300->textures[i], 515 texture[i]); 516 r300->dirty_state |= (R300_NEW_TEXTURE << i); 517 } 518 } 519 520 for (i = count; i < 8; i++) { 521 if (r300->textures[i]) { 522 pipe_texture_reference((struct pipe_texture**)&r300->textures[i], 523 NULL); 524 r300->dirty_state |= (R300_NEW_TEXTURE << i); 525 } 526 } 527 528 r300->texture_count = count; 529} 530 531static void r300_set_scissor_state(struct pipe_context* pipe, 532 const struct pipe_scissor_state* state) 533{ 534 struct r300_context* r300 = r300_context(pipe); 535 536 if (r300_screen(r300->context.screen)->caps->is_r500) { 537 r300->scissor_state->scissor_top_left = 538 (state->minx << R300_SCISSORS_X_SHIFT) | 539 (state->miny << R300_SCISSORS_Y_SHIFT); 540 r300->scissor_state->scissor_bottom_right = 541 (state->maxx << R300_SCISSORS_X_SHIFT) | 542 (state->maxy << R300_SCISSORS_Y_SHIFT); 543 } else { 544 /* Offset of 1440 in non-R500 chipsets. */ 545 r300->scissor_state->scissor_top_left = 546 ((state->minx + 1440) << R300_SCISSORS_X_SHIFT) | 547 ((state->miny + 1440) << R300_SCISSORS_Y_SHIFT); 548 r300->scissor_state->scissor_bottom_right = 549 ((state->maxx + 1440) << R300_SCISSORS_X_SHIFT) | 550 ((state->maxy + 1440) << R300_SCISSORS_Y_SHIFT); 551 } 552 553 r300->dirty_state |= R300_NEW_SCISSOR; 554} 555 556static void r300_set_viewport_state(struct pipe_context* pipe, 557 const struct pipe_viewport_state* state) 558{ 559 struct r300_context* r300 = r300_context(pipe); 560 561 draw_flush(r300->draw); 562 563 if (r300_screen(r300->context.screen)->caps->has_tcl) { 564 /* Do the transform in HW. */ 565 r300->viewport_state->vte_control = R300_VTX_XY_FMT | R300_VTX_Z_FMT; 566 567 if (state->scale[0] != 1.0f) { 568 assert(state->scale[0] != 0.0f); 569 r300->viewport_state->xscale = state->scale[0]; 570 r300->viewport_state->vte_control |= R300_VPORT_X_SCALE_ENA; 571 } 572 if (state->scale[1] != 1.0f) { 573 assert(state->scale[1] != 0.0f); 574 r300->viewport_state->yscale = state->scale[1]; 575 r300->viewport_state->vte_control |= R300_VPORT_Y_SCALE_ENA; 576 } 577 if (state->scale[2] != 1.0f) { 578 assert(state->scale[2] != 0.0f); 579 r300->viewport_state->zscale = state->scale[2]; 580 r300->viewport_state->vte_control |= R300_VPORT_Z_SCALE_ENA; 581 } 582 if (state->translate[0] != 0.0f) { 583 r300->viewport_state->xoffset = state->translate[0]; 584 r300->viewport_state->vte_control |= R300_VPORT_X_OFFSET_ENA; 585 } 586 if (state->translate[1] != 0.0f) { 587 r300->viewport_state->yoffset = state->translate[1]; 588 r300->viewport_state->vte_control |= R300_VPORT_Y_OFFSET_ENA; 589 } 590 if (state->translate[2] != 0.0f) { 591 r300->viewport_state->zoffset = state->translate[2]; 592 r300->viewport_state->vte_control |= R300_VPORT_Z_OFFSET_ENA; 593 } 594 } else { 595 r300->viewport_state->vte_control = 0; 596 /* Have Draw do the actual transform. */ 597 draw_set_viewport_state(r300->draw, state); 598 } 599 600 r300->dirty_state |= R300_NEW_VIEWPORT; 601} 602 603static void r300_set_vertex_buffers(struct pipe_context* pipe, 604 unsigned count, 605 const struct pipe_vertex_buffer* buffers) 606{ 607 struct r300_context* r300 = r300_context(pipe); 608 609 memcpy(r300->vertex_buffers, buffers, 610 sizeof(struct pipe_vertex_buffer) * count); 611 612 r300->vertex_buffer_count = count; 613 614 draw_flush(r300->draw); 615 draw_set_vertex_buffers(r300->draw, count, buffers); 616} 617 618static void r300_set_vertex_elements(struct pipe_context* pipe, 619 unsigned count, 620 const struct pipe_vertex_element* elements) 621{ 622 struct r300_context* r300 = r300_context(pipe); 623 624 draw_flush(r300->draw); 625 draw_set_vertex_elements(r300->draw, count, elements); 626} 627 628static void* r300_create_vs_state(struct pipe_context* pipe, 629 const struct pipe_shader_state* shader) 630{ 631 struct r300_context* r300 = r300_context(pipe); 632 633 if (r300_screen(pipe->screen)->caps->has_tcl) { 634 struct r300_vertex_shader* vs = CALLOC_STRUCT(r300_vertex_shader); 635 /* Copy state directly into shader. */ 636 vs->state = *shader; 637 638 tgsi_scan_shader(shader->tokens, &vs->info); 639 640 /* Appease Draw. */ 641 vs->draw = draw_create_vertex_shader(r300->draw, shader); 642 643 return (void*)vs; 644 } else { 645 return draw_create_vertex_shader(r300->draw, shader); 646 } 647} 648 649static void r300_bind_vs_state(struct pipe_context* pipe, void* shader) 650{ 651 struct r300_context* r300 = r300_context(pipe); 652 653 draw_flush(r300->draw); 654 655 if (r300_screen(pipe->screen)->caps->has_tcl) { 656 struct r300_vertex_shader* vs = (struct r300_vertex_shader*)shader; 657 658 if (vs == NULL) { 659 r300->vs = NULL; 660 return; 661 } else if (!vs->translated) { 662 r300_translate_vertex_shader(r300, vs); 663 } 664 665 draw_bind_vertex_shader(r300->draw, vs->draw); 666 r300->vs = vs; 667 r300->dirty_state |= R300_NEW_VERTEX_SHADER; 668 } else { 669 draw_bind_vertex_shader(r300->draw, 670 (struct draw_vertex_shader*)shader); 671 } 672} 673 674static void r300_delete_vs_state(struct pipe_context* pipe, void* shader) 675{ 676 struct r300_context* r300 = r300_context(pipe); 677 678 if (r300_screen(pipe->screen)->caps->has_tcl) { 679 struct r300_vertex_shader* vs = (struct r300_vertex_shader*)shader; 680 681 draw_delete_vertex_shader(r300->draw, vs->draw); 682 FREE(shader); 683 } else { 684 draw_delete_vertex_shader(r300->draw, 685 (struct draw_vertex_shader*)shader); 686 } 687} 688 689void r300_init_state_functions(struct r300_context* r300) 690{ 691 r300->context.create_blend_state = r300_create_blend_state; 692 r300->context.bind_blend_state = r300_bind_blend_state; 693 r300->context.delete_blend_state = r300_delete_blend_state; 694 695 r300->context.set_blend_color = r300_set_blend_color; 696 697 r300->context.set_clip_state = r300_set_clip_state; 698 699 r300->context.set_constant_buffer = r300_set_constant_buffer; 700 701 r300->context.create_depth_stencil_alpha_state = r300_create_dsa_state; 702 r300->context.bind_depth_stencil_alpha_state = r300_bind_dsa_state; 703 r300->context.delete_depth_stencil_alpha_state = r300_delete_dsa_state; 704 705 r300->context.set_edgeflags = r300_set_edgeflags; 706 707 r300->context.set_framebuffer_state = r300_set_framebuffer_state; 708 709 r300->context.create_fs_state = r300_create_fs_state; 710 r300->context.bind_fs_state = r300_bind_fs_state; 711 r300->context.delete_fs_state = r300_delete_fs_state; 712 713 r300->context.set_polygon_stipple = r300_set_polygon_stipple; 714 715 r300->context.create_rasterizer_state = r300_create_rs_state; 716 r300->context.bind_rasterizer_state = r300_bind_rs_state; 717 r300->context.delete_rasterizer_state = r300_delete_rs_state; 718 719 r300->context.create_sampler_state = r300_create_sampler_state; 720 r300->context.bind_sampler_states = r300_bind_sampler_states; 721 r300->context.delete_sampler_state = r300_delete_sampler_state; 722 723 r300->context.set_sampler_textures = r300_set_sampler_textures; 724 725 r300->context.set_scissor_state = r300_set_scissor_state; 726 727 r300->context.set_viewport_state = r300_set_viewport_state; 728 729 r300->context.set_vertex_buffers = r300_set_vertex_buffers; 730 r300->context.set_vertex_elements = r300_set_vertex_elements; 731 732 r300->context.create_vs_state = r300_create_vs_state; 733 r300->context.bind_vs_state = r300_bind_vs_state; 734 r300->context.delete_vs_state = r300_delete_vs_state; 735} 736