?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
git-svn-id: http://bladebattles.com/kurok/SVN@11 20cd92bb-ff49-0410-b73e-96a06e42c3b9
[kurok.git] / r_draw.c
blob52a4fc991e47d84b00ecbd235631110260864215
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[SIN_BUFFER_SIZE];
54 int intsintable[SIN_BUFFER_SIZE];
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) ceilf(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) ceilf(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
You play as Kurok, the long lost brother to someone else that resembles his name.