![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to r_draw.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quakeworld / client|
Return to r_draw.c CVS log | Up to [Quake] / quakeworld / client |
1.1 ! root 1: /* ! 2: Copyright (C) 1996-1997 Id Software, Inc. ! 3: ! 4: This program is free software; you can redistribute it and/or ! 5: modify it under the terms of the GNU General Public License ! 6: as published by the Free Software Foundation; either version 2 ! 7: of the License, or (at your option) any later version. ! 8: ! 9: This program is distributed in the hope that it will be useful, ! 10: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ! 12: ! 13: See the GNU General Public License for more details. ! 14: ! 15: You should have received a copy of the GNU General Public License ! 16: along with this program; if not, write to the Free Software ! 17: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ! 18: ! 19: */ ! 20: ! 21: // r_draw.c ! 22: ! 23: #include "quakedef.h" ! 24: #include "r_local.h" ! 25: #include "d_local.h" // FIXME: shouldn't need to include this ! 26: ! 27: #define MAXLEFTCLIPEDGES 100 ! 28: ! 29: // !!! if these are changed, they must be changed in asm_draw.h too !!! ! 30: #define FULLY_CLIPPED_CACHED 0x80000000 ! 31: #define FRAMECOUNT_MASK 0x7FFFFFFF ! 32: ! 33: unsigned int cacheoffset; ! 34: ! 35: int c_faceclip; // number of faces clipped ! 36: ! 37: zpointdesc_t r_zpointdesc; ! 38: ! 39: polydesc_t r_polydesc; ! 40: ! 41: ! 42: ! 43: clipplane_t *entity_clipplanes; ! 44: clipplane_t view_clipplanes[4]; ! 45: clipplane_t world_clipplanes[16]; ! 46: ! 47: medge_t *r_pedge; ! 48: ! 49: qboolean r_leftclipped, r_rightclipped; ! 50: static qboolean makeleftedge, makerightedge; ! 51: qboolean r_nearzionly; ! 52: ! 53: int sintable[1280]; ! 54: int intsintable[1280]; ! 55: ! 56: mvertex_t r_leftenter, r_leftexit; ! 57: mvertex_t r_rightenter, r_rightexit; ! 58: ! 59: typedef struct ! 60: { ! 61: float u,v; ! 62: int ceilv; ! 63: } evert_t; ! 64: ! 65: int r_emitted; ! 66: float r_nearzi; ! 67: float r_u1, r_v1, r_lzi1; ! 68: int r_ceilv1; ! 69: ! 70: qboolean r_lastvertvalid; ! 71: ! 72: ! 73: #if !id386 ! 74: ! 75: /* ! 76: ================ ! 77: R_EmitEdge ! 78: ================ ! 79: */ ! 80: void R_EmitEdge (mvertex_t *pv0, mvertex_t *pv1) ! 81: { ! 82: edge_t *edge, *pcheck; ! 83: int u_check; ! 84: float u, u_step; ! 85: vec3_t local, transformed; ! 86: float *world; ! 87: int v, v2, ceilv0; ! 88: float scale, lzi0, u0, v0; ! 89: int side; ! 90: ! 91: if (r_lastvertvalid) ! 92: { ! 93: u0 = r_u1; ! 94: v0 = r_v1; ! 95: lzi0 = r_lzi1; ! 96: ceilv0 = r_ceilv1; ! 97: } ! 98: else ! 99: { ! 100: world = &pv0->position[0]; ! 101: ! 102: // transform and project ! 103: VectorSubtract (world, modelorg, local); ! 104: TransformVector (local, transformed); ! 105: ! 106: if (transformed[2] < NEAR_CLIP) ! 107: transformed[2] = NEAR_CLIP; ! 108: ! 109: lzi0 = 1.0 / transformed[2]; ! 110: ! 111: // FIXME: build x/yscale into transform? ! 112: scale = xscale * lzi0; ! 113: u0 = (xcenter + scale*transformed[0]); ! 114: if (u0 < r_refdef.fvrectx_adj) ! 115: u0 = r_refdef.fvrectx_adj; ! 116: if (u0 > r_refdef.fvrectright_adj) ! 117: u0 = r_refdef.fvrectright_adj; ! 118: ! 119: scale = yscale * lzi0; ! 120: v0 = (ycenter - scale*transformed[1]); ! 121: if (v0 < r_refdef.fvrecty_adj) ! 122: v0 = r_refdef.fvrecty_adj; ! 123: if (v0 > r_refdef.fvrectbottom_adj) ! 124: v0 = r_refdef.fvrectbottom_adj; ! 125: ! 126: ceilv0 = (int) ceil(v0); ! 127: } ! 128: ! 129: world = &pv1->position[0]; ! 130: ! 131: // transform and project ! 132: VectorSubtract (world, modelorg, local); ! 133: TransformVector (local, transformed); ! 134: ! 135: if (transformed[2] < NEAR_CLIP) ! 136: transformed[2] = NEAR_CLIP; ! 137: ! 138: r_lzi1 = 1.0 / transformed[2]; ! 139: ! 140: scale = xscale * r_lzi1; ! 141: r_u1 = (xcenter + scale*transformed[0]); ! 142: if (r_u1 < r_refdef.fvrectx_adj) ! 143: r_u1 = r_refdef.fvrectx_adj; ! 144: if (r_u1 > r_refdef.fvrectright_adj) ! 145: r_u1 = r_refdef.fvrectright_adj; ! 146: ! 147: scale = yscale * r_lzi1; ! 148: r_v1 = (ycenter - scale*transformed[1]); ! 149: if (r_v1 < r_refdef.fvrecty_adj) ! 150: r_v1 = r_refdef.fvrecty_adj; ! 151: if (r_v1 > r_refdef.fvrectbottom_adj) ! 152: r_v1 = r_refdef.fvrectbottom_adj; ! 153: ! 154: if (r_lzi1 > lzi0) ! 155: lzi0 = r_lzi1; ! 156: ! 157: if (lzi0 > r_nearzi) // for mipmap finding ! 158: r_nearzi = lzi0; ! 159: ! 160: // for right edges, all we want is the effect on 1/z ! 161: if (r_nearzionly) ! 162: return; ! 163: ! 164: r_emitted = 1; ! 165: ! 166: r_ceilv1 = (int) ceil(r_v1); ! 167: ! 168: ! 169: // create the edge ! 170: if (ceilv0 == r_ceilv1) ! 171: { ! 172: // we cache unclipped horizontal edges as fully clipped ! 173: if (cacheoffset != 0x7FFFFFFF) ! 174: { ! 175: cacheoffset = FULLY_CLIPPED_CACHED | ! 176: (r_framecount & FRAMECOUNT_MASK); ! 177: } ! 178: ! 179: return; // horizontal edge ! 180: } ! 181: ! 182: side = ceilv0 > r_ceilv1; ! 183: ! 184: edge = edge_p++; ! 185: ! 186: edge->owner = r_pedge; ! 187: ! 188: edge->nearzi = lzi0; ! 189: ! 190: if (side == 0) ! 191: { ! 192: // trailing edge (go from p1 to p2) ! 193: v = ceilv0; ! 194: v2 = r_ceilv1 - 1; ! 195: ! 196: edge->surfs[0] = surface_p - surfaces; ! 197: edge->surfs[1] = 0; ! 198: ! 199: u_step = ((r_u1 - u0) / (r_v1 - v0)); ! 200: u = u0 + ((float)v - v0) * u_step; ! 201: } ! 202: else ! 203: { ! 204: // leading edge (go from p2 to p1) ! 205: v2 = ceilv0 - 1; ! 206: v = r_ceilv1; ! 207: ! 208: edge->surfs[0] = 0; ! 209: edge->surfs[1] = surface_p - surfaces; ! 210: ! 211: u_step = ((u0 - r_u1) / (v0 - r_v1)); ! 212: u = r_u1 + ((float)v - r_v1) * u_step; ! 213: } ! 214: ! 215: edge->u_step = u_step*0x100000; ! 216: edge->u = u*0x100000 + 0xFFFFF; ! 217: ! 218: // we need to do this to avoid stepping off the edges if a very nearly ! 219: // horizontal edge is less than epsilon above a scan, and numeric error causes ! 220: // it to incorrectly extend to the scan, and the extension of the line goes off ! 221: // the edge of the screen ! 222: // FIXME: is this actually needed? ! 223: if (edge->u < r_refdef.vrect_x_adj_shift20) ! 224: edge->u = r_refdef.vrect_x_adj_shift20; ! 225: if (edge->u > r_refdef.vrectright_adj_shift20) ! 226: edge->u = r_refdef.vrectright_adj_shift20; ! 227: ! 228: // ! 229: // sort the edge in normally ! 230: // ! 231: u_check = edge->u; ! 232: if (edge->surfs[0]) ! 233: u_check++; // sort trailers after leaders ! 234: ! 235: if (!newedges[v] || newedges[v]->u >= u_check) ! 236: { ! 237: edge->next = newedges[v]; ! 238: newedges[v] = edge; ! 239: } ! 240: else ! 241: { ! 242: pcheck = newedges[v]; ! 243: while (pcheck->next && pcheck->next->u < u_check) ! 244: pcheck = pcheck->next; ! 245: edge->next = pcheck->next; ! 246: pcheck->next = edge; ! 247: } ! 248: ! 249: edge->nextremove = removeedges[v2]; ! 250: removeedges[v2] = edge; ! 251: } ! 252: ! 253: ! 254: /* ! 255: ================ ! 256: R_ClipEdge ! 257: ================ ! 258: */ ! 259: void R_ClipEdge (mvertex_t *pv0, mvertex_t *pv1, clipplane_t *clip) ! 260: { ! 261: float d0, d1, f; ! 262: mvertex_t clipvert; ! 263: ! 264: if (clip) ! 265: { ! 266: do ! 267: { ! 268: d0 = DotProduct (pv0->position, clip->normal) - clip->dist; ! 269: d1 = DotProduct (pv1->position, clip->normal) - clip->dist; ! 270: ! 271: if (d0 >= 0) ! 272: { ! 273: // point 0 is unclipped ! 274: if (d1 >= 0) ! 275: { ! 276: // both points are unclipped ! 277: continue; ! 278: } ! 279: ! 280: // only point 1 is clipped ! 281: ! 282: // we don't cache clipped edges ! 283: cacheoffset = 0x7FFFFFFF; ! 284: ! 285: f = d0 / (d0 - d1); ! 286: clipvert.position[0] = pv0->position[0] + ! 287: f * (pv1->position[0] - pv0->position[0]); ! 288: clipvert.position[1] = pv0->position[1] + ! 289: f * (pv1->position[1] - pv0->position[1]); ! 290: clipvert.position[2] = pv0->position[2] + ! 291: f * (pv1->position[2] - pv0->position[2]); ! 292: ! 293: if (clip->leftedge) ! 294: { ! 295: r_leftclipped = true; ! 296: r_leftexit = clipvert; ! 297: } ! 298: else if (clip->rightedge) ! 299: { ! 300: r_rightclipped = true; ! 301: r_rightexit = clipvert; ! 302: } ! 303: ! 304: R_ClipEdge (pv0, &clipvert, clip->next); ! 305: return; ! 306: } ! 307: else ! 308: { ! 309: // point 0 is clipped ! 310: if (d1 < 0) ! 311: { ! 312: // both points are clipped ! 313: // we do cache fully clipped edges ! 314: if (!r_leftclipped) ! 315: cacheoffset = FULLY_CLIPPED_CACHED | ! 316: (r_framecount & FRAMECOUNT_MASK); ! 317: return; ! 318: } ! 319: ! 320: // only point 0 is clipped ! 321: r_lastvertvalid = false; ! 322: ! 323: // we don't cache partially clipped edges ! 324: cacheoffset = 0x7FFFFFFF; ! 325: ! 326: f = d0 / (d0 - d1); ! 327: clipvert.position[0] = pv0->position[0] + ! 328: f * (pv1->position[0] - pv0->position[0]); ! 329: clipvert.position[1] = pv0->position[1] + ! 330: f * (pv1->position[1] - pv0->position[1]); ! 331: clipvert.position[2] = pv0->position[2] + ! 332: f * (pv1->position[2] - pv0->position[2]); ! 333: ! 334: if (clip->leftedge) ! 335: { ! 336: r_leftclipped = true; ! 337: r_leftenter = clipvert; ! 338: } ! 339: else if (clip->rightedge) ! 340: { ! 341: r_rightclipped = true; ! 342: r_rightenter = clipvert; ! 343: } ! 344: ! 345: R_ClipEdge (&clipvert, pv1, clip->next); ! 346: return; ! 347: } ! 348: } while ((clip = clip->next) != NULL); ! 349: } ! 350: ! 351: // add the edge ! 352: R_EmitEdge (pv0, pv1); ! 353: } ! 354: ! 355: #endif // !id386 ! 356: ! 357: ! 358: /* ! 359: ================ ! 360: R_EmitCachedEdge ! 361: ================ ! 362: */ ! 363: void R_EmitCachedEdge (void) ! 364: { ! 365: edge_t *pedge_t; ! 366: ! 367: pedge_t = (edge_t *)((unsigned long)r_edges + r_pedge->cachededgeoffset); ! 368: ! 369: if (!pedge_t->surfs[0]) ! 370: pedge_t->surfs[0] = surface_p - surfaces; ! 371: else ! 372: pedge_t->surfs[1] = surface_p - surfaces; ! 373: ! 374: if (pedge_t->nearzi > r_nearzi) // for mipmap finding ! 375: r_nearzi = pedge_t->nearzi; ! 376: ! 377: r_emitted = 1; ! 378: } ! 379: ! 380: ! 381: /* ! 382: ================ ! 383: R_RenderFace ! 384: ================ ! 385: */ ! 386: void R_RenderFace (msurface_t *fa, int clipflags) ! 387: { ! 388: int i, lindex; ! 389: unsigned mask; ! 390: mplane_t *pplane; ! 391: float distinv; ! 392: vec3_t p_normal; ! 393: medge_t *pedges, tedge; ! 394: clipplane_t *pclip; ! 395: ! 396: // skip out if no more surfs ! 397: if ((surface_p) >= surf_max) ! 398: { ! 399: r_outofsurfaces++; ! 400: return; ! 401: } ! 402: ! 403: // ditto if not enough edges left, or switch to auxedges if possible ! 404: if ((edge_p + fa->numedges + 4) >= edge_max) ! 405: { ! 406: r_outofedges += fa->numedges; ! 407: return; ! 408: } ! 409: ! 410: c_faceclip++; ! 411: ! 412: // set up clip planes ! 413: pclip = NULL; ! 414: ! 415: for (i=3, mask = 0x08 ; i>=0 ; i--, mask >>= 1) ! 416: { ! 417: if (clipflags & mask) ! 418: { ! 419: view_clipplanes[i].next = pclip; ! 420: pclip = &view_clipplanes[i]; ! 421: } ! 422: } ! 423: ! 424: // push the edges through ! 425: r_emitted = 0; ! 426: r_nearzi = 0; ! 427: r_nearzionly = false; ! 428: makeleftedge = makerightedge = false; ! 429: pedges = currententity->model->edges; ! 430: r_lastvertvalid = false; ! 431: ! 432: for (i=0 ; i<fa->numedges ; i++) ! 433: { ! 434: lindex = currententity->model->surfedges[fa->firstedge + i]; ! 435: ! 436: if (lindex > 0) ! 437: { ! 438: r_pedge = &pedges[lindex]; ! 439: ! 440: // if the edge is cached, we can just reuse the edge ! 441: if (!insubmodel) ! 442: { ! 443: if (r_pedge->cachededgeoffset & FULLY_CLIPPED_CACHED) ! 444: { ! 445: if ((r_pedge->cachededgeoffset & FRAMECOUNT_MASK) == ! 446: r_framecount) ! 447: { ! 448: r_lastvertvalid = false; ! 449: continue; ! 450: } ! 451: } ! 452: else ! 453: { ! 454: if ((((unsigned long)edge_p - (unsigned long)r_edges) > ! 455: r_pedge->cachededgeoffset) && ! 456: (((edge_t *)((unsigned long)r_edges + ! 457: r_pedge->cachededgeoffset))->owner == r_pedge)) ! 458: { ! 459: R_EmitCachedEdge (); ! 460: r_lastvertvalid = false; ! 461: continue; ! 462: } ! 463: } ! 464: } ! 465: ! 466: // assume it's cacheable ! 467: cacheoffset = (byte *)edge_p - (byte *)r_edges; ! 468: r_leftclipped = r_rightclipped = false; ! 469: R_ClipEdge (&r_pcurrentvertbase[r_pedge->v[0]], ! 470: &r_pcurrentvertbase[r_pedge->v[1]], ! 471: pclip); ! 472: r_pedge->cachededgeoffset = cacheoffset; ! 473: ! 474: if (r_leftclipped) ! 475: makeleftedge = true; ! 476: if (r_rightclipped) ! 477: makerightedge = true; ! 478: r_lastvertvalid = true; ! 479: } ! 480: else ! 481: { ! 482: lindex = -lindex; ! 483: r_pedge = &pedges[lindex]; ! 484: // if the edge is cached, we can just reuse the edge ! 485: if (!insubmodel) ! 486: { ! 487: if (r_pedge->cachededgeoffset & FULLY_CLIPPED_CACHED) ! 488: { ! 489: if ((r_pedge->cachededgeoffset & FRAMECOUNT_MASK) == ! 490: r_framecount) ! 491: { ! 492: r_lastvertvalid = false; ! 493: continue; ! 494: } ! 495: } ! 496: else ! 497: { ! 498: // it's cached if the cached edge is valid and is owned ! 499: // by this medge_t ! 500: if ((((unsigned long)edge_p - (unsigned long)r_edges) > ! 501: r_pedge->cachededgeoffset) && ! 502: (((edge_t *)((unsigned long)r_edges + ! 503: r_pedge->cachededgeoffset))->owner == r_pedge)) ! 504: { ! 505: R_EmitCachedEdge (); ! 506: r_lastvertvalid = false; ! 507: continue; ! 508: } ! 509: } ! 510: } ! 511: ! 512: // assume it's cacheable ! 513: cacheoffset = (byte *)edge_p - (byte *)r_edges; ! 514: r_leftclipped = r_rightclipped = false; ! 515: R_ClipEdge (&r_pcurrentvertbase[r_pedge->v[1]], ! 516: &r_pcurrentvertbase[r_pedge->v[0]], ! 517: pclip); ! 518: r_pedge->cachededgeoffset = cacheoffset; ! 519: ! 520: if (r_leftclipped) ! 521: makeleftedge = true; ! 522: if (r_rightclipped) ! 523: makerightedge = true; ! 524: r_lastvertvalid = true; ! 525: } ! 526: } ! 527: ! 528: // if there was a clip off the left edge, add that edge too ! 529: // FIXME: faster to do in screen space? ! 530: // FIXME: share clipped edges? ! 531: if (makeleftedge) ! 532: { ! 533: r_pedge = &tedge; ! 534: r_lastvertvalid = false; ! 535: R_ClipEdge (&r_leftexit, &r_leftenter, pclip->next); ! 536: } ! 537: ! 538: // if there was a clip off the right edge, get the right r_nearzi ! 539: if (makerightedge) ! 540: { ! 541: r_pedge = &tedge; ! 542: r_lastvertvalid = false; ! 543: r_nearzionly = true; ! 544: R_ClipEdge (&r_rightexit, &r_rightenter, view_clipplanes[1].next); ! 545: } ! 546: ! 547: // if no edges made it out, return without posting the surface ! 548: if (!r_emitted) ! 549: return; ! 550: ! 551: r_polycount++; ! 552: ! 553: surface_p->data = (void *)fa; ! 554: surface_p->nearzi = r_nearzi; ! 555: surface_p->flags = fa->flags; ! 556: surface_p->insubmodel = insubmodel; ! 557: surface_p->spanstate = 0; ! 558: surface_p->entity = currententity; ! 559: surface_p->key = r_currentkey++; ! 560: surface_p->spans = NULL; ! 561: ! 562: pplane = fa->plane; ! 563: // FIXME: cache this? ! 564: TransformVector (pplane->normal, p_normal); ! 565: // FIXME: cache this? ! 566: distinv = 1.0 / (pplane->dist - DotProduct (modelorg, pplane->normal)); ! 567: ! 568: surface_p->d_zistepu = p_normal[0] * xscaleinv * distinv; ! 569: surface_p->d_zistepv = -p_normal[1] * yscaleinv * distinv; ! 570: surface_p->d_ziorigin = p_normal[2] * distinv - ! 571: xcenter * surface_p->d_zistepu - ! 572: ycenter * surface_p->d_zistepv; ! 573: ! 574: //JDC VectorCopy (r_worldmodelorg, surface_p->modelorg); ! 575: surface_p++; ! 576: } ! 577: ! 578: ! 579: /* ! 580: ================ ! 581: R_RenderBmodelFace ! 582: ================ ! 583: */ ! 584: void R_RenderBmodelFace (bedge_t *pedges, msurface_t *psurf) ! 585: { ! 586: int i; ! 587: unsigned mask; ! 588: mplane_t *pplane; ! 589: float distinv; ! 590: vec3_t p_normal; ! 591: medge_t tedge; ! 592: clipplane_t *pclip; ! 593: ! 594: // skip out if no more surfs ! 595: if (surface_p >= surf_max) ! 596: { ! 597: r_outofsurfaces++; ! 598: return; ! 599: } ! 600: ! 601: // ditto if not enough edges left, or switch to auxedges if possible ! 602: if ((edge_p + psurf->numedges + 4) >= edge_max) ! 603: { ! 604: r_outofedges += psurf->numedges; ! 605: return; ! 606: } ! 607: ! 608: c_faceclip++; ! 609: ! 610: // this is a dummy to give the caching mechanism someplace to write to ! 611: r_pedge = &tedge; ! 612: ! 613: // set up clip planes ! 614: pclip = NULL; ! 615: ! 616: for (i=3, mask = 0x08 ; i>=0 ; i--, mask >>= 1) ! 617: { ! 618: if (r_clipflags & mask) ! 619: { ! 620: view_clipplanes[i].next = pclip; ! 621: pclip = &view_clipplanes[i]; ! 622: } ! 623: } ! 624: ! 625: // push the edges through ! 626: r_emitted = 0; ! 627: r_nearzi = 0; ! 628: r_nearzionly = false; ! 629: makeleftedge = makerightedge = false; ! 630: // FIXME: keep clipped bmodel edges in clockwise order so last vertex caching ! 631: // can be used? ! 632: r_lastvertvalid = false; ! 633: ! 634: for ( ; pedges ; pedges = pedges->pnext) ! 635: { ! 636: r_leftclipped = r_rightclipped = false; ! 637: R_ClipEdge (pedges->v[0], pedges->v[1], pclip); ! 638: ! 639: if (r_leftclipped) ! 640: makeleftedge = true; ! 641: if (r_rightclipped) ! 642: makerightedge = true; ! 643: } ! 644: ! 645: // if there was a clip off the left edge, add that edge too ! 646: // FIXME: faster to do in screen space? ! 647: // FIXME: share clipped edges? ! 648: if (makeleftedge) ! 649: { ! 650: r_pedge = &tedge; ! 651: R_ClipEdge (&r_leftexit, &r_leftenter, pclip->next); ! 652: } ! 653: ! 654: // if there was a clip off the right edge, get the right r_nearzi ! 655: if (makerightedge) ! 656: { ! 657: r_pedge = &tedge; ! 658: r_nearzionly = true; ! 659: R_ClipEdge (&r_rightexit, &r_rightenter, view_clipplanes[1].next); ! 660: } ! 661: ! 662: // if no edges made it out, return without posting the surface ! 663: if (!r_emitted) ! 664: return; ! 665: ! 666: r_polycount++; ! 667: ! 668: surface_p->data = (void *)psurf; ! 669: surface_p->nearzi = r_nearzi; ! 670: surface_p->flags = psurf->flags; ! 671: surface_p->insubmodel = true; ! 672: surface_p->spanstate = 0; ! 673: surface_p->entity = currententity; ! 674: surface_p->key = r_currentbkey; ! 675: surface_p->spans = NULL; ! 676: ! 677: pplane = psurf->plane; ! 678: // FIXME: cache this? ! 679: TransformVector (pplane->normal, p_normal); ! 680: // FIXME: cache this? ! 681: distinv = 1.0 / (pplane->dist - DotProduct (modelorg, pplane->normal)); ! 682: ! 683: surface_p->d_zistepu = p_normal[0] * xscaleinv * distinv; ! 684: surface_p->d_zistepv = -p_normal[1] * yscaleinv * distinv; ! 685: surface_p->d_ziorigin = p_normal[2] * distinv - ! 686: xcenter * surface_p->d_zistepu - ! 687: ycenter * surface_p->d_zistepv; ! 688: ! 689: //JDC VectorCopy (r_worldmodelorg, surface_p->modelorg); ! 690: surface_p++; ! 691: } ! 692: ! 693: ! 694: /* ! 695: ================ ! 696: R_RenderPoly ! 697: ================ ! 698: */ ! 699: void R_RenderPoly (msurface_t *fa, int clipflags) ! 700: { ! 701: int i, lindex, lnumverts, s_axis, t_axis; ! 702: float dist, lastdist, lzi, scale, u, v, frac; ! 703: unsigned mask; ! 704: vec3_t local, transformed; ! 705: clipplane_t *pclip; ! 706: medge_t *pedges; ! 707: mplane_t *pplane; ! 708: mvertex_t verts[2][100]; //FIXME: do real number ! 709: polyvert_t pverts[100]; //FIXME: do real number, safely ! 710: int vertpage, newverts, newpage, lastvert; ! 711: qboolean visible; ! 712: ! 713: // FIXME: clean this up and make it faster ! 714: // FIXME: guard against running out of vertices ! 715: ! 716: s_axis = t_axis = 0; // keep compiler happy ! 717: ! 718: // set up clip planes ! 719: pclip = NULL; ! 720: ! 721: for (i=3, mask = 0x08 ; i>=0 ; i--, mask >>= 1) ! 722: { ! 723: if (clipflags & mask) ! 724: { ! 725: view_clipplanes[i].next = pclip; ! 726: pclip = &view_clipplanes[i]; ! 727: } ! 728: } ! 729: ! 730: // reconstruct the polygon ! 731: // FIXME: these should be precalculated and loaded off disk ! 732: pedges = currententity->model->edges; ! 733: lnumverts = fa->numedges; ! 734: vertpage = 0; ! 735: ! 736: for (i=0 ; i<lnumverts ; i++) ! 737: { ! 738: lindex = currententity->model->surfedges[fa->firstedge + i]; ! 739: ! 740: if (lindex > 0) ! 741: { ! 742: r_pedge = &pedges[lindex]; ! 743: verts[0][i] = r_pcurrentvertbase[r_pedge->v[0]]; ! 744: } ! 745: else ! 746: { ! 747: r_pedge = &pedges[-lindex]; ! 748: verts[0][i] = r_pcurrentvertbase[r_pedge->v[1]]; ! 749: } ! 750: } ! 751: ! 752: // clip the polygon, done if not visible ! 753: while (pclip) ! 754: { ! 755: lastvert = lnumverts - 1; ! 756: lastdist = DotProduct (verts[vertpage][lastvert].position, ! 757: pclip->normal) - pclip->dist; ! 758: ! 759: visible = false; ! 760: newverts = 0; ! 761: newpage = vertpage ^ 1; ! 762: ! 763: for (i=0 ; i<lnumverts ; i++) ! 764: { ! 765: dist = DotProduct (verts[vertpage][i].position, pclip->normal) - ! 766: pclip->dist; ! 767: ! 768: if ((lastdist > 0) != (dist > 0)) ! 769: { ! 770: frac = dist / (dist - lastdist); ! 771: verts[newpage][newverts].position[0] = ! 772: verts[vertpage][i].position[0] + ! 773: ((verts[vertpage][lastvert].position[0] - ! 774: verts[vertpage][i].position[0]) * frac); ! 775: verts[newpage][newverts].position[1] = ! 776: verts[vertpage][i].position[1] + ! 777: ((verts[vertpage][lastvert].position[1] - ! 778: verts[vertpage][i].position[1]) * frac); ! 779: verts[newpage][newverts].position[2] = ! 780: verts[vertpage][i].position[2] + ! 781: ((verts[vertpage][lastvert].position[2] - ! 782: verts[vertpage][i].position[2]) * frac); ! 783: newverts++; ! 784: } ! 785: ! 786: if (dist >= 0) ! 787: { ! 788: verts[newpage][newverts] = verts[vertpage][i]; ! 789: newverts++; ! 790: visible = true; ! 791: } ! 792: ! 793: lastvert = i; ! 794: lastdist = dist; ! 795: } ! 796: ! 797: if (!visible || (newverts < 3)) ! 798: return; ! 799: ! 800: lnumverts = newverts; ! 801: vertpage ^= 1; ! 802: pclip = pclip->next; ! 803: } ! 804: ! 805: // transform and project, remembering the z values at the vertices and ! 806: // r_nearzi, and extract the s and t coordinates at the vertices ! 807: pplane = fa->plane; ! 808: switch (pplane->type) ! 809: { ! 810: case PLANE_X: ! 811: case PLANE_ANYX: ! 812: s_axis = 1; ! 813: t_axis = 2; ! 814: break; ! 815: case PLANE_Y: ! 816: case PLANE_ANYY: ! 817: s_axis = 0; ! 818: t_axis = 2; ! 819: break; ! 820: case PLANE_Z: ! 821: case PLANE_ANYZ: ! 822: s_axis = 0; ! 823: t_axis = 1; ! 824: break; ! 825: } ! 826: ! 827: r_nearzi = 0; ! 828: ! 829: for (i=0 ; i<lnumverts ; i++) ! 830: { ! 831: // transform and project ! 832: VectorSubtract (verts[vertpage][i].position, modelorg, local); ! 833: TransformVector (local, transformed); ! 834: ! 835: if (transformed[2] < NEAR_CLIP) ! 836: transformed[2] = NEAR_CLIP; ! 837: ! 838: lzi = 1.0 / transformed[2]; ! 839: ! 840: if (lzi > r_nearzi) // for mipmap finding ! 841: r_nearzi = lzi; ! 842: ! 843: // FIXME: build x/yscale into transform? ! 844: scale = xscale * lzi; ! 845: u = (xcenter + scale*transformed[0]); ! 846: if (u < r_refdef.fvrectx_adj) ! 847: u = r_refdef.fvrectx_adj; ! 848: if (u > r_refdef.fvrectright_adj) ! 849: u = r_refdef.fvrectright_adj; ! 850: ! 851: scale = yscale * lzi; ! 852: v = (ycenter - scale*transformed[1]); ! 853: if (v < r_refdef.fvrecty_adj) ! 854: v = r_refdef.fvrecty_adj; ! 855: if (v > r_refdef.fvrectbottom_adj) ! 856: v = r_refdef.fvrectbottom_adj; ! 857: ! 858: pverts[i].u = u; ! 859: pverts[i].v = v; ! 860: pverts[i].zi = lzi; ! 861: pverts[i].s = verts[vertpage][i].position[s_axis]; ! 862: pverts[i].t = verts[vertpage][i].position[t_axis]; ! 863: } ! 864: ! 865: // build the polygon descriptor, including fa, r_nearzi, and u, v, s, t, and z ! 866: // for each vertex ! 867: r_polydesc.numverts = lnumverts; ! 868: r_polydesc.nearzi = r_nearzi; ! 869: r_polydesc.pcurrentface = fa; ! 870: r_polydesc.pverts = pverts; ! 871: ! 872: // draw the polygon ! 873: D_DrawPoly (); ! 874: } ! 875: ! 876: ! 877: /* ! 878: ================ ! 879: R_ZDrawSubmodelPolys ! 880: ================ ! 881: */ ! 882: void R_ZDrawSubmodelPolys (model_t *pmodel) ! 883: { ! 884: int i, numsurfaces; ! 885: msurface_t *psurf; ! 886: float dot; ! 887: mplane_t *pplane; ! 888: ! 889: psurf = &pmodel->surfaces[pmodel->firstmodelsurface]; ! 890: numsurfaces = pmodel->nummodelsurfaces; ! 891: ! 892: for (i=0 ; i<numsurfaces ; i++, psurf++) ! 893: { ! 894: // find which side of the node we are on ! 895: pplane = psurf->plane; ! 896: ! 897: dot = DotProduct (modelorg, pplane->normal) - pplane->dist; ! 898: ! 899: // draw the polygon ! 900: if (((psurf->flags & SURF_PLANEBACK) && (dot < -BACKFACE_EPSILON)) || ! 901: (!(psurf->flags & SURF_PLANEBACK) && (dot > BACKFACE_EPSILON))) ! 902: { ! 903: // FIXME: use bounding-box-based frustum clipping info? ! 904: R_RenderPoly (psurf, 15); ! 905: } ! 906: } ! 907: } ! 908:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.