1 /************************************************************************** 2 * 3 * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR 22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27 28 /** @file intel_tris.c 29 * 30 * This file contains functions for managing the vertex buffer and emitting 31 * primitives into it. 32 */ 33 34 #include "main/glheader.h" 35 #include "main/context.h" 36 #include "main/macros.h" 37 #include "main/enums.h" 38 #include "main/texobj.h" 39 #include "main/state.h" 40 #include "main/dd.h" 41 #include "main/fbobject.h" 42 43 #include "swrast/swrast.h" 44 #include "swrast_setup/swrast_setup.h" 45 #include "tnl/t_context.h" 46 #include "tnl/t_pipeline.h" 47 #include "tnl/t_vertex.h" 48 49 #include "intel_screen.h" 50 #include "intel_context.h" 51 #include "intel_tris.h" 52 #include "intel_batchbuffer.h" 53 #include "intel_buffers.h" 54 #include "intel_reg.h" 55 #include "intel_span.h" 56 #include "i830_context.h" 57 #include "i830_reg.h" 58 #include "i915_context.h" 59 60 static void intelRenderPrimitive(struct gl_context * ctx, GLenum prim); 61 static void intelRasterPrimitive(struct gl_context * ctx, GLenum rprim, 62 GLuint hwprim); 63 64 static void 65 intel_flush_inline_primitive(struct intel_context *intel) 66 { 67 GLuint used = intel->batch.used - intel->prim.start_ptr; 68 69 assert(intel->prim.primitive != ~0); 70 71 /* printf("/\n"); */ 72 73 if (used < 2) 74 goto do_discard; 75 76 intel->batch.map[intel->prim.start_ptr] = 77 _3DPRIMITIVE | intel->prim.primitive | (used - 2); 78 79 goto finished; 80 81 do_discard: 82 intel->batch.used = intel->prim.start_ptr; 83 84 finished: 85 intel->prim.primitive = ~0; 86 intel->prim.start_ptr = 0; 87 intel->prim.flush = 0; 88 } 89 90 static void intel_start_inline(struct intel_context *intel, uint32_t prim) 91 { 92 BATCH_LOCALS; 93 94 intel->vtbl.emit_state(intel); 95 96 intel->no_batch_wrap = true; 97 98 /*printf("%s *", __progname);*/ 99 100 /* Emit a slot which will be filled with the inline primitive 101 * command later. 102 */ 103 BEGIN_BATCH(1); 104 105 intel->prim.start_ptr = intel->batch.used; 106 intel->prim.primitive = prim; 107 intel->prim.flush = intel_flush_inline_primitive; 108 109 OUT_BATCH(0); 110 ADVANCE_BATCH(); 111 112 intel->no_batch_wrap = false; 113 /* printf(">"); */ 114 } 115 116 static void intel_wrap_inline(struct intel_context *intel) 117 { 118 GLuint prim = intel->prim.primitive; 119 120 intel_flush_inline_primitive(intel); 121 intel_batchbuffer_flush(intel); 122 intel_start_inline(intel, prim); /* ??? */ 123 } 124 125 static GLuint *intel_extend_inline(struct intel_context *intel, GLuint dwords) 126 { 127 GLuint *ptr; 128 129 assert(intel->prim.flush == intel_flush_inline_primitive); 130 131 if (intel_batchbuffer_space(intel) < dwords * sizeof(GLuint)) 132 intel_wrap_inline(intel); 133 134 /* printf("."); */ 135 136 intel->vtbl.assert_not_dirty(intel); 137 138 ptr = intel->batch.map + intel->batch.used; 139 intel->batch.used += dwords; 140 141 return ptr; 142 } 143 144 /** Sets the primitive type for a primitive sequence, flushing as needed. */ 145 void intel_set_prim(struct intel_context *intel, uint32_t prim) 146 { 147 /* if we have no VBOs */ 148 149 if (intel->intelScreen->no_vbo) { 150 intel_start_inline(intel, prim); 151 return; 152 } 153 if (prim != intel->prim.primitive) { 154 INTEL_FIREVERTICES(intel); 155 intel->prim.primitive = prim; 156 } 157 } 158 159 /** Returns mapped VB space for the given number of vertices */ 160 uint32_t *intel_get_prim_space(struct intel_context *intel, unsigned int count) 161 { 162 uint32_t *addr; 163 164 if (intel->intelScreen->no_vbo) { 165 return intel_extend_inline(intel, count * intel->vertex_size); 166 } 167 168 /* Check for space in the existing VB */ 169 if (intel->prim.vb_bo == NULL || 170 (intel->prim.current_offset + 171 count * intel->vertex_size * 4) > INTEL_VB_SIZE || 172 (intel->prim.count + count) >= (1 << 16)) { 173 /* Flush existing prim if any */ 174 INTEL_FIREVERTICES(intel); 175 176 intel_finish_vb(intel); 177 178 /* Start a new VB */ 179 if (intel->prim.vb == NULL) 180 intel->prim.vb = malloc(INTEL_VB_SIZE); 181 intel->prim.vb_bo = drm_intel_bo_alloc(intel->bufmgr, "vb", 182 INTEL_VB_SIZE, 4); 183 intel->prim.start_offset = 0; 184 intel->prim.current_offset = 0; 185 } 186 187 intel->prim.flush = intel_flush_prim; 188 189 addr = (uint32_t *)(intel->prim.vb + intel->prim.current_offset); 190 intel->prim.current_offset += intel->vertex_size * 4 * count; 191 intel->prim.count += count; 192 193 return addr; 194 } 195 196 /** Dispatches the accumulated primitive to the batchbuffer. */ 197 void intel_flush_prim(struct intel_context *intel) 198 { 199 drm_intel_bo *aper_array[2]; 200 drm_intel_bo *vb_bo; 201 unsigned int offset, count; 202 BATCH_LOCALS; 203 204 /* Must be called after an intel_start_prim. */ 205 assert(intel->prim.primitive != ~0); 206 207 if (intel->prim.count == 0) 208 return; 209 210 /* Clear the current prims out of the context state so that a batch flush 211 * flush triggered by emit_state doesn't loop back to flush_prim again. 212 */ 213 vb_bo = intel->prim.vb_bo; 214 drm_intel_bo_reference(vb_bo); 215 count = intel->prim.count; 216 intel->prim.count = 0; 217 offset = intel->prim.start_offset; 218 intel->prim.start_offset = intel->prim.current_offset; 219 if (intel->gen < 3) 220 intel->prim.current_offset = intel->prim.start_offset = ALIGN(intel->prim.start_offset, 128); 221 intel->prim.flush = NULL; 222 223 intel->vtbl.emit_state(intel); 224 225 aper_array[0] = intel->batch.bo; 226 aper_array[1] = vb_bo; 227 if (dri_bufmgr_check_aperture_space(aper_array, 2)) { 228 intel_batchbuffer_flush(intel); 229 intel->vtbl.emit_state(intel); 230 } 231 232 /* Ensure that we don't start a new batch for the following emit, which 233 * depends on the state just emitted. emit_state should be making sure we 234 * have the space for this. 235 */ 236 intel->no_batch_wrap = true; 237 238 if (intel->always_flush_cache) { 239 intel_batchbuffer_emit_mi_flush(intel); 240 } 241 242 #if 0 243 printf("emitting %d..%d=%d vertices size %d\n", offset, 244 intel->prim.current_offset, count, 245 intel->vertex_size * 4); 246 #endif 247 248 if (intel->gen >= 3) { 249 struct i915_context *i915 = i915_context(&intel->ctx); 250 unsigned int cmd = 0, len = 0; 251 252 if (vb_bo != i915->current_vb_bo) { 253 cmd |= I1_LOAD_S(0); 254 len++; 255 } 256 257 if (intel->vertex_size != i915->current_vertex_size) { 258 cmd |= I1_LOAD_S(1); 259 len++; 260 } 261 if (len) 262 len++; 263 264 BEGIN_BATCH(2+len); 265 if (cmd) 266 OUT_BATCH(_3DSTATE_LOAD_STATE_IMMEDIATE_1 | cmd | (len - 2)); 267 if (vb_bo != i915->current_vb_bo) { 268 OUT_RELOC(vb_bo, I915_GEM_DOMAIN_VERTEX, 0, 0); 269 i915->current_vb_bo = vb_bo; 270 } 271 if (intel->vertex_size != i915->current_vertex_size) { 272 OUT_BATCH((intel->vertex_size << S1_VERTEX_WIDTH_SHIFT) | 273 (intel->vertex_size << S1_VERTEX_PITCH_SHIFT)); 274 i915->current_vertex_size = intel->vertex_size; 275 } 276 OUT_BATCH(_3DPRIMITIVE | 277 PRIM_INDIRECT | 278 PRIM_INDIRECT_SEQUENTIAL | 279 intel->prim.primitive | 280 count); 281 OUT_BATCH(offset / (intel->vertex_size * 4)); 282 ADVANCE_BATCH(); 283 } else { 284 struct i830_context *i830 = i830_context(&intel->ctx); 285 286 BEGIN_BATCH(5); 287 OUT_BATCH(_3DSTATE_LOAD_STATE_IMMEDIATE_1 | 288 I1_LOAD_S(0) | I1_LOAD_S(2) | 1); 289 /* S0 */ 290 assert((offset & ~S0_VB_OFFSET_MASK_830) == 0); 291 OUT_RELOC(vb_bo, I915_GEM_DOMAIN_VERTEX, 0, 292 offset | (intel->vertex_size << S0_VB_PITCH_SHIFT_830) | 293 S0_VB_ENABLE_830); 294 /* S2 295 * This is somewhat unfortunate -- VB width is tied up with 296 * vertex format data that we've already uploaded through 297 * _3DSTATE_VFT[01]_CMD. We may want to replace emits of VFT state with 298 * STATE_IMMEDIATE_1 like this to avoid duplication. 299 */ 300 OUT_BATCH((i830->state.Ctx[I830_CTXREG_VF] & VFT0_TEX_COUNT_MASK) >> 301 VFT0_TEX_COUNT_SHIFT << S2_TEX_COUNT_SHIFT_830 | 302 (i830->state.Ctx[I830_CTXREG_VF2] << 16) | 303 intel->vertex_size << S2_VERTEX_0_WIDTH_SHIFT_830); 304 305 OUT_BATCH(_3DPRIMITIVE | 306 PRIM_INDIRECT | 307 PRIM_INDIRECT_SEQUENTIAL | 308 intel->prim.primitive | 309 count); 310 OUT_BATCH(0); /* Beginning vertex index */ 311 ADVANCE_BATCH(); 312 } 313 314 if (intel->always_flush_cache) { 315 intel_batchbuffer_emit_mi_flush(intel); 316 } 317 318 intel->no_batch_wrap = false; 319 320 drm_intel_bo_unreference(vb_bo); 321 } 322 323 /** 324 * Uploads the locally-accumulated VB into the buffer object. 325 * 326 * This avoids us thrashing the cachelines in and out as the buffer gets 327 * filled, dispatched, then reused as the hardware completes rendering from it, 328 * and also lets us clflush less if we dispatch with a partially-filled VB. 329 * 330 * This is called normally from get_space when we're finishing a BO, but also 331 * at batch flush time so that we don't try accessing the contents of a 332 * just-dispatched buffer. 333 */ 334 void intel_finish_vb(struct intel_context *intel) 335 { 336 if (intel->prim.vb_bo == NULL) 337 return; 338 339 drm_intel_bo_subdata(intel->prim.vb_bo, 0, intel->prim.start_offset, 340 intel->prim.vb); 341 drm_intel_bo_unreference(intel->prim.vb_bo); 342 intel->prim.vb_bo = NULL; 343 } 344 345 /*********************************************************************** 346 * Emit primitives as inline vertices * 347 ***********************************************************************/ 348 349 #ifdef __i386__ 350 #define COPY_DWORDS( j, vb, vertsize, v ) \ 351 do { \ 352 int __tmp; \ 353 __asm__ __volatile__( "rep ; movsl" \ 354 : "=%c" (j), "=D" (vb), "=S" (__tmp) \ 355 : "0" (vertsize), \ 356 "D" ((long)vb), \ 357 "S" ((long)v) ); \ 358 } while (0) 359 #else 360 #define COPY_DWORDS( j, vb, vertsize, v ) \ 361 do { \ 362 for ( j = 0 ; j < vertsize ; j++ ) { \ 363 vb[j] = ((GLuint *)v)[j]; \ 364 } \ 365 vb += vertsize; \ 366 } while (0) 367 #endif 368 369 static void 370 intel_draw_quad(struct intel_context *intel, 371 intelVertexPtr v0, 372 intelVertexPtr v1, intelVertexPtr v2, intelVertexPtr v3) 373 { 374 GLuint vertsize = intel->vertex_size; 375 GLuint *vb = intel_get_prim_space(intel, 6); 376 int j; 377 378 COPY_DWORDS(j, vb, vertsize, v0); 379 COPY_DWORDS(j, vb, vertsize, v1); 380 381 /* If smooth shading, draw like a trifan which gives better 382 * rasterization. Otherwise draw as two triangles with provoking 383 * vertex in third position as required for flat shading. 384 */ 385 if (intel->ctx.Light.ShadeModel == GL_FLAT) { 386 COPY_DWORDS(j, vb, vertsize, v3); 387 COPY_DWORDS(j, vb, vertsize, v1); 388 } 389 else { 390 COPY_DWORDS(j, vb, vertsize, v2); 391 COPY_DWORDS(j, vb, vertsize, v0); 392 } 393 394 COPY_DWORDS(j, vb, vertsize, v2); 395 COPY_DWORDS(j, vb, vertsize, v3); 396 } 397 398 static void 399 intel_draw_triangle(struct intel_context *intel, 400 intelVertexPtr v0, intelVertexPtr v1, intelVertexPtr v2) 401 { 402 GLuint vertsize = intel->vertex_size; 403 GLuint *vb = intel_get_prim_space(intel, 3); 404 int j; 405 406 COPY_DWORDS(j, vb, vertsize, v0); 407 COPY_DWORDS(j, vb, vertsize, v1); 408 COPY_DWORDS(j, vb, vertsize, v2); 409 } 410 411 412 static void 413 intel_draw_line(struct intel_context *intel, 414 intelVertexPtr v0, intelVertexPtr v1) 415 { 416 GLuint vertsize = intel->vertex_size; 417 GLuint *vb = intel_get_prim_space(intel, 2); 418 int j; 419 420 COPY_DWORDS(j, vb, vertsize, v0); 421 COPY_DWORDS(j, vb, vertsize, v1); 422 } 423 424 425 static void 426 intel_draw_point(struct intel_context *intel, intelVertexPtr v0) 427 { 428 GLuint vertsize = intel->vertex_size; 429 GLuint *vb = intel_get_prim_space(intel, 1); 430 int j; 431 432 /* Adjust for sub pixel position -- still required for conform. */ 433 *(float *) &vb[0] = v0->v.x; 434 *(float *) &vb[1] = v0->v.y; 435 for (j = 2; j < vertsize; j++) 436 vb[j] = v0->ui[j]; 437 } 438 439 440 441 /*********************************************************************** 442 * Fixup for ARB_point_parameters * 443 ***********************************************************************/ 444 445 /* Currently not working - VERT_ATTRIB_POINTSIZE isn't correctly 446 * represented in the fragment program InputsRead field. 447 */ 448 static void 449 intel_atten_point(struct intel_context *intel, intelVertexPtr v0) 450 { 451 struct gl_context *ctx = &intel->ctx; 452 GLfloat psz[4], col[4], restore_psz, restore_alpha; 453 454 _tnl_get_attr(ctx, v0, _TNL_ATTRIB_POINTSIZE, psz); 455 _tnl_get_attr(ctx, v0, _TNL_ATTRIB_COLOR0, col); 456 457 restore_psz = psz[0]; 458 restore_alpha = col[3]; 459 460 if (psz[0] >= ctx->Point.Threshold) { 461 psz[0] = MIN2(psz[0], ctx->Point.MaxSize); 462 } 463 else { 464 GLfloat dsize = psz[0] / ctx->Point.Threshold; 465 psz[0] = MAX2(ctx->Point.Threshold, ctx->Point.MinSize); 466 col[3] *= dsize * dsize; 467 } 468 469 if (psz[0] < 1.0) 470 psz[0] = 1.0; 471 472 if (restore_psz != psz[0] || restore_alpha != col[3]) { 473 _tnl_set_attr(ctx, v0, _TNL_ATTRIB_POINTSIZE, psz); 474 _tnl_set_attr(ctx, v0, _TNL_ATTRIB_COLOR0, col); 475 476 intel_draw_point(intel, v0); 477 478 psz[0] = restore_psz; 479 col[3] = restore_alpha; 480 481 _tnl_set_attr(ctx, v0, _TNL_ATTRIB_POINTSIZE, psz); 482 _tnl_set_attr(ctx, v0, _TNL_ATTRIB_COLOR0, col); 483 } 484 else 485 intel_draw_point(intel, v0); 486 } 487 488 489 490 491 492 /*********************************************************************** 493 * Fixup for I915 WPOS texture coordinate * 494 ***********************************************************************/ 495 496 static void 497 intel_emit_fragcoord(struct intel_context *intel, intelVertexPtr v) 498 { 499 struct gl_context *ctx = &intel->ctx; 500 struct gl_framebuffer *fb = ctx->DrawBuffer; 501 GLuint offset = intel->wpos_offset; 502 float *vertex_position = (float *)v; 503 float *fragcoord = (float *)((char *)v + offset); 504 505 fragcoord[0] = vertex_position[0]; 506 507 if (_mesa_is_user_fbo(fb)) 508 fragcoord[1] = vertex_position[1]; 509 else 510 fragcoord[1] = fb->Height - vertex_position[1]; 511 512 fragcoord[2] = vertex_position[2]; 513 fragcoord[3] = vertex_position[3]; 514 } 515 516 static void 517 intel_wpos_triangle(struct intel_context *intel, 518 intelVertexPtr v0, intelVertexPtr v1, intelVertexPtr v2) 519 { 520 intel_emit_fragcoord(intel, v0); 521 intel_emit_fragcoord(intel, v1); 522 intel_emit_fragcoord(intel, v2); 523 524 intel_draw_triangle(intel, v0, v1, v2); 525 } 526 527 528 static void 529 intel_wpos_line(struct intel_context *intel, 530 intelVertexPtr v0, intelVertexPtr v1) 531 { 532 intel_emit_fragcoord(intel, v0); 533 intel_emit_fragcoord(intel, v1); 534 intel_draw_line(intel, v0, v1); 535 } 536 537 538 static void 539 intel_wpos_point(struct intel_context *intel, intelVertexPtr v0) 540 { 541 intel_emit_fragcoord(intel, v0); 542 intel_draw_point(intel, v0); 543 } 544 545 546 547 548 549 550 /*********************************************************************** 551 * Macros for t_dd_tritmp.h to draw basic primitives * 552 ***********************************************************************/ 553 554 #define TRI( a, b, c ) \ 555 do { \ 556 if (DO_FALLBACK) \ 557 intel->draw_tri( intel, a, b, c ); \ 558 else \ 559 intel_draw_triangle( intel, a, b, c ); \ 560 } while (0) 561 562 #define QUAD( a, b, c, d ) \ 563 do { \ 564 if (DO_FALLBACK) { \ 565 intel->draw_tri( intel, a, b, d ); \ 566 intel->draw_tri( intel, b, c, d ); \ 567 } else \ 568 intel_draw_quad( intel, a, b, c, d ); \ 569 } while (0) 570 571 #define LINE( v0, v1 ) \ 572 do { \ 573 if (DO_FALLBACK) \ 574 intel->draw_line( intel, v0, v1 ); \ 575 else \ 576 intel_draw_line( intel, v0, v1 ); \ 577 } while (0) 578 579 #define POINT( v0 ) \ 580 do { \ 581 if (DO_FALLBACK) \ 582 intel->draw_point( intel, v0 ); \ 583 else \ 584 intel_draw_point( intel, v0 ); \ 585 } while (0) 586 587 588 /*********************************************************************** 589 * Build render functions from dd templates * 590 ***********************************************************************/ 591 592 #define INTEL_OFFSET_BIT 0x01 593 #define INTEL_TWOSIDE_BIT 0x02 594 #define INTEL_UNFILLED_BIT 0x04 595 #define INTEL_FALLBACK_BIT 0x08 596 #define INTEL_MAX_TRIFUNC 0x10 597 598 599 static struct 600 { 601 tnl_points_func points; 602 tnl_line_func line; 603 tnl_triangle_func triangle; 604 tnl_quad_func quad; 605 } rast_tab[INTEL_MAX_TRIFUNC]; 606 607 608 #define DO_FALLBACK (IND & INTEL_FALLBACK_BIT) 609 #define DO_OFFSET (IND & INTEL_OFFSET_BIT) 610 #define DO_UNFILLED (IND & INTEL_UNFILLED_BIT) 611 #define DO_TWOSIDE (IND & INTEL_TWOSIDE_BIT) 612 #define DO_FLAT 0 613 #define DO_TRI 1 614 #define DO_QUAD 1 615 #define DO_LINE 1 616 #define DO_POINTS 1 617 #define DO_FULL_QUAD 1 618 619 #define HAVE_SPEC 1 620 #define HAVE_BACK_COLORS 0 621 #define HAVE_HW_FLATSHADE 1 622 #define VERTEX intelVertex 623 #define TAB rast_tab 624 625 /* Only used to pull back colors into vertices (ie, we know color is 626 * floating point). 627 */ 628 #define INTEL_COLOR( dst, src ) \ 629 do { \ 630 UNCLAMPED_FLOAT_TO_UBYTE((dst)[0], (src)[2]); \ 631 UNCLAMPED_FLOAT_TO_UBYTE((dst)[1], (src)[1]); \ 632 UNCLAMPED_FLOAT_TO_UBYTE((dst)[2], (src)[0]); \ 633 UNCLAMPED_FLOAT_TO_UBYTE((dst)[3], (src)[3]); \ 634 } while (0) 635 636 #define INTEL_SPEC( dst, src ) \ 637 do { \ 638 UNCLAMPED_FLOAT_TO_UBYTE((dst)[0], (src)[2]); \ 639 UNCLAMPED_FLOAT_TO_UBYTE((dst)[1], (src)[1]); \ 640 UNCLAMPED_FLOAT_TO_UBYTE((dst)[2], (src)[0]); \ 641 } while (0) 642 643 644 #define DEPTH_SCALE intel->polygon_offset_scale 645 #define UNFILLED_TRI unfilled_tri 646 #define UNFILLED_QUAD unfilled_quad 647 #define VERT_X(_v) _v->v.x 648 #define VERT_Y(_v) _v->v.y 649 #define VERT_Z(_v) _v->v.z 650 #define AREA_IS_CCW( a ) (a > 0) 651 #define GET_VERTEX(e) (intel->verts + (e * intel->vertex_size * sizeof(GLuint))) 652 653 #define VERT_SET_RGBA( v, c ) if (coloroffset) INTEL_COLOR( v->ub4[coloroffset], c ) 654 #define VERT_COPY_RGBA( v0, v1 ) if (coloroffset) v0->ui[coloroffset] = v1->ui[coloroffset] 655 #define VERT_SAVE_RGBA( idx ) if (coloroffset) color[idx] = v[idx]->ui[coloroffset] 656 #define VERT_RESTORE_RGBA( idx ) if (coloroffset) v[idx]->ui[coloroffset] = color[idx] 657 658 #define VERT_SET_SPEC( v, c ) if (specoffset) INTEL_SPEC( v->ub4[specoffset], c ) 659 #define VERT_COPY_SPEC( v0, v1 ) if (specoffset) COPY_3V(v0->ub4[specoffset], v1->ub4[specoffset]) 660 #define VERT_SAVE_SPEC( idx ) if (specoffset) spec[idx] = v[idx]->ui[specoffset] 661 #define VERT_RESTORE_SPEC( idx ) if (specoffset) v[idx]->ui[specoffset] = spec[idx] 662 663 #define LOCAL_VARS(n) \ 664 struct intel_context *intel = intel_context(ctx); \ 665 GLuint color[n] = { 0, }, spec[n] = { 0, }; \ 666 GLuint coloroffset = intel->coloroffset; \ 667 GLuint specoffset = intel->specoffset; \ 668 (void) color; (void) spec; (void) coloroffset; (void) specoffset; 669 670 671 /*********************************************************************** 672 * Helpers for rendering unfilled primitives * 673 ***********************************************************************/ 674 675 static const GLuint hw_prim[GL_POLYGON + 1] = { 676 PRIM3D_POINTLIST, 677 PRIM3D_LINELIST, 678 PRIM3D_LINELIST, 679 PRIM3D_LINELIST, 680 PRIM3D_TRILIST, 681 PRIM3D_TRILIST, 682 PRIM3D_TRILIST, 683 PRIM3D_TRILIST, 684 PRIM3D_TRILIST, 685 PRIM3D_TRILIST 686 }; 687 688 #define RASTERIZE(x) intelRasterPrimitive( ctx, x, hw_prim[x] ) 689 #define RENDER_PRIMITIVE intel->render_primitive 690 #define TAG(x) x 691 #define IND INTEL_FALLBACK_BIT 692 #include "tnl_dd/t_dd_unfilled.h" 693 #undef IND 694 695 /*********************************************************************** 696 * Generate GL render functions * 697 ***********************************************************************/ 698 699 #define IND (0) 700 #define TAG(x) x 701 #include "tnl_dd/t_dd_tritmp.h" 702 703 #define IND (INTEL_OFFSET_BIT) 704 #define TAG(x) x##_offset 705 #include "tnl_dd/t_dd_tritmp.h" 706 707 #define IND (INTEL_TWOSIDE_BIT) 708 #define TAG(x) x##_twoside 709 #include "tnl_dd/t_dd_tritmp.h" 710 711 #define IND (INTEL_TWOSIDE_BIT|INTEL_OFFSET_BIT) 712 #define TAG(x) x##_twoside_offset 713 #include "tnl_dd/t_dd_tritmp.h" 714 715 #define IND (INTEL_UNFILLED_BIT) 716 #define TAG(x) x##_unfilled 717 #include "tnl_dd/t_dd_tritmp.h" 718 719 #define IND (INTEL_OFFSET_BIT|INTEL_UNFILLED_BIT) 720 #define TAG(x) x##_offset_unfilled 721 #include "tnl_dd/t_dd_tritmp.h" 722 723 #define IND (INTEL_TWOSIDE_BIT|INTEL_UNFILLED_BIT) 724 #define TAG(x) x##_twoside_unfilled 725 #include "tnl_dd/t_dd_tritmp.h" 726 727 #define IND (INTEL_TWOSIDE_BIT|INTEL_OFFSET_BIT|INTEL_UNFILLED_BIT) 728 #define TAG(x) x##_twoside_offset_unfilled 729 #include "tnl_dd/t_dd_tritmp.h" 730 731 #define IND (INTEL_FALLBACK_BIT) 732 #define TAG(x) x##_fallback 733 #include "tnl_dd/t_dd_tritmp.h" 734 735 #define IND (INTEL_OFFSET_BIT|INTEL_FALLBACK_BIT) 736 #define TAG(x) x##_offset_fallback 737 #include "tnl_dd/t_dd_tritmp.h" 738 739 #define IND (INTEL_TWOSIDE_BIT|INTEL_FALLBACK_BIT) 740 #define TAG(x) x##_twoside_fallback 741 #include "tnl_dd/t_dd_tritmp.h" 742 743 #define IND (INTEL_TWOSIDE_BIT|INTEL_OFFSET_BIT|INTEL_FALLBACK_BIT) 744 #define TAG(x) x##_twoside_offset_fallback 745 #include "tnl_dd/t_dd_tritmp.h" 746 747 #define IND (INTEL_UNFILLED_BIT|INTEL_FALLBACK_BIT) 748 #define TAG(x) x##_unfilled_fallback 749 #include "tnl_dd/t_dd_tritmp.h" 750 751 #define IND (INTEL_OFFSET_BIT|INTEL_UNFILLED_BIT|INTEL_FALLBACK_BIT) 752 #define TAG(x) x##_offset_unfilled_fallback 753 #include "tnl_dd/t_dd_tritmp.h" 754 755 #define IND (INTEL_TWOSIDE_BIT|INTEL_UNFILLED_BIT|INTEL_FALLBACK_BIT) 756 #define TAG(x) x##_twoside_unfilled_fallback 757 #include "tnl_dd/t_dd_tritmp.h" 758 759 #define IND (INTEL_TWOSIDE_BIT|INTEL_OFFSET_BIT|INTEL_UNFILLED_BIT| \ 760 INTEL_FALLBACK_BIT) 761 #define TAG(x) x##_twoside_offset_unfilled_fallback 762 #include "tnl_dd/t_dd_tritmp.h" 763 764 765 static void 766 init_rast_tab(void) 767 { 768 init(); 769 init_offset(); 770 init_twoside(); 771 init_twoside_offset(); 772 init_unfilled(); 773 init_offset_unfilled(); 774 init_twoside_unfilled(); 775 init_twoside_offset_unfilled(); 776 init_fallback(); 777 init_offset_fallback(); 778 init_twoside_fallback(); 779 init_twoside_offset_fallback(); 780 init_unfilled_fallback(); 781 init_offset_unfilled_fallback(); 782 init_twoside_unfilled_fallback(); 783 init_twoside_offset_unfilled_fallback(); 784 } 785 786 787 /*********************************************************************** 788 * Rasterization fallback helpers * 789 ***********************************************************************/ 790 791 792 /* This code is hit only when a mix of accelerated and unaccelerated 793 * primitives are being drawn, and only for the unaccelerated 794 * primitives. 795 */ 796 static void 797 intel_fallback_tri(struct intel_context *intel, 798 intelVertex * v0, intelVertex * v1, intelVertex * v2) 799 { 800 struct gl_context *ctx = &intel->ctx; 801 SWvertex v[3]; 802 803 if (0) 804 fprintf(stderr, "\n%s\n", __FUNCTION__); 805 806 INTEL_FIREVERTICES(intel); 807 808 _swsetup_Translate(ctx, v0, &v[0]); 809 _swsetup_Translate(ctx, v1, &v[1]); 810 _swsetup_Translate(ctx, v2, &v[2]); 811 intelSpanRenderStart(ctx); 812 _swrast_Triangle(ctx, &v[0], &v[1], &v[2]); 813 intelSpanRenderFinish(ctx); 814 } 815 816 817 static void 818 intel_fallback_line(struct intel_context *intel, 819 intelVertex * v0, intelVertex * v1) 820 { 821 struct gl_context *ctx = &intel->ctx; 822 SWvertex v[2]; 823 824 if (0) 825 fprintf(stderr, "\n%s\n", __FUNCTION__); 826 827 INTEL_FIREVERTICES(intel); 828 829 _swsetup_Translate(ctx, v0, &v[0]); 830 _swsetup_Translate(ctx, v1, &v[1]); 831 intelSpanRenderStart(ctx); 832 _swrast_Line(ctx, &v[0], &v[1]); 833 intelSpanRenderFinish(ctx); 834 } 835 836 static void 837 intel_fallback_point(struct intel_context *intel, 838 intelVertex * v0) 839 { 840 struct gl_context *ctx = &intel->ctx; 841 SWvertex v[1]; 842 843 if (0) 844 fprintf(stderr, "\n%s\n", __FUNCTION__); 845 846 INTEL_FIREVERTICES(intel); 847 848 _swsetup_Translate(ctx, v0, &v[0]); 849 intelSpanRenderStart(ctx); 850 _swrast_Point(ctx, &v[0]); 851 intelSpanRenderFinish(ctx); 852 } 853 854 855 /**********************************************************************/ 856 /* Render unclipped begin/end objects */ 857 /**********************************************************************/ 858 859 #define IND 0 860 #define V(x) (intelVertex *)(vertptr + ((x)*vertsize*sizeof(GLuint))) 861 #define RENDER_POINTS( start, count ) \ 862 for ( ; start < count ; start++) POINT( V(ELT(start)) ); 863 #define RENDER_LINE( v0, v1 ) LINE( V(v0), V(v1) ) 864 #define RENDER_TRI( v0, v1, v2 ) TRI( V(v0), V(v1), V(v2) ) 865 #define RENDER_QUAD( v0, v1, v2, v3 ) QUAD( V(v0), V(v1), V(v2), V(v3) ) 866 #define INIT(x) intelRenderPrimitive( ctx, x ) 867 #undef LOCAL_VARS 868 #define LOCAL_VARS \ 869 struct intel_context *intel = intel_context(ctx); \ 870 GLubyte *vertptr = (GLubyte *)intel->verts; \ 871 const GLuint vertsize = intel->vertex_size; \ 872 const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts; \ 873 (void) elt; 874 #define RESET_STIPPLE 875 #define RESET_OCCLUSION 876 #define PRESERVE_VB_DEFS 877 #define ELT(x) x 878 #define TAG(x) intel_##x##_verts 879 #include "tnl/t_vb_rendertmp.h" 880 #undef ELT 881 #undef TAG 882 #define TAG(x) intel_##x##_elts 883 #define ELT(x) elt[x] 884 #include "tnl/t_vb_rendertmp.h" 885 886 /**********************************************************************/ 887 /* Render clipped primitives */ 888 /**********************************************************************/ 889 890 891 892 static void 893 intelRenderClippedPoly(struct gl_context * ctx, const GLuint * elts, GLuint n) 894 { 895 struct intel_context *intel = intel_context(ctx); 896 TNLcontext *tnl = TNL_CONTEXT(ctx); 897 struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; 898 GLuint prim = intel->render_primitive; 899 900 /* Render the new vertices as an unclipped polygon. 901 */ 902 { 903 GLuint *tmp = VB->Elts; 904 VB->Elts = (GLuint *) elts; 905 tnl->Driver.Render.PrimTabElts[GL_POLYGON] (ctx, 0, n, 906 PRIM_BEGIN | PRIM_END); 907 VB->Elts = tmp; 908 } 909 910 /* Restore the render primitive 911 */ 912 if (prim != GL_POLYGON) 913 tnl->Driver.Render.PrimitiveNotify(ctx, prim); 914 } 915 916 static void 917 intelRenderClippedLine(struct gl_context * ctx, GLuint ii, GLuint jj) 918 { 919 TNLcontext *tnl = TNL_CONTEXT(ctx); 920 921 tnl->Driver.Render.Line(ctx, ii, jj); 922 } 923 924 static void 925 intelFastRenderClippedPoly(struct gl_context * ctx, const GLuint * elts, GLuint n) 926 { 927 struct intel_context *intel = intel_context(ctx); 928 const GLuint vertsize = intel->vertex_size; 929 GLuint *vb = intel_get_prim_space(intel, (n - 2) * 3); 930 GLubyte *vertptr = (GLubyte *) intel->verts; 931 const GLuint *start = (const GLuint *) V(elts[0]); 932 int i, j; 933 934 for (i = 2; i < n; i++) { 935 COPY_DWORDS(j, vb, vertsize, V(elts[i - 1])); 936 COPY_DWORDS(j, vb, vertsize, V(elts[i])); 937 COPY_DWORDS(j, vb, vertsize, start); 938 } 939 } 940 941 /**********************************************************************/ 942 /* Choose render functions */ 943 /**********************************************************************/ 944 945 946 947 948 #define ANY_FALLBACK_FLAGS (DD_LINE_STIPPLE | DD_TRI_STIPPLE | DD_POINT_ATTEN) 949 #define ANY_RASTER_FLAGS (DD_TRI_LIGHT_TWOSIDE | DD_TRI_OFFSET | DD_TRI_UNFILLED) 950 951 void 952 intelChooseRenderState(struct gl_context * ctx) 953 { 954 TNLcontext *tnl = TNL_CONTEXT(ctx); 955 struct intel_context *intel = intel_context(ctx); 956 GLuint flags = ctx->_TriangleCaps; 957 const struct gl_fragment_program *fprog = ctx->FragmentProgram._Current; 958 bool have_wpos = (fprog && (fprog->Base.InputsRead & FRAG_BIT_WPOS)); 959 GLuint index = 0; 960 961 if (INTEL_DEBUG & DEBUG_STATE) 962 fprintf(stderr, "\n%s\n", __FUNCTION__); 963 964 if ((flags & (ANY_FALLBACK_FLAGS | ANY_RASTER_FLAGS)) || have_wpos) { 965 966 if (flags & ANY_RASTER_FLAGS) { 967 if (flags & DD_TRI_LIGHT_TWOSIDE) 968 index |= INTEL_TWOSIDE_BIT; 969 if (flags & DD_TRI_OFFSET) 970 index |= INTEL_OFFSET_BIT; 971 if (flags & DD_TRI_UNFILLED) 972 index |= INTEL_UNFILLED_BIT; 973 } 974 975 if (have_wpos) { 976 intel->draw_point = intel_wpos_point; 977 intel->draw_line = intel_wpos_line; 978 intel->draw_tri = intel_wpos_triangle; 979 980 /* Make sure these get called: 981 */ 982 index |= INTEL_FALLBACK_BIT; 983 } 984 else { 985 intel->draw_point = intel_draw_point; 986 intel->draw_line = intel_draw_line; 987 intel->draw_tri = intel_draw_triangle; 988 } 989 990 /* Hook in fallbacks for specific primitives. 991 */ 992 if (flags & ANY_FALLBACK_FLAGS) { 993 if (flags & DD_LINE_STIPPLE) 994 intel->draw_line = intel_fallback_line; 995 996 if ((flags & DD_TRI_STIPPLE) && !intel->hw_stipple) 997 intel->draw_tri = intel_fallback_tri; 998 999 if (flags & DD_POINT_ATTEN) { 1000 if (0) 1001 intel->draw_point = intel_atten_point; 1002 else 1003 intel->draw_point = intel_fallback_point; 1004 } 1005 1006 index |= INTEL_FALLBACK_BIT; 1007 } 1008 } 1009 1010 if (intel->RenderIndex != index) { 1011 intel->RenderIndex = index; 1012 1013 tnl->Driver.Render.Points = rast_tab[index].points; 1014 tnl->Driver.Render.Line = rast_tab[index].line; 1015 tnl->Driver.Render.Triangle = rast_tab[index].triangle; 1016 tnl->Driver.Render.Quad = rast_tab[index].quad; 1017 1018 if (index == 0) { 1019 tnl->Driver.Render.PrimTabVerts = intel_render_tab_verts; 1020 tnl->Driver.Render.PrimTabElts = intel_render_tab_elts; 1021 tnl->Driver.Render.ClippedLine = line; /* from tritmp.h */ 1022 tnl->Driver.Render.ClippedPolygon = intelFastRenderClippedPoly; 1023 } 1024 else { 1025 tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts; 1026 tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts; 1027 tnl->Driver.Render.ClippedLine = intelRenderClippedLine; 1028 tnl->Driver.Render.ClippedPolygon = intelRenderClippedPoly; 1029 } 1030 } 1031 } 1032 1033 static const GLenum reduced_prim[GL_POLYGON + 1] = { 1034 GL_POINTS, 1035 GL_LINES, 1036 GL_LINES, 1037 GL_LINES, 1038 GL_TRIANGLES, 1039 GL_TRIANGLES, 1040 GL_TRIANGLES, 1041 GL_TRIANGLES, 1042 GL_TRIANGLES, 1043 GL_TRIANGLES 1044 }; 1045 1046 1047 /**********************************************************************/ 1048 /* High level hooks for t_vb_render.c */ 1049 /**********************************************************************/ 1050 1051 1052 1053 1054 static void 1055 intelRunPipeline(struct gl_context * ctx) 1056 { 1057 struct intel_context *intel = intel_context(ctx); 1058 1059 _mesa_lock_context_textures(ctx); 1060 1061 if (ctx->NewState) 1062 _mesa_update_state_locked(ctx); 1063 1064 /* We need to get this done before we start the pipeline, or a 1065 * change in the INTEL_FALLBACK() of its intel_draw_buffers() call 1066 * while the pipeline is running will result in mismatched swrast 1067 * map/unmaps, and later assertion failures. 1068 */ 1069 intel_prepare_render(intel); 1070 1071 if (intel->NewGLState) { 1072 if (intel->NewGLState & _NEW_TEXTURE) { 1073 intel->vtbl.update_texture_state(intel); 1074 } 1075 1076 if (!intel->Fallback) { 1077 if (intel->NewGLState & _INTEL_NEW_RENDERSTATE) 1078 intelChooseRenderState(ctx); 1079 } 1080 1081 intel->NewGLState = 0; 1082 } 1083 1084 intel_map_vertex_shader_textures(ctx); 1085 intel->tnl_pipeline_running = true; 1086 _tnl_run_pipeline(ctx); 1087 intel->tnl_pipeline_running = false; 1088 intel_unmap_vertex_shader_textures(ctx); 1089 1090 _mesa_unlock_context_textures(ctx); 1091 } 1092 1093 static void 1094 intelRenderStart(struct gl_context * ctx) 1095 { 1096 struct intel_context *intel = intel_context(ctx); 1097 1098 intel_check_front_buffer_rendering(intel); 1099 intel->vtbl.render_start(intel_context(ctx)); 1100 intel->vtbl.emit_state(intel); 1101 } 1102 1103 static void 1104 intelRenderFinish(struct gl_context * ctx) 1105 { 1106 struct intel_context *intel = intel_context(ctx); 1107 1108 if (intel->RenderIndex & INTEL_FALLBACK_BIT) 1109 _swrast_flush(ctx); 1110 1111 INTEL_FIREVERTICES(intel); 1112 } 1113 1114 1115 1116 1117 /* System to flush dma and emit state changes based on the rasterized 1118 * primitive. 1119 */ 1120 static void 1121 intelRasterPrimitive(struct gl_context * ctx, GLenum rprim, GLuint hwprim) 1122 { 1123 struct intel_context *intel = intel_context(ctx); 1124 1125 if (0) 1126 fprintf(stderr, "%s %s %x\n", __FUNCTION__, 1127 _mesa_lookup_enum_by_nr(rprim), hwprim); 1128 1129 intel->vtbl.reduced_primitive_state(intel, rprim); 1130 1131 /* Start a new primitive. Arrange to have it flushed later on. 1132 */ 1133 if (hwprim != intel->prim.primitive) { 1134 INTEL_FIREVERTICES(intel); 1135 1136 intel_set_prim(intel, hwprim); 1137 } 1138 } 1139 1140 1141 /* 1142 */ 1143 static void 1144 intelRenderPrimitive(struct gl_context * ctx, GLenum prim) 1145 { 1146 struct intel_context *intel = intel_context(ctx); 1147 1148 if (0) 1149 fprintf(stderr, "%s %s\n", __FUNCTION__, _mesa_lookup_enum_by_nr(prim)); 1150 1151 /* Let some clipping routines know which primitive they're dealing 1152 * with. 1153 */ 1154 intel->render_primitive = prim; 1155 1156 /* Shortcircuit this when called for unfilled triangles. The rasterized 1157 * primitive will always be reset by lower level functions in that case, 1158 * potentially pingponging the state: 1159 */ 1160 if (reduced_prim[prim] == GL_TRIANGLES && 1161 (ctx->_TriangleCaps & DD_TRI_UNFILLED)) 1162 return; 1163 1164 /* Set some primitive-dependent state and Start? a new primitive. 1165 */ 1166 intelRasterPrimitive(ctx, reduced_prim[prim], hw_prim[prim]); 1167 } 1168 1169 1170 /**********************************************************************/ 1171 /* Transition to/from hardware rasterization. */ 1172 /**********************************************************************/ 1173 1174 static char *fallbackStrings[] = { 1175 [0] = "Draw buffer", 1176 [1] = "Read buffer", 1177 [2] = "Depth buffer", 1178 [3] = "Stencil buffer", 1179 [4] = "User disable", 1180 [5] = "Render mode", 1181 1182 [12] = "Texture", 1183 [13] = "Color mask", 1184 [14] = "Stencil", 1185 [15] = "Stipple", 1186 [16] = "Program", 1187 [17] = "Logic op", 1188 [18] = "Smooth polygon", 1189 [19] = "Smooth point", 1190 [20] = "point sprite coord origin", 1191 [21] = "depth/color drawing offset", 1192 [22] = "coord replace(SPRITE POINT ENABLE)", 1193 }; 1194 1195 1196 static char * 1197 getFallbackString(GLuint bit) 1198 { 1199 int i = 0; 1200 while (bit > 1) { 1201 i++; 1202 bit >>= 1; 1203 } 1204 return fallbackStrings[i]; 1205 } 1206 1207 1208 1209 /** 1210 * Enable/disable a fallback flag. 1211 * \param bit one of INTEL_FALLBACK_x flags. 1212 */ 1213 void 1214 intelFallback(struct intel_context *intel, GLbitfield bit, bool mode) 1215 { 1216 struct gl_context *ctx = &intel->ctx; 1217 TNLcontext *tnl = TNL_CONTEXT(ctx); 1218 const GLbitfield oldfallback = intel->Fallback; 1219 1220 if (mode) { 1221 intel->Fallback |= bit; 1222 if (oldfallback == 0) { 1223 assert(!intel->tnl_pipeline_running); 1224 1225 intel_flush(ctx); 1226 if (INTEL_DEBUG & DEBUG_PERF) 1227 fprintf(stderr, "ENTER FALLBACK %x: %s\n", 1228 bit, getFallbackString(bit)); 1229 _swsetup_Wakeup(ctx); 1230 intel->RenderIndex = ~0; 1231 } 1232 } 1233 else { 1234 intel->Fallback &= ~bit; 1235 if (oldfallback == bit) { 1236 assert(!intel->tnl_pipeline_running); 1237 1238 _swrast_flush(ctx); 1239 if (INTEL_DEBUG & DEBUG_PERF) 1240 fprintf(stderr, "LEAVE FALLBACK %s\n", getFallbackString(bit)); 1241 tnl->Driver.Render.Start = intelRenderStart; 1242 tnl->Driver.Render.PrimitiveNotify = intelRenderPrimitive; 1243 tnl->Driver.Render.Finish = intelRenderFinish; 1244 tnl->Driver.Render.BuildVertices = _tnl_build_vertices; 1245 tnl->Driver.Render.CopyPV = _tnl_copy_pv; 1246 tnl->Driver.Render.Interp = _tnl_interp; 1247 1248 _tnl_invalidate_vertex_state(ctx, ~0); 1249 _tnl_invalidate_vertices(ctx, ~0); 1250 _tnl_install_attrs(ctx, 1251 intel->vertex_attrs, 1252 intel->vertex_attr_count, 1253 intel->ViewportMatrix.m, 0); 1254 1255 intel->NewGLState |= _INTEL_NEW_RENDERSTATE; 1256 } 1257 } 1258 } 1259 1260 union fi 1261 { 1262 GLfloat f; 1263 GLint i; 1264 }; 1265 1266 /**********************************************************************/ 1267 /* Initialization. */ 1268 /**********************************************************************/ 1269 1270 1271 void 1272 intelInitTriFuncs(struct gl_context * ctx) 1273 { 1274 TNLcontext *tnl = TNL_CONTEXT(ctx); 1275 static int firsttime = 1; 1276 1277 if (firsttime) { 1278 init_rast_tab(); 1279 firsttime = 0; 1280 } 1281 1282 tnl->Driver.RunPipeline = intelRunPipeline; 1283 tnl->Driver.Render.Start = intelRenderStart; 1284 tnl->Driver.Render.Finish = intelRenderFinish; 1285 tnl->Driver.Render.PrimitiveNotify = intelRenderPrimitive; 1286 tnl->Driver.Render.ResetLineStipple = _swrast_ResetLineStipple; 1287 tnl->Driver.Render.BuildVertices = _tnl_build_vertices; 1288 tnl->Driver.Render.CopyPV = _tnl_copy_pv; 1289 tnl->Driver.Render.Interp = _tnl_interp; 1290 } 1291
