![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to d_polyse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quake1|
Return to d_polyse.c CVS log | Up to [Quake] / quake1 |
1.1 root 1: // d_polyset.c: routines for drawing sets of polygons sharing the same
2: // texture (used for Alias models)
3:
4: #include "quakedef.h"
5: #include "r_local.h"
6: #include "d_local.h"
7:
8: // TODO: put in span spilling to shrink list size
9: // !!! if this is changed, it must be changed in d_polysa.s too !!!
10: #define DPS_MAXSPANS MAXHEIGHT+1
11: // 1 extra for spanpackage that marks end
12:
13: // !!! if this is changed, it must be changed in asm_draw.h too !!!
14: typedef struct {
15: void *pdest;
16: short *pz;
17: int count;
18: byte *ptex;
19: int sfrac, tfrac, light, zi;
20: } spanpackage_t;
21:
22: typedef struct {
23: int isflattop;
24: int numleftedges;
25: int *pleftedgevert0;
26: int *pleftedgevert1;
27: int *pleftedgevert2;
28: int numrightedges;
29: int *prightedgevert0;
30: int *prightedgevert1;
31: int *prightedgevert2;
32: } edgetable;
33:
34: int r_p0[6], r_p1[6], r_p2[6];
35:
36: byte *d_pcolormap;
37:
38: int d_aflatcolor;
39: int d_xdenom;
40:
41: edgetable *pedgetable;
42:
43: edgetable edgetables[12] = {
44: {0, 1, r_p0, r_p2, NULL, 2, r_p0, r_p1, r_p2 },
45: {0, 2, r_p1, r_p0, r_p2, 1, r_p1, r_p2, NULL},
46: {1, 1, r_p0, r_p2, NULL, 1, r_p1, r_p2, NULL},
47: {0, 1, r_p1, r_p0, NULL, 2, r_p1, r_p2, r_p0 },
48: {0, 2, r_p0, r_p2, r_p1, 1, r_p0, r_p1, NULL},
49: {0, 1, r_p2, r_p1, NULL, 1, r_p2, r_p0, NULL},
50: {0, 1, r_p2, r_p1, NULL, 2, r_p2, r_p0, r_p1 },
51: {0, 2, r_p2, r_p1, r_p0, 1, r_p2, r_p0, NULL},
52: {0, 1, r_p1, r_p0, NULL, 1, r_p1, r_p2, NULL},
53: {1, 1, r_p2, r_p1, NULL, 1, r_p0, r_p1, NULL},
54: {1, 1, r_p1, r_p0, NULL, 1, r_p2, r_p0, NULL},
55: {0, 1, r_p0, r_p2, NULL, 1, r_p0, r_p1, NULL},
56: };
57:
58: // FIXME: some of these can become statics
59: int a_sstepxfrac, a_tstepxfrac, r_lstepx, a_ststepxwhole;
60: int r_sstepx, r_tstepx, r_lstepy, r_sstepy, r_tstepy;
61: int r_zistepx, r_zistepy;
62: int d_aspancount, d_countextrastep;
63:
64: spanpackage_t *a_spans;
65: spanpackage_t *d_pedgespanpackage;
66: static int ystart;
67: byte *d_pdest, *d_ptex;
68: short *d_pz;
69: int d_sfrac, d_tfrac, d_light, d_zi;
70: int d_ptexextrastep, d_sfracextrastep;
71: int d_tfracextrastep, d_lightextrastep, d_pdestextrastep;
72: int d_lightbasestep, d_pdestbasestep, d_ptexbasestep;
73: int d_sfracbasestep, d_tfracbasestep;
74: int d_ziextrastep, d_zibasestep;
75: int d_pzextrastep, d_pzbasestep;
76:
77: typedef struct {
78: int quotient;
79: int remainder;
80: } adivtab_t;
81:
82: static adivtab_t adivtab[32*32] = {
83: #include "adivtab.h"
84: };
85:
86: byte *skintable[MAX_LBM_HEIGHT];
87: int skinwidth;
88: byte *skinstart;
89:
90: void D_PolysetDrawSpans8 (spanpackage_t *pspanpackage);
91: void D_PolysetCalcGradients (int skinwidth);
92: void D_DrawSubdiv (void);
93: void D_DrawNonSubdiv (void);
94: void D_PolysetRecursiveTriangle (int *p1, int *p2, int *p3);
95: void D_PolysetSetEdgeTable (void);
96: void D_RasterizeAliasPolySmooth (void);
97: void D_PolysetScanLeftEdge (int height);
98:
99: #if !id386
100:
101: /*
102: ================
103: D_PolysetDraw
104: ================
105: */
106: void D_PolysetDraw (void)
107: {
108: spanpackage_t spans[DPS_MAXSPANS + 1 +
109: ((CACHE_SIZE - 1) / sizeof(spanpackage_t)) + 1];
110: // one extra because of cache line pretouching
111:
112: a_spans = (spanpackage_t *)
113: (((long)&spans[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
114:
115: if (r_affinetridesc.drawtype)
116: {
117: D_DrawSubdiv ();
118: }
119: else
120: {
121: D_DrawNonSubdiv ();
122: }
123: }
124:
125:
126: /*
127: ================
128: D_PolysetDrawFinalVerts
129: ================
130: */
131: void D_PolysetDrawFinalVerts (finalvert_t *fv, int numverts)
132: {
133: int i, z;
134: short *zbuf;
135:
136: for (i=0 ; i<numverts ; i++, fv++)
137: {
138: // valid triangle coordinates for filling can include the bottom and
139: // right clip edges, due to the fill rule; these shouldn't be drawn
140: if ((fv->v[0] < r_refdef.vrectright) &&
141: (fv->v[1] < r_refdef.vrectbottom))
142: {
143: z = fv->v[5]>>16;
144: zbuf = zspantable[fv->v[1]] + fv->v[0];
145: if (z >= *zbuf)
146: {
147: int pix;
148:
149: *zbuf = z;
150: pix = skintable[fv->v[3]>>16][fv->v[2]>>16];
151: pix = ((byte *)acolormap)[pix + (fv->v[4] & 0xFF00) ];
152: d_viewbuffer[d_scantable[fv->v[1]] + fv->v[0]] = pix;
153: }
154: }
155: }
156: }
157:
158:
159: /*
160: ================
161: D_DrawSubdiv
162: ================
163: */
164: void D_DrawSubdiv (void)
165: {
166: mtriangle_t *ptri;
167: finalvert_t *pfv, *index0, *index1, *index2;
168: int i;
169: int lnumtriangles;
170:
171: pfv = r_affinetridesc.pfinalverts;
172: ptri = r_affinetridesc.ptriangles;
173: lnumtriangles = r_affinetridesc.numtriangles;
174:
175: for (i=0 ; i<lnumtriangles ; i++)
176: {
177: index0 = pfv + ptri[i].vertindex[0];
178: index1 = pfv + ptri[i].vertindex[1];
179: index2 = pfv + ptri[i].vertindex[2];
180:
181: if (((index0->v[1]-index1->v[1]) *
182: (index0->v[0]-index2->v[0]) -
183: (index0->v[0]-index1->v[0]) *
184: (index0->v[1]-index2->v[1])) >= 0)
185: {
186: continue;
187: }
188:
189: d_pcolormap = &((byte *)acolormap)[index0->v[4] & 0xFF00];
190:
191: if (ptri[i].facesfront)
192: {
193: D_PolysetRecursiveTriangle(index0->v, index1->v, index2->v);
194: }
195: else
196: {
197: int s0, s1, s2;
198:
199: s0 = index0->v[2];
200: s1 = index1->v[2];
201: s2 = index2->v[2];
202:
203: if (index0->flags & ALIAS_ONSEAM)
204: index0->v[2] += r_affinetridesc.seamfixupX16;
205: if (index1->flags & ALIAS_ONSEAM)
206: index1->v[2] += r_affinetridesc.seamfixupX16;
207: if (index2->flags & ALIAS_ONSEAM)
208: index2->v[2] += r_affinetridesc.seamfixupX16;
209:
210: D_PolysetRecursiveTriangle(index0->v, index1->v, index2->v);
211:
212: index0->v[2] = s0;
213: index1->v[2] = s1;
214: index2->v[2] = s2;
215: }
216: }
217: }
218:
219:
220: /*
221: ================
222: D_DrawNonSubdiv
223: ================
224: */
225: void D_DrawNonSubdiv (void)
226: {
227: mtriangle_t *ptri;
228: finalvert_t *pfv, *index0, *index1, *index2;
229: int i;
230: int lnumtriangles;
231:
232: pfv = r_affinetridesc.pfinalverts;
233: ptri = r_affinetridesc.ptriangles;
234: lnumtriangles = r_affinetridesc.numtriangles;
235:
236: for (i=0 ; i<lnumtriangles ; i++, ptri++)
237: {
238: index0 = pfv + ptri->vertindex[0];
239: index1 = pfv + ptri->vertindex[1];
240: index2 = pfv + ptri->vertindex[2];
241:
242: d_xdenom = (index0->v[1]-index1->v[1]) *
243: (index0->v[0]-index2->v[0]) -
244: (index0->v[0]-index1->v[0])*(index0->v[1]-index2->v[1]);
245:
246: if (d_xdenom >= 0)
247: {
248: continue;
249: }
250:
251: r_p0[0] = index0->v[0]; // u
252: r_p0[1] = index0->v[1]; // v
253: r_p0[2] = index0->v[2]; // s
254: r_p0[3] = index0->v[3]; // t
255: r_p0[4] = index0->v[4]; // light
256: r_p0[5] = index0->v[5]; // iz
257:
258: r_p1[0] = index1->v[0];
259: r_p1[1] = index1->v[1];
260: r_p1[2] = index1->v[2];
261: r_p1[3] = index1->v[3];
262: r_p1[4] = index1->v[4];
263: r_p1[5] = index1->v[5];
264:
265: r_p2[0] = index2->v[0];
266: r_p2[1] = index2->v[1];
267: r_p2[2] = index2->v[2];
268: r_p2[3] = index2->v[3];
269: r_p2[4] = index2->v[4];
270: r_p2[5] = index2->v[5];
271:
272: if (!ptri->facesfront)
273: {
274: if (index0->flags & ALIAS_ONSEAM)
275: r_p0[2] += r_affinetridesc.seamfixupX16;
276: if (index1->flags & ALIAS_ONSEAM)
277: r_p1[2] += r_affinetridesc.seamfixupX16;
278: if (index2->flags & ALIAS_ONSEAM)
279: r_p2[2] += r_affinetridesc.seamfixupX16;
280: }
281:
282: D_PolysetSetEdgeTable ();
283: D_RasterizeAliasPolySmooth ();
284: }
285: }
286:
287:
288: /*
289: ================
290: D_PolysetRecursiveTriangle
291: ================
292: */
293: void D_PolysetRecursiveTriangle (int *lp1, int *lp2, int *lp3)
294: {
295: int *temp;
296: int d;
297: int new[6];
298: int z;
299: short *zbuf;
300:
301: d = lp2[0] - lp1[0];
302: if (d < -1 || d > 1)
303: goto split;
304: d = lp2[1] - lp1[1];
305: if (d < -1 || d > 1)
306: goto split;
307:
308: d = lp3[0] - lp2[0];
309: if (d < -1 || d > 1)
310: goto split2;
311: d = lp3[1] - lp2[1];
312: if (d < -1 || d > 1)
313: goto split2;
314:
315: d = lp1[0] - lp3[0];
316: if (d < -1 || d > 1)
317: goto split3;
318: d = lp1[1] - lp3[1];
319: if (d < -1 || d > 1)
320: {
321: split3:
322: temp = lp1;
323: lp1 = lp3;
324: lp3 = lp2;
325: lp2 = temp;
326:
327: goto split;
328: }
329:
330: return; // entire tri is filled
331:
332: split2:
333: temp = lp1;
334: lp1 = lp2;
335: lp2 = lp3;
336: lp3 = temp;
337:
338: split:
339: // split this edge
340: new[0] = (lp1[0] + lp2[0]) >> 1;
341: new[1] = (lp1[1] + lp2[1]) >> 1;
342: new[2] = (lp1[2] + lp2[2]) >> 1;
343: new[3] = (lp1[3] + lp2[3]) >> 1;
344: new[5] = (lp1[5] + lp2[5]) >> 1;
345:
346: // draw the point if splitting a leading edge
347: if (lp2[1] > lp1[1])
348: goto nodraw;
349: if ((lp2[1] == lp1[1]) && (lp2[0] < lp1[0]))
350: goto nodraw;
351:
352:
353: z = new[5]>>16;
354: zbuf = zspantable[new[1]] + new[0];
355: if (z >= *zbuf)
356: {
357: int pix;
358:
359: *zbuf = z;
360: pix = d_pcolormap[skintable[new[3]>>16][new[2]>>16]];
361: d_viewbuffer[d_scantable[new[1]] + new[0]] = pix;
362: }
363:
364: nodraw:
365: // recursively continue
366: D_PolysetRecursiveTriangle (lp3, lp1, new);
367: D_PolysetRecursiveTriangle (lp3, new, lp2);
368: }
369:
370: #endif // !id386
371:
372:
373: /*
374: ================
375: D_PolysetUpdateTables
376: ================
377: */
378: void D_PolysetUpdateTables (void)
379: {
380: int i;
381: byte *s;
382:
383: if (r_affinetridesc.skinwidth != skinwidth ||
384: r_affinetridesc.pskin != skinstart)
385: {
386: skinwidth = r_affinetridesc.skinwidth;
387: skinstart = r_affinetridesc.pskin;
388: s = skinstart;
389: for (i=0 ; i<MAX_LBM_HEIGHT ; i++, s+=skinwidth)
390: skintable[i] = s;
391: }
392: }
393:
394:
395: #if !id386
396:
397: /*
398: ===================
399: D_PolysetScanLeftEdge
400: ====================
401: */
402: void D_PolysetScanLeftEdge (int height)
403: {
404:
405: do
406: {
407: d_pedgespanpackage->pdest = d_pdest;
408: d_pedgespanpackage->pz = d_pz;
409: d_pedgespanpackage->count = d_aspancount;
410: d_pedgespanpackage->ptex = d_ptex;
411:
412: d_pedgespanpackage->sfrac = d_sfrac;
413: d_pedgespanpackage->tfrac = d_tfrac;
414:
415: // FIXME: need to clamp l, s, t, at both ends?
416: d_pedgespanpackage->light = d_light;
417: d_pedgespanpackage->zi = d_zi;
418:
419: d_pedgespanpackage++;
420:
421: errorterm += erroradjustup;
422: if (errorterm >= 0)
423: {
424: d_pdest += d_pdestextrastep;
425: d_pz += d_pzextrastep;
426: d_aspancount += d_countextrastep;
427: d_ptex += d_ptexextrastep;
428: d_sfrac += d_sfracextrastep;
429: d_ptex += d_sfrac >> 16;
430:
431: d_sfrac &= 0xFFFF;
432: d_tfrac += d_tfracextrastep;
433: if (d_tfrac & 0x10000)
434: {
435: d_ptex += r_affinetridesc.skinwidth;
436: d_tfrac &= 0xFFFF;
437: }
438: d_light += d_lightextrastep;
439: d_zi += d_ziextrastep;
440: errorterm -= erroradjustdown;
441: }
442: else
443: {
444: d_pdest += d_pdestbasestep;
445: d_pz += d_pzbasestep;
446: d_aspancount += ubasestep;
447: d_ptex += d_ptexbasestep;
448: d_sfrac += d_sfracbasestep;
449: d_ptex += d_sfrac >> 16;
450: d_sfrac &= 0xFFFF;
451: d_tfrac += d_tfracbasestep;
452: if (d_tfrac & 0x10000)
453: {
454: d_ptex += r_affinetridesc.skinwidth;
455: d_tfrac &= 0xFFFF;
456: }
457: d_light += d_lightbasestep;
458: d_zi += d_zibasestep;
459: }
460: } while (--height);
461: }
462:
463: #endif // !id386
464:
465:
466: /*
467: ===================
468: D_PolysetSetUpForLineScan
469: ====================
470: */
471: void D_PolysetSetUpForLineScan(fixed8_t startvertu, fixed8_t startvertv,
472: fixed8_t endvertu, fixed8_t endvertv)
473: {
474: double dm, dn;
475: int tm, tn;
476: adivtab_t *ptemp;
477:
478: // TODO: implement x86 version
479:
480: errorterm = -1;
481:
482: tm = endvertu - startvertu;
483: tn = endvertv - startvertv;
484:
485: if (((tm <= 16) && (tm >= -15)) &&
486: ((tn <= 16) && (tn >= -15)))
487: {
488: ptemp = &adivtab[((tm+15) << 5) + (tn+15)];
489: ubasestep = ptemp->quotient;
490: erroradjustup = ptemp->remainder;
491: erroradjustdown = tn;
492: }
493: else
494: {
495: dm = (double)tm;
496: dn = (double)tn;
497:
498: FloorDivMod (dm, dn, &ubasestep, &erroradjustup);
499:
500: erroradjustdown = dn;
501: }
502: }
503:
504:
505: #if !id386
506:
507: /*
508: ================
509: D_PolysetCalcGradients
510: ================
511: */
512: void D_PolysetCalcGradients (int skinwidth)
513: {
514: float xstepdenominv, ystepdenominv, t0, t1;
515: float p01_minus_p21, p11_minus_p21, p00_minus_p20, p10_minus_p20;
516:
517: p00_minus_p20 = r_p0[0] - r_p2[0];
518: p01_minus_p21 = r_p0[1] - r_p2[1];
519: p10_minus_p20 = r_p1[0] - r_p2[0];
520: p11_minus_p21 = r_p1[1] - r_p2[1];
521:
522: xstepdenominv = 1.0 / (float)d_xdenom;
523:
524: ystepdenominv = -xstepdenominv;
525:
526: // ceil () for light so positive steps are exaggerated, negative steps
527: // diminished, pushing us away from underflow toward overflow. Underflow is
528: // very visible, overflow is very unlikely, because of ambient lighting
529: t0 = r_p0[4] - r_p2[4];
530: t1 = r_p1[4] - r_p2[4];
531: r_lstepx = (int)
532: ceil((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv);
533: r_lstepy = (int)
534: ceil((t1 * p00_minus_p20 - t0 * p10_minus_p20) * ystepdenominv);
535:
536: t0 = r_p0[2] - r_p2[2];
537: t1 = r_p1[2] - r_p2[2];
538: r_sstepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) *
539: xstepdenominv);
540: r_sstepy = (int)((t1 * p00_minus_p20 - t0* p10_minus_p20) *
541: ystepdenominv);
542:
543: t0 = r_p0[3] - r_p2[3];
544: t1 = r_p1[3] - r_p2[3];
545: r_tstepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) *
546: xstepdenominv);
547: r_tstepy = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) *
548: ystepdenominv);
549:
550: t0 = r_p0[5] - r_p2[5];
551: t1 = r_p1[5] - r_p2[5];
552: r_zistepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) *
553: xstepdenominv);
554: r_zistepy = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) *
555: ystepdenominv);
556:
1.1.1.3 ! root 557: #if id386
1.1 root 558: a_sstepxfrac = r_sstepx << 16;
559: a_tstepxfrac = r_tstepx << 16;
560: #else
561: a_sstepxfrac = r_sstepx & 0xFFFF;
562: a_tstepxfrac = r_tstepx & 0xFFFF;
563: #endif
564:
565: a_ststepxwhole = skinwidth * (r_tstepx >> 16) + (r_sstepx >> 16);
566: }
567:
568: #endif // !id386
569:
570:
1.1.1.3 ! root 571: #if 0
1.1 root 572: byte gelmap[256];
573: void InitGel (byte *palette)
574: {
575: int i;
576: int r;
577:
578: for (i=0 ; i<256 ; i++)
579: {
580: // r = (palette[i*3]>>4);
581: r = (palette[i*3] + palette[i*3+1] + palette[i*3+2])/(16*3);
582: gelmap[i] = /* 64 */ 0 + r;
583: }
584: }
1.1.1.3 ! root 585: #endif
1.1 root 586:
587:
1.1.1.3 ! root 588: #if !id386
1.1 root 589:
590: /*
591: ================
592: D_PolysetDrawSpans8
593: ================
594: */
595: void D_PolysetDrawSpans8 (spanpackage_t *pspanpackage)
596: {
597: int lcount;
598: byte *lpdest;
599: byte *lptex;
600: int lsfrac, ltfrac;
601: int llight;
602: int lzi;
603: short *lpz;
604:
605: do
606: {
607: lcount = d_aspancount - pspanpackage->count;
608:
609: errorterm += erroradjustup;
610: if (errorterm >= 0)
611: {
612: d_aspancount += d_countextrastep;
613: errorterm -= erroradjustdown;
614: }
615: else
616: {
617: d_aspancount += ubasestep;
618: }
619:
620: if (lcount)
621: {
622: lpdest = pspanpackage->pdest;
623: lptex = pspanpackage->ptex;
624: lpz = pspanpackage->pz;
625: lsfrac = pspanpackage->sfrac;
626: ltfrac = pspanpackage->tfrac;
627: llight = pspanpackage->light;
628: lzi = pspanpackage->zi;
629:
630: do
631: {
632: if ((lzi >> 16) >= *lpz)
633: {
634: *lpdest = ((byte *)acolormap)[*lptex + (llight & 0xFF00)];
635: // gel mapping *lpdest = gelmap[*lpdest];
636: *lpz = lzi >> 16;
637: }
638: lpdest++;
639: lzi += r_zistepx;
640: lpz++;
641: llight += r_lstepx;
642: lptex += a_ststepxwhole;
643: lsfrac += a_sstepxfrac;
644: lptex += lsfrac >> 16;
645: lsfrac &= 0xFFFF;
646: ltfrac += a_tstepxfrac;
647: if (ltfrac & 0x10000)
648: {
649: lptex += r_affinetridesc.skinwidth;
650: ltfrac &= 0xFFFF;
651: }
652: } while (--lcount);
653: }
654:
655: pspanpackage++;
656: } while (pspanpackage->count != -999999);
657: }
658: #endif // !id386
659:
660:
661: /*
662: ================
663: D_PolysetFillSpans8
664: ================
665: */
666: void D_PolysetFillSpans8 (spanpackage_t *pspanpackage)
667: {
668: int color;
669:
670: // FIXME: do z buffering
671:
672: color = d_aflatcolor++;
673:
674: while (1)
675: {
676: int lcount;
677: byte *lpdest;
678:
679: lcount = pspanpackage->count;
680:
681: if (lcount == -1)
682: return;
683:
684: if (lcount)
685: {
686: lpdest = pspanpackage->pdest;
687:
688: do
689: {
690: *lpdest++ = color;
691: } while (--lcount);
692: }
693:
694: pspanpackage++;
695: }
696: }
697:
698: /*
699: ================
700: D_RasterizeAliasPolySmooth
701: ================
702: */
703: void D_RasterizeAliasPolySmooth (void)
704: {
705: int initialleftheight, initialrightheight;
706: int *plefttop, *prighttop, *pleftbottom, *prightbottom;
707: int working_lstepx, originalcount;
708:
709: plefttop = pedgetable->pleftedgevert0;
710: prighttop = pedgetable->prightedgevert0;
711:
712: pleftbottom = pedgetable->pleftedgevert1;
713: prightbottom = pedgetable->prightedgevert1;
714:
715: initialleftheight = pleftbottom[1] - plefttop[1];
716: initialrightheight = prightbottom[1] - prighttop[1];
717:
718: //
719: // set the s, t, and light gradients, which are consistent across the triangle
720: // because being a triangle, things are affine
721: //
722: D_PolysetCalcGradients (r_affinetridesc.skinwidth);
723:
724: //
725: // rasterize the polygon
726: //
727:
728: //
729: // scan out the top (and possibly only) part of the left edge
730: //
731: d_pedgespanpackage = a_spans;
732:
733: ystart = plefttop[1];
734: d_aspancount = plefttop[0] - prighttop[0];
735:
736: d_ptex = (byte *)r_affinetridesc.pskin + (plefttop[2] >> 16) +
737: (plefttop[3] >> 16) * r_affinetridesc.skinwidth;
738: #if id386
739: d_sfrac = (plefttop[2] & 0xFFFF) << 16;
740: d_tfrac = (plefttop[3] & 0xFFFF) << 16;
741: #else
742: d_sfrac = plefttop[2] & 0xFFFF;
743: d_tfrac = plefttop[3] & 0xFFFF;
744: #endif
745: d_light = plefttop[4];
746: d_zi = plefttop[5];
747:
748: d_pdest = (byte *)d_viewbuffer +
749: ystart * screenwidth + plefttop[0];
750: d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0];
751:
1.1.1.3 ! root 752: if (initialleftheight == 1)
! 753: {
! 754: d_pedgespanpackage->pdest = d_pdest;
! 755: d_pedgespanpackage->pz = d_pz;
! 756: d_pedgespanpackage->count = d_aspancount;
! 757: d_pedgespanpackage->ptex = d_ptex;
! 758:
! 759: d_pedgespanpackage->sfrac = d_sfrac;
! 760: d_pedgespanpackage->tfrac = d_tfrac;
! 761:
! 762: // FIXME: need to clamp l, s, t, at both ends?
! 763: d_pedgespanpackage->light = d_light;
! 764: d_pedgespanpackage->zi = d_zi;
1.1 root 765:
1.1.1.3 ! root 766: d_pedgespanpackage++;
! 767: }
1.1 root 768: else
1.1.1.3 ! root 769: {
! 770: D_PolysetSetUpForLineScan(plefttop[0], plefttop[1],
! 771: pleftbottom[0], pleftbottom[1]);
1.1 root 772:
1.1.1.3 ! root 773: #if id386
! 774: d_pzbasestep = (d_zwidth + ubasestep) << 1;
! 775: d_pzextrastep = d_pzbasestep + 2;
! 776: #else
! 777: d_pzbasestep = d_zwidth + ubasestep;
! 778: d_pzextrastep = d_pzbasestep + 1;
! 779: #endif
1.1 root 780:
1.1.1.3 ! root 781: d_pdestbasestep = screenwidth + ubasestep;
! 782: d_pdestextrastep = d_pdestbasestep + 1;
1.1 root 783:
1.1.1.3 ! root 784: // TODO: can reuse partial expressions here
! 785:
! 786: // for negative steps in x along left edge, bias toward overflow rather than
! 787: // underflow (sort of turning the floor () we did in the gradient calcs into
! 788: // ceil (), but plus a little bit)
! 789: if (ubasestep < 0)
! 790: working_lstepx = r_lstepx - 1;
! 791: else
! 792: working_lstepx = r_lstepx;
! 793:
! 794: d_countextrastep = ubasestep + 1;
! 795: d_ptexbasestep = ((r_sstepy + r_sstepx * ubasestep) >> 16) +
! 796: ((r_tstepy + r_tstepx * ubasestep) >> 16) *
! 797: r_affinetridesc.skinwidth;
! 798: #if id386
! 799: d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) << 16;
! 800: d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) << 16;
! 801: #else
! 802: d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) & 0xFFFF;
! 803: d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) & 0xFFFF;
! 804: #endif
! 805: d_lightbasestep = r_lstepy + working_lstepx * ubasestep;
! 806: d_zibasestep = r_zistepy + r_zistepx * ubasestep;
! 807:
! 808: d_ptexextrastep = ((r_sstepy + r_sstepx * d_countextrastep) >> 16) +
! 809: ((r_tstepy + r_tstepx * d_countextrastep) >> 16) *
! 810: r_affinetridesc.skinwidth;
! 811: #if id386
! 812: d_sfracextrastep = (r_sstepy + r_sstepx*d_countextrastep) << 16;
! 813: d_tfracextrastep = (r_tstepy + r_tstepx*d_countextrastep) << 16;
! 814: #else
! 815: d_sfracextrastep = (r_sstepy + r_sstepx*d_countextrastep) & 0xFFFF;
! 816: d_tfracextrastep = (r_tstepy + r_tstepx*d_countextrastep) & 0xFFFF;
! 817: #endif
! 818: d_lightextrastep = d_lightbasestep + working_lstepx;
! 819: d_ziextrastep = d_zibasestep + r_zistepx;
! 820:
! 821: D_PolysetScanLeftEdge (initialleftheight);
! 822: }
1.1 root 823:
824: //
825: // scan out the bottom part of the left edge, if it exists
826: //
827: if (pedgetable->numleftedges == 2)
828: {
829: int height;
830:
831: plefttop = pleftbottom;
832: pleftbottom = pedgetable->pleftedgevert2;
833:
834: height = pleftbottom[1] - plefttop[1];
835:
836: // TODO: make this a function; modularize this function in general
837:
838: ystart = plefttop[1];
839: d_aspancount = plefttop[0] - prighttop[0];
840: d_ptex = (byte *)r_affinetridesc.pskin + (plefttop[2] >> 16) +
841: (plefttop[3] >> 16) * r_affinetridesc.skinwidth;
842: d_sfrac = 0;
843: d_tfrac = 0;
844: d_light = plefttop[4];
845: d_zi = plefttop[5];
846:
847: d_pdest = (byte *)d_viewbuffer + ystart * screenwidth + plefttop[0];
848: d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0];
849:
1.1.1.3 ! root 850: if (height == 1)
! 851: {
! 852: d_pedgespanpackage->pdest = d_pdest;
! 853: d_pedgespanpackage->pz = d_pz;
! 854: d_pedgespanpackage->count = d_aspancount;
! 855: d_pedgespanpackage->ptex = d_ptex;
! 856:
! 857: d_pedgespanpackage->sfrac = d_sfrac;
! 858: d_pedgespanpackage->tfrac = d_tfrac;
! 859:
! 860: // FIXME: need to clamp l, s, t, at both ends?
! 861: d_pedgespanpackage->light = d_light;
! 862: d_pedgespanpackage->zi = d_zi;
! 863:
! 864: d_pedgespanpackage++;
! 865: }
1.1 root 866: else
1.1.1.3 ! root 867: {
! 868: D_PolysetSetUpForLineScan(plefttop[0], plefttop[1],
! 869: pleftbottom[0], pleftbottom[1]);
1.1 root 870:
1.1.1.3 ! root 871: d_pdestbasestep = screenwidth + ubasestep;
! 872: d_pdestextrastep = d_pdestbasestep + 1;
1.1 root 873:
1.1.1.3 ! root 874: #if id386
! 875: d_pzbasestep = (d_zwidth + ubasestep) << 1;
! 876: d_pzextrastep = d_pzbasestep + 2;
! 877: #else
! 878: d_pzbasestep = d_zwidth + ubasestep;
! 879: d_pzextrastep = d_pzbasestep + 1;
! 880: #endif
! 881:
! 882: if (ubasestep < 0)
! 883: working_lstepx = r_lstepx - 1;
! 884: else
! 885: working_lstepx = r_lstepx;
! 886:
! 887: d_countextrastep = ubasestep + 1;
! 888: d_ptexbasestep = ((r_sstepy + r_sstepx * ubasestep) >> 16) +
! 889: ((r_tstepy + r_tstepx * ubasestep) >> 16) *
! 890: r_affinetridesc.skinwidth;
! 891: #if id386
! 892: d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) << 16;
! 893: d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) << 16;
! 894: #else
! 895: d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) & 0xFFFF;
! 896: d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) & 0xFFFF;
! 897: #endif
! 898: d_lightbasestep = r_lstepy + working_lstepx * ubasestep;
! 899: d_zibasestep = r_zistepy + r_zistepx * ubasestep;
! 900:
! 901: d_ptexextrastep = ((r_sstepy + r_sstepx * d_countextrastep) >> 16) +
! 902: ((r_tstepy + r_tstepx * d_countextrastep) >> 16) *
! 903: r_affinetridesc.skinwidth;
! 904: #if id386
! 905: d_sfracextrastep = ((r_sstepy+r_sstepx*d_countextrastep) & 0xFFFF)<<16;
! 906: d_tfracextrastep = ((r_tstepy+r_tstepx*d_countextrastep) & 0xFFFF)<<16;
! 907: #else
! 908: d_sfracextrastep = (r_sstepy+r_sstepx*d_countextrastep) & 0xFFFF;
! 909: d_tfracextrastep = (r_tstepy+r_tstepx*d_countextrastep) & 0xFFFF;
! 910: #endif
! 911: d_lightextrastep = d_lightbasestep + working_lstepx;
! 912: d_ziextrastep = d_zibasestep + r_zistepx;
1.1 root 913:
1.1.1.3 ! root 914: D_PolysetScanLeftEdge (height);
! 915: }
1.1 root 916: }
917:
918: // scan out the top (and possibly only) part of the right edge, updating the
919: // count field
920: d_pedgespanpackage = a_spans;
921:
922: D_PolysetSetUpForLineScan(prighttop[0], prighttop[1],
923: prightbottom[0], prightbottom[1]);
924: d_aspancount = 0;
925: d_countextrastep = ubasestep + 1;
926: originalcount = a_spans[initialrightheight].count;
927: a_spans[initialrightheight].count = -999999; // mark end of the spanpackages
928: D_PolysetDrawSpans8 (a_spans);
929:
930: // scan out the bottom part of the right edge, if it exists
931: if (pedgetable->numrightedges == 2)
932: {
933: int height;
934: spanpackage_t *pstart;
935:
936: pstart = a_spans + initialrightheight;
937: pstart->count = originalcount;
938:
939: d_aspancount = prightbottom[0] - prighttop[0];
940:
941: prighttop = prightbottom;
942: prightbottom = pedgetable->prightedgevert2;
943:
944: height = prightbottom[1] - prighttop[1];
945:
946: D_PolysetSetUpForLineScan(prighttop[0], prighttop[1],
947: prightbottom[0], prightbottom[1]);
948:
949: d_countextrastep = ubasestep + 1;
950: a_spans[initialrightheight + height].count = -999999;
951: // mark end of the spanpackages
952: D_PolysetDrawSpans8 (pstart);
953: }
954: }
955:
956:
957: /*
958: ================
959: D_PolysetSetEdgeTable
960: ================
961: */
962: void D_PolysetSetEdgeTable (void)
963: {
964: int edgetableindex;
965:
966: edgetableindex = 0; // assume the vertices are already in
967: // top to bottom order
968:
969: //
970: // determine which edges are right & left, and the order in which
971: // to rasterize them
972: //
973: if (r_p0[1] >= r_p1[1])
974: {
975: if (r_p0[1] == r_p1[1])
976: {
977: if (r_p0[1] < r_p2[1])
978: pedgetable = &edgetables[2];
979: else
980: pedgetable = &edgetables[5];
981:
982: return;
983: }
984: else
985: {
986: edgetableindex = 1;
987: }
988: }
989:
990: if (r_p0[1] == r_p2[1])
991: {
992: if (edgetableindex)
993: pedgetable = &edgetables[8];
994: else
995: pedgetable = &edgetables[9];
996:
997: return;
998: }
999: else if (r_p1[1] == r_p2[1])
1000: {
1001: if (edgetableindex)
1002: pedgetable = &edgetables[10];
1003: else
1004: pedgetable = &edgetables[11];
1005:
1006: return;
1007: }
1008:
1009: if (r_p0[1] > r_p2[1])
1010: edgetableindex += 2;
1011:
1012: if (r_p1[1] > r_p2[1])
1013: edgetableindex += 4;
1014:
1015: pedgetable = &edgetables[edgetableindex];
1016: }
1017:
1018:
1019: #if 0
1020:
1021: void D_PolysetRecursiveDrawLine (int *lp1, int *lp2)
1022: {
1023: int d;
1024: int new[6];
1025: int ofs;
1026:
1027: d = lp2[0] - lp1[0];
1028: if (d < -1 || d > 1)
1029: goto split;
1030: d = lp2[1] - lp1[1];
1031: if (d < -1 || d > 1)
1032: goto split;
1033:
1034: return; // line is completed
1035:
1036: split:
1037: // split this edge
1038: new[0] = (lp1[0] + lp2[0]) >> 1;
1039: new[1] = (lp1[1] + lp2[1]) >> 1;
1040: new[5] = (lp1[5] + lp2[5]) >> 1;
1041: new[2] = (lp1[2] + lp2[2]) >> 1;
1042: new[3] = (lp1[3] + lp2[3]) >> 1;
1043: new[4] = (lp1[4] + lp2[4]) >> 1;
1044:
1045: // draw the point
1046: ofs = d_scantable[new[1]] + new[0];
1047: if (new[5] > d_pzbuffer[ofs])
1048: {
1049: int pix;
1050:
1051: d_pzbuffer[ofs] = new[5];
1052: pix = skintable[new[3]>>16][new[2]>>16];
1053: // pix = ((byte *)acolormap)[pix + (new[4] & 0xFF00)];
1054: d_viewbuffer[ofs] = pix;
1055: }
1056:
1057: // recursively continue
1058: D_PolysetRecursiveDrawLine (lp1, new);
1059: D_PolysetRecursiveDrawLine (new, lp2);
1060: }
1061:
1062: void D_PolysetRecursiveTriangle2 (int *lp1, int *lp2, int *lp3)
1063: {
1064: int d;
1065: int new[4];
1066:
1067: d = lp2[0] - lp1[0];
1068: if (d < -1 || d > 1)
1069: goto split;
1070: d = lp2[1] - lp1[1];
1071: if (d < -1 || d > 1)
1072: goto split;
1073: return;
1074:
1075: split:
1076: // split this edge
1077: new[0] = (lp1[0] + lp2[0]) >> 1;
1078: new[1] = (lp1[1] + lp2[1]) >> 1;
1079: new[5] = (lp1[5] + lp2[5]) >> 1;
1080: new[2] = (lp1[2] + lp2[2]) >> 1;
1081: new[3] = (lp1[3] + lp2[3]) >> 1;
1082: new[4] = (lp1[4] + lp2[4]) >> 1;
1083:
1084: D_PolysetRecursiveDrawLine (new, lp3);
1085:
1086: // recursively continue
1087: D_PolysetRecursiveTriangle (lp1, new, lp3);
1088: D_PolysetRecursiveTriangle (new, lp2, lp3);
1089: }
1090:
1091: #endif
1092:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.