Previous 15994 Revisions Next

r6716 Sunday 20th December, 2009 at 20:35:40 UTC by Harmony
Fixes the build?
[src/mame/video]rdpblend.c* rdpblend.h* rdptri.c* rdptri.h* rdpupd16.c* rdpupd16.h*

src/mame/video/rdptri.c
r0r6716
1static void triangle_ns_nt_nz(UINT32 w1, UINT32 w2)
2{
3   int j;
4   int xleft, xright, xleft_inc, xright_inc;
5   int xstart, xend;
6   int flip = (w1 & 0x800000) ? 1 : 0;
7
8   INT32 yl, ym, yh;
9   INT32 xl, xm, xh;
10   INT32 dxldy, dxhdy, dxmdy;
11   UINT32 w3, w4, w5, w6, w7, w8;
12
13   int k = 0;
14
15   INT32 limcvg = 0;
16   INT32 startcvg = 0;
17
18   int sign_dxldy = 0;
19   int sign_dxmdy = 0;
20   int samesign = 0;
21
22   int sign_dxhdy = 0;
23
24   int xfrac = 0;
25
26   int m_inc;
27   UINT32 min=0, max=3;
28   INT32 maxxmx = 0, minxmx = 0, maxxhx = 0, minxhx = 0;
29
30   int spix = 0; // Current subpixel
31   int ycur;
32   int ylfar;
33   int ldflag;
34   int yhpix;
35   int ympix;
36   int ylpix;
37
38#define addleft(x) addleftcvg(x,k)
39#define addright(x) addrightcvg(x,k)
40
41   w3 = rdp_cmd_data[rdp_cmd_cur+2];
42   w4 = rdp_cmd_data[rdp_cmd_cur+3];
43   w5 = rdp_cmd_data[rdp_cmd_cur+4];
44   w6 = rdp_cmd_data[rdp_cmd_cur+5];
45   w7 = rdp_cmd_data[rdp_cmd_cur+6];
46   w8 = rdp_cmd_data[rdp_cmd_cur+7];
47
48   yl = (w1 & 0x3fff);
49   ym = ((w2 >> 16) & 0x3fff);
50   yh = ((w2 >>  0) & 0x3fff);
51   xl = (INT32)(w3 & 0x3fffffff);
52   xh = (INT32)(w5 & 0x3fffffff);
53   xm = (INT32)(w7 & 0x3fffffff);
54   // Inverse slopes in 16.16 format
55   dxldy = (INT32)(w4);
56   dxhdy = (INT32)(w6);
57   dxmdy = (INT32)(w8);
58
59   max_level = ((w1 >> 19) & 7);
60
61   if (yl & 0x2000)  yl |= 0xffffc000;
62   if (ym & 0x2000)  ym |= 0xffffc000;
63   if (yh & 0x2000)  yh |= 0xffffc000;
64
65   if (xl & 0x20000000)  xl |= 0xc0000000;
66   if (xm & 0x20000000)  xm |= 0xc0000000;
67   if (xh & 0x20000000)  xh |= 0xc0000000;
68
69   span[0].dymax = 0;
70
71   xleft_inc = dxmdy >> 2;
72   xright_inc = dxhdy >> 2;
73
74   xright = xh;
75   xleft = xm;
76
77   limcvg = ((yl>>2) <= 1023) ? (yl>>2) : 1023; // Needed by 40 Winks
78   if (limcvg < 0)
79   {
80      limcvg = 0;
81   }
82
83   startcvg = ((yh>>2)>=0) ? (yh>>2) : 0;
84   for (k = startcvg; k <= limcvg; k++)
85   {
86      memset((void*)&span[k].cvg[0],0,640);
87   }
88
89   sign_dxldy = (dxldy & 0x80000000) ? 1 : 0;
90   sign_dxmdy = (dxmdy & 0x80000000) ? 1 : 0;
91   samesign = !(sign_dxldy ^ sign_dxmdy);
92
93   sign_dxhdy = (dxhdy & 0x80000000) ? 1 : 0;
94
95   m_inc = flip ? 1 : -1;
96
97   ycur =   yh & ~3;
98   ylfar = yl | 3;
99   ldflag = (sign_dxhdy ^ flip) ? 0 : 3;
100   yhpix = yh >> 2;
101   ympix = ym >> 2;
102   ylpix = yl >> 2;
103
104   for (k = ycur; k <= ylfar; k++)
105   {
106      if (k == ym)
107      {
108         xleft = xl;
109         xleft_inc = dxldy >> 2;
110      }
111
112      xstart = xleft >> 16;
113      xend = xright >> 16;
114      j = k >> 2;
115      spix = k & 3;
116
117      if (k >= 0 && k < 0x1000)
118      {
119         int m = 0;
120         int n = 0;
121         int length = 0;
122         min = 0; max = 3;
123         if (j == yhpix)
124         {
125            min = yh & 3;
126         }
127         if (j == ylpix)
128         {
129            max = yl & 3;
130         }
131         if (spix >= min && spix <= max)
132         {
133            if (spix == min)
134            {
135               minxmx = maxxmx = xstart;
136               minxhx = maxxhx = xend;
137            }
138            else
139            {
140               minxmx = (xstart < minxmx) ? xstart : minxmx;
141               maxxmx = (xstart > maxxmx) ? xstart : maxxmx;
142               minxhx = (xend < minxhx) ? xend : minxhx;
143               maxxhx = (xend > maxxhx) ? xend : maxxhx;
144            }
145         }
146
147         if (spix == max)
148         {
149            if (flip)
150            {
151               span[j].lx = maxxmx;
152               span[j].rx = minxhx;
153            }
154            else
155            {
156               span[j].lx = minxmx;
157               span[j].rx = maxxhx;
158            }
159         }
160
161         length = flip ? (xstart - xend) : (xend - xstart);
162
163         if (spix == ldflag)
164         {
165            xfrac = ((xright >> 8) & 0xff);
166         }
167
168         m = flip ? (xend+1) : (xend-1);
169
170         if (k >= yh && length >= 0 && k <= yl)
171         {
172            if (xstart>=0 && xstart <1024)
173            {
174               if (!flip)
175               {
176                  span[j].cvg[xstart] += addleft(xleft);
177               }
178               else
179               {
180                  span[j].cvg[xstart] += addright(xleft);
181               }
182            }
183            if (xend>=0 && xend<1024)
184            {
185               if (xstart != xend)
186               {
187                  if (!flip)
188                  {
189                     span[j].cvg[xend] += addright(xright);
190                  }
191                  else
192                  {
193                     span[j].cvg[xend] += addleft(xright);
194                  }
195               }
196               else
197               {
198                  if (!flip)
199                  {
200                     span[j].cvg[xend] -= (2 - addright(xright));
201                  }
202                  else
203                  {
204                     span[j].cvg[xend] -= (2 - addleft(xright));
205                  }
206                  if (span[j].cvg[xend] > 200)
207                  {
208                     span[j].cvg[xend] = 0;
209                  }
210               }
211            }
212            for (n = 0; n < (length - 1); n++)
213            {
214               if (m>=0 && m < 640)
215               {
216                  span[j].cvg[m] += 2;
217               }
218
219               m += m_inc;
220            }
221         }
222      }
223
224      xleft += xleft_inc;
225      xright += xright_inc;
226   }
227
228   switch (fb_size) // 8bpp needs to be implemented
229   {
230      case PIXEL_SIZE_16BIT:
231         if(flip)
232         {
233            render_spans_16_ns_nt_nz_f(yh>>2, yl>>2, &tile[0]); break;
234         }
235         else
236         {
237            render_spans_16_ns_nt_nz_nf(yh>>2, yl>>2, &tile[0]); break;
238         }
239      case PIXEL_SIZE_32BIT:   render_spans_32(yh>>2, yl>>2, &tile[0], 0, 0, 0, flip); break;
240      default: break; // V-Rally2 does this, fb_size=0
241   }
242}
243
244static void triangle_ns_nt_z(UINT32 w1, UINT32 w2)
245{
246   int j;
247   int xleft, xright, xleft_inc, xright_inc;
248   int xstart, xend;
249   int z = 0;
250   int dzdx = 0;
251   int dzdy = 0;
252   int dzde = 0;
253   int tilenum;
254   int flip = (w1 & 0x800000) ? 1 : 0;
255
256   INT32 yl, ym, yh;
257   INT32 xl, xm, xh;
258   INT32 dxldy, dxhdy, dxmdy;
259   int dzdy_dz, dzdx_dz;
260   UINT32 w3, w4, w5, w6, w7, w8;
261
262   int k = 0;
263
264   INT32 limcvg = 0;
265   INT32 startcvg = 0;
266
267   int sign_dxldy = 0;
268   int sign_dxmdy = 0;
269   int samesign = 0;
270
271   int dzdiff = 0;
272   int sign_dxhdy = 0;
273
274   int dzdeh = 0, dzdyh = 0;
275   int do_offset = 0;
276
277   int xfrac = 0;
278   int dzeoff = 0;
279
280   int dzdxh = 0;
281
282   int m_inc;
283   UINT32 min=0, max=3;
284   INT32 maxxmx = 0, minxmx = 0, maxxhx = 0, minxhx = 0;
285
286   int spix = 0; // Current subpixel
287   int ycur;
288   int ylfar;
289   int ldflag;
290   int yhpix;
291   int ympix;
292   int ylpix;
293
294   int zbuffer_base = rdp_cmd_cur + 8;
295
296   w3 = rdp_cmd_data[rdp_cmd_cur+2];
297   w4 = rdp_cmd_data[rdp_cmd_cur+3];
298   w5 = rdp_cmd_data[rdp_cmd_cur+4];
299   w6 = rdp_cmd_data[rdp_cmd_cur+5];
300   w7 = rdp_cmd_data[rdp_cmd_cur+6];
301   w8 = rdp_cmd_data[rdp_cmd_cur+7];
302
303   yl = (w1 & 0x3fff);
304   ym = ((w2 >> 16) & 0x3fff);
305   yh = ((w2 >>  0) & 0x3fff);
306   xl = (INT32)(w3 & 0x3fffffff);
307   xh = (INT32)(w5 & 0x3fffffff);
308   xm = (INT32)(w7 & 0x3fffffff);
309   // Inverse slopes in 16.16 format
310   dxldy = (INT32)(w4);
311   dxhdy = (INT32)(w6);
312   dxmdy = (INT32)(w8);
313
314   max_level = ((w1 >> 19) & 7);
315   tilenum = (w1 >> 16) & 0x7;
316
317   if (yl & 0x2000)  yl |= 0xffffc000;
318   if (ym & 0x2000)  ym |= 0xffffc000;
319   if (yh & 0x2000)  yh |= 0xffffc000;
320
321   if (xl & 0x20000000)  xl |= 0xc0000000;
322   if (xm & 0x20000000)  xm |= 0xc0000000;
323   if (xh & 0x20000000)  xh |= 0xc0000000;
324
325   z    = rdp_cmd_data[zbuffer_base+0];
326   dzdx = rdp_cmd_data[zbuffer_base+1];
327   dzde = rdp_cmd_data[zbuffer_base+2];
328   dzdy = rdp_cmd_data[zbuffer_base+3];
329
330   span[0].dz.w = dzdx;
331   dzdy_dz = (dzdy >> 16) & 0xffff;
332   dzdx_dz = (dzdx >> 16) & 0xffff;
333   span[0].dzpix = ((dzdy_dz & 0x8000) ? ((~dzdy_dz) & 0x7fff) : dzdy_dz) + ((dzdx_dz & 0x8000) ? ((~dzdx_dz) & 0x7fff) : dzdx_dz);
334   span[0].dzpix = normalize_dzpix(span[0].dzpix);
335
336   xleft_inc = dxmdy >> 2;
337   xright_inc = dxhdy >> 2;
338
339   xright = xh;
340   xleft = xm;
341
342   limcvg = ((yl>>2) <= 1023) ? (yl>>2) : 1023; // Needed by 40 Winks
343   if (limcvg < 0)
344   {
345      limcvg = 0;
346   }
347
348   startcvg = ((yh>>2)>=0) ? (yh>>2) : 0;
349   for (k = startcvg; k <= limcvg; k++)
350   {
351      memset((void*)&span[k].cvg[0],0,640);
352   }
353
354   sign_dxldy = (dxldy & 0x80000000) ? 1 : 0;
355   sign_dxmdy = (dxmdy & 0x80000000) ? 1 : 0;
356   samesign = !(sign_dxldy ^ sign_dxmdy);
357
358   sign_dxhdy = (dxhdy & 0x80000000) ? 1 : 0;
359
360   do_offset = !(sign_dxhdy ^ (flip));
361
362   if (do_offset)
363   {
364      dzdeh = dzde >> 9;   dzdyh = dzdy >> 9;
365
366      dzdiff = (dzdeh*3 - dzdyh*3) << 7;
367   }
368   else
369   {
370      dzdiff = 0;
371   }
372
373   if (do_offset)
374   {
375      dzeoff = (dzdeh*3) << 7;
376   }
377   else
378   {
379      dzeoff = 0;
380   }
381
382#define addleft(x) addleftcvg(x,k)
383#define addright(x) addrightcvg(x,k)
384#define setvalues() {               \
385         addvalues();            \
386         adjust_attr();   \
387}
388
389   dzdxh = dzdx >> 8;
390
391#define adjust_attr()      \
392{                     \
393         span[j].z.w = z + dzdiff - (xfrac * dzdxh);            \
394}
395
396#define addvalues() {   \
397         z += dzde; \
398}
399
400   m_inc = flip ? 1 : -1;
401
402   ycur =   yh & ~3;
403   ylfar = yl | 3;
404   ldflag = (sign_dxhdy ^ flip) ? 0 : 3;
405   yhpix = yh >> 2;
406   ympix = ym >> 2;
407   ylpix = yl >> 2;
408
409   for (k = ycur; k <= ylfar; k++)
410   {
411      if (k == ym)
412      {
413         xleft = xl;
414         xleft_inc = dxldy >> 2;
415      }
416
417      xstart = xleft >> 16;
418      xend = xright >> 16;
419      j = k >> 2;
420      spix = k & 3;
421
422      if (k >= 0 && k < 0x1000)
423      {
424         int m = 0;
425         int n = 0;
426         int length = 0;
427         min = 0; max = 3;
428         if (j == yhpix)
429         {
430            min = yh & 3;
431         }
432         if (j == ylpix)
433         {
434            max = yl & 3;
435         }
436         if (spix >= min && spix <= max)
437         {
438            if (spix == min)
439            {
440               minxmx = maxxmx = xstart;
441               minxhx = maxxhx = xend;
442            }
443            else
444            {
445               minxmx = (xstart < minxmx) ? xstart : minxmx;
446               maxxmx = (xstart > maxxmx) ? xstart : maxxmx;
447               minxhx = (xend < minxhx) ? xend : minxhx;
448               maxxhx = (xend > maxxhx) ? xend : maxxhx;
449            }
450         }
451
452         if (spix == max)
453         {
454            if (flip)
455            {
456               span[j].lx = maxxmx;
457               span[j].rx = minxhx;
458            }
459            else
460            {
461               span[j].lx = minxmx;
462               span[j].rx = maxxhx;
463            }
464         }
465
466         length = flip ? (xstart - xend) : (xend - xstart);
467
468         if (spix == ldflag)
469         {
470            xfrac = ((xright >> 8) & 0xff);
471            adjust_attr();
472         }
473
474         m = flip ? (xend+1) : (xend-1);
475
476         if (k >= yh && length >= 0 && k <= yl)
477         {
478            if (xstart>=0 && xstart <1024)
479            {
480               if (!flip)
481               {
482                  span[j].cvg[xstart] += addleft(xleft);
483               }
484               else
485               {
486                  span[j].cvg[xstart] += addright(xleft);
487               }
488            }
489            if (xend>=0 && xend<1024)
490            {
491               if (xstart != xend)
492               {
493                  if (!flip)
494                  {
495                     span[j].cvg[xend] += addright(xright);
496                  }
497                  else
498                  {
499                     span[j].cvg[xend] += addleft(xright);
500                  }
501               }
502               else
503               {
504                  if (!flip)
505                  {
506                     span[j].cvg[xend] -= (2 - addright(xright));
507                  }
508                  else
509                  {
510                     span[j].cvg[xend] -= (2 - addleft(xright));
511                  }
512                  if (span[j].cvg[xend] > 200)
513                  {
514                     span[j].cvg[xend] = 0;
515                  }
516               }
517            }
518            for (n = 0; n < (length - 1); n++)
519            {
520               if (m>=0 && m < 640)
521               {
522                  span[j].cvg[m] += 2;
523               }
524
525               m += m_inc;
526            }
527         }
528      }
529
530      if (spix == 3)
531      {
532         addvalues();
533      }
534      xleft += xleft_inc;
535      xright += xright_inc;
536   }
537
538   switch (fb_size) // 8bpp needs to be implemented
539   {
540      case PIXEL_SIZE_16BIT:
541         if(flip)
542         {
543            render_spans_16_ns_nt_z_f(yh>>2, yl>>2, &tile[0]); break;
544         }
545         else
546         {
547            render_spans_16_ns_nt_z_nf(yh>>2, yl>>2, &tile[0]); break;
548         }
549      case PIXEL_SIZE_32BIT:   render_spans_32(yh>>2, yl>>2, &tile[tilenum], 0, 0, 1, flip); break;
550      default: break; // V-Rally2 does this, fb_size=0
551   }
552}
553#undef addvalues
554#undef adjust_attr
555#undef addleft
556#undef addright
557#undef setvalues
558
559static void triangle_ns_t_nz(UINT32 w1, UINT32 w2)
560{
561   int j;
562   int xleft, xright, xleft_inc, xright_inc;
563   int xstart, xend;
564   int s = 0, t = 0, w = 0;
565   int dsdx = 0, dtdx = 0, dwdx = 0;
566   int dsdy = 0, dtdy = 0, dwdy = 0;
567   int dsde = 0, dtde = 0, dwde = 0;
568   int tilenum;
569   int flip = (w1 & 0x800000) ? 1 : 0;
570
571   INT32 yl, ym, yh;
572   INT32 xl, xm, xh;
573   INT32 dxldy, dxhdy, dxmdy;
574   UINT32 w3, w4, w5, w6, w7, w8;
575
576   int k = 0;
577
578   INT32 limcvg = 0;
579   INT32 startcvg = 0;
580
581   int sign_dxldy = 0;
582   int sign_dxmdy = 0;
583   int samesign = 0;
584
585   int dsdiff = 0, dtdiff = 0, dwdiff = 0;
586   int sign_dxhdy = 0;
587
588   int dsdeh = 0, dtdeh = 0, dwdeh = 0, dsdyh = 0, dtdyh = 0, dwdyh = 0;
589   int do_offset = 0;
590
591   int xfrac = 0;
592   int dseoff = 0, dteoff = 0, dweoff = 0;
593
594   int dsdxh = 0, dtdxh = 0, dwdxh = 0;
595
596   int m_inc;
597   UINT32 min=0, max=3;
598   INT32 maxxmx = 0, minxmx = 0, maxxhx = 0, minxhx = 0;
599
600   int spix = 0; // Current subpixel
601   int ycur;
602   int ylfar;
603   int ldflag;
604   int yhpix;
605   int ympix;
606   int ylpix;
607
608   int texture_base = rdp_cmd_cur + 8;
609
610   w3 = rdp_cmd_data[rdp_cmd_cur+2];
611   w4 = rdp_cmd_data[rdp_cmd_cur+3];
612   w5 = rdp_cmd_data[rdp_cmd_cur+4];
613   w6 = rdp_cmd_data[rdp_cmd_cur+5];
614   w7 = rdp_cmd_data[rdp_cmd_cur+6];
615   w8 = rdp_cmd_data[rdp_cmd_cur+7];
616
617   yl = (w1 & 0x3fff);
618   ym = ((w2 >> 16) & 0x3fff);
619   yh = ((w2 >>  0) & 0x3fff);
620   xl = (INT32)(w3 & 0x3fffffff);
621   xh = (INT32)(w5 & 0x3fffffff);
622   xm = (INT32)(w7 & 0x3fffffff);
623   // Inverse slopes in 16.16 format
624   dxldy = (INT32)(w4);
625   dxhdy = (INT32)(w6);
626   dxmdy = (INT32)(w8);
627
628   max_level = ((w1 >> 19) & 7);
629   tilenum = (w1 >> 16) & 0x7;
630
631   if (yl & 0x2000)  yl |= 0xffffc000;
632   if (ym & 0x2000)  ym |= 0xffffc000;
633   if (yh & 0x2000)  yh |= 0xffffc000;
634
635   if (xl & 0x20000000)  xl |= 0xc0000000;
636   if (xm & 0x20000000)  xm |= 0xc0000000;
637   if (xh & 0x20000000)  xh |= 0xc0000000;
638
639   s = 0;   t = 0;   w = 0;
640
641   s    = (rdp_cmd_data[texture_base+0 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+4 ] >> 16) & 0x0000ffff);
642   t    = ((rdp_cmd_data[texture_base+0 ] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+4 ] & 0x0000ffff);
643   w    = (rdp_cmd_data[texture_base+1 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+5 ] >> 16) & 0x0000ffff);
644   dsdx = (rdp_cmd_data[texture_base+2 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+6 ] >> 16) & 0x0000ffff);
645   dtdx = ((rdp_cmd_data[texture_base+2 ] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+6 ] & 0x0000ffff);
646   dwdx = (rdp_cmd_data[texture_base+3 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+7 ] >> 16) & 0x0000ffff);
647   dsde = (rdp_cmd_data[texture_base+8 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+12] >> 16) & 0x0000ffff);
648   dtde = ((rdp_cmd_data[texture_base+8 ] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+12] & 0x0000ffff);
649   dwde = (rdp_cmd_data[texture_base+9 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+13] >> 16) & 0x0000ffff);
650   dsdy = (rdp_cmd_data[texture_base+10] & 0xffff0000) | ((rdp_cmd_data[texture_base+14] >> 16) & 0x0000ffff);
651   dtdy = ((rdp_cmd_data[texture_base+10] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+14] & 0x0000ffff);
652   dwdy = (rdp_cmd_data[texture_base+11] & 0xffff0000) | ((rdp_cmd_data[texture_base+15] >> 16) & 0x0000ffff);
653
654   span[0].ds.w = dsdx;
655   span[0].dt.w = dtdx;
656   span[0].dw.w = dwdx;
657
658   xleft_inc = dxmdy >> 2;
659   xright_inc = dxhdy >> 2;
660
661   xright = xh;
662   xleft = xm;
663
664   limcvg = ((yl>>2) <= 1023) ? (yl>>2) : 1023; // Needed by 40 Winks
665   if (limcvg < 0)
666   {
667      limcvg = 0;
668   }
669
670   startcvg = ((yh>>2)>=0) ? (yh>>2) : 0;
671   for (k = startcvg; k <= limcvg; k++)
672   {
673      memset((void*)&span[k].cvg[0],0,640);
674   }
675
676   sign_dxldy = (dxldy & 0x80000000) ? 1 : 0;
677   sign_dxmdy = (dxmdy & 0x80000000) ? 1 : 0;
678   samesign = !(sign_dxldy ^ sign_dxmdy);
679
680   sign_dxhdy = (dxhdy & 0x80000000) ? 1 : 0;
681
682   do_offset = !(sign_dxhdy ^ (flip));
683
684   if (do_offset)
685   {
686      dsdeh = dsde >> 9;   dsdyh = dsdy >> 9;
687      dtdeh = dtde >> 9;   dtdyh = dtdy >> 9;
688      dwdeh = dwde >> 9;   dwdyh = dwdy >> 9;
689
690      dsdiff = (dsdeh*3 - dsdyh*3) << 7;
691      dtdiff = (dtdeh*3 - dtdyh*3) << 7;
692      dwdiff = (dwdeh*3 - dwdyh*3) << 7;
693   }
694   else
695   {
696      dsdiff = dtdiff = dwdiff = 0;
697   }
698
699   if (do_offset)
700   {
701      dseoff = (dsdeh*3) << 7;
702      dteoff = (dtdeh*3) << 7;
703      dweoff = (dwdeh*3) << 7;
704   }
705   else
706   {
707      dseoff = dteoff = dweoff;
708   }
709
710#define addleft(x) addleftcvg(x,k)
711#define addright(x) addrightcvg(x,k)
712#define setvalues() {               \
713         addvalues();            \
714         adjust_attr();   \
715}
716
717   dsdxh = dsdx >> 8;
718   dtdxh = dtdx >> 8;
719   dwdxh = dwdx >> 8;
720
721#define adjust_attr()      \
722{                     \
723         span[j].s.w = (s + dsdiff - (xfrac * dsdxh)) & ~0x1f;            \
724         span[j].t.w = (t + dtdiff - (xfrac * dtdxh)) & ~0x1f;            \
725         span[j].w.w = (w + dwdiff - (xfrac * dwdxh)) & ~0x1f;            \
726}
727
728#define addvalues() {   \
729         s += dsde;   \
730         t += dtde;   \
731         w += dwde; \
732}
733
734   m_inc = flip ? 1 : -1;
735
736   ycur =   yh & ~3;
737   ylfar = yl | 3;
738   ldflag = (sign_dxhdy ^ flip) ? 0 : 3;
739   yhpix = yh >> 2;
740   ympix = ym >> 2;
741   ylpix = yl >> 2;
742
743   for (k = ycur; k <= ylfar; k++)
744   {
745      if (k == ym)
746      {
747         xleft = xl;
748         xleft_inc = dxldy >> 2;
749      }
750
751      xstart = xleft >> 16;
752      xend = xright >> 16;
753      j = k >> 2;
754      spix = k & 3;
755
756      if (k >= 0 && k < 0x1000)
757      {
758         int m = 0;
759         int n = 0;
760         int length = 0;
761         min = 0; max = 3;
762         if (j == yhpix)
763         {
764            min = yh & 3;
765         }
766         if (j == ylpix)
767         {
768            max = yl & 3;
769         }
770         if (spix >= min && spix <= max)
771         {
772            if (spix == min)
773            {
774               minxmx = maxxmx = xstart;
775               minxhx = maxxhx = xend;
776            }
777            else
778            {
779               minxmx = (xstart < minxmx) ? xstart : minxmx;
780               maxxmx = (xstart > maxxmx) ? xstart : maxxmx;
781               minxhx = (xend < minxhx) ? xend : minxhx;
782               maxxhx = (xend > maxxhx) ? xend : maxxhx;
783            }
784         }
785
786         if (spix == max)
787         {
788            if (flip)
789            {
790               span[j].lx = maxxmx;
791               span[j].rx = minxhx;
792            }
793            else
794            {
795               span[j].lx = minxmx;
796               span[j].rx = maxxhx;
797            }
798         }
799
800         length = flip ? (xstart - xend) : (xend - xstart);
801
802         if (spix == ldflag)
803         {
804            xfrac = ((xright >> 8) & 0xff);
805            adjust_attr();
806         }
807
808         m = flip ? (xend+1) : (xend-1);
809
810         if (k >= yh && length >= 0 && k <= yl)
811         {
812            if (xstart>=0 && xstart <1024)
813            {
814               if (!flip)
815               {
816                  span[j].cvg[xstart] += addleft(xleft);
817               }
818               else
819               {
820                  span[j].cvg[xstart] += addright(xleft);
821               }
822            }
823            if (xend>=0 && xend<1024)
824            {
825               if (xstart != xend)
826               {
827                  if (!flip)
828                  {
829                     span[j].cvg[xend] += addright(xright);
830                  }
831                  else
832                  {
833                     span[j].cvg[xend] += addleft(xright);
834                  }
835               }
836               else
837               {
838                  if (!flip)
839                  {
840                     span[j].cvg[xend] -= (2 - addright(xright));
841                  }
842                  else
843                  {
844                     span[j].cvg[xend] -= (2 - addleft(xright));
845                  }
846                  if (span[j].cvg[xend] > 200)
847                  {
848                     span[j].cvg[xend] = 0;
849                  }
850               }
851            }
852            for (n = 0; n < (length - 1); n++)
853            {
854               if (m>=0 && m < 640)
855               {
856                  span[j].cvg[m] += 2;
857               }
858
859               m += m_inc;
860            }
861         }
862      }
863
864      if (spix == 3)
865      {
866         addvalues();
867      }
868      xleft += xleft_inc;
869      xright += xright_inc;
870   }
871
872   switch (fb_size) // 8bpp needs to be implemented
873   {
874      case PIXEL_SIZE_16BIT:
875         if(flip)
876         {
877            render_spans_16_ns_t_nz_f(yh>>2, yl>>2, &tile[0]); break;
878         }
879         else
880         {
881            render_spans_16_ns_t_nz_nf(yh>>2, yl>>2, &tile[0]); break;
882         }
883      case PIXEL_SIZE_32BIT:   render_spans_32(yh>>2, yl>>2, &tile[tilenum], 0, 1, 0, flip); break;
884      default: break; // V-Rally2 does this, fb_size=0
885   }
886}
887#undef addvalues
888#undef adjust_attr
889#undef addleft
890#undef addright
891#undef setvalues
892
893static void triangle_ns_t_z(UINT32 w1, UINT32 w2)
894{
895   int j;
896   int xleft, xright, xleft_inc, xright_inc;
897   int xstart, xend;
898   int z = 0, s = 0, t = 0, w = 0;
899   int dzdx = 0, dsdx = 0, dtdx = 0, dwdx = 0;
900   int dzdy = 0, dsdy = 0, dtdy = 0, dwdy = 0;
901   int dzde = 0, dsde = 0, dtde = 0, dwde = 0;
902   int tilenum;
903   int flip = (w1 & 0x800000) ? 1 : 0;
904
905   INT32 yl, ym, yh;
906   INT32 xl, xm, xh;
907   INT32 dxldy, dxhdy, dxmdy;
908   int dzdy_dz, dzdx_dz;
909   int dsdylod, dtdylod;
910   UINT32 w3, w4, w5, w6, w7, w8;
911
912   int k = 0;
913
914   INT32 limcvg = 0;
915   INT32 startcvg = 0;
916
917   int sign_dxldy = 0;
918   int sign_dxmdy = 0;
919   int samesign = 0;
920
921   int dsdiff = 0, dtdiff = 0, dwdiff = 0, dzdiff = 0;
922   int sign_dxhdy = 0;
923
924   int dsdeh = 0, dtdeh = 0, dwdeh = 0, dzdeh = 0, dsdyh = 0, dtdyh = 0, dwdyh = 0, dzdyh = 0;
925   int do_offset = 0;
926
927   int xfrac = 0;
928   int dseoff = 0, dteoff = 0, dweoff = 0, dzeoff = 0;
929
930   int dsdxh = 0, dtdxh = 0, dwdxh = 0, dzdxh = 0;
931
932   int m_inc;
933   UINT32 min=0, max=3;
934   INT32 maxxmx = 0, minxmx = 0, maxxhx = 0, minxhx = 0;
935
936   int spix = 0; // Current subpixel
937   int ycur;
938   int ylfar;
939   int ldflag;
940   int yhpix;
941   int ympix;
942   int ylpix;
943
944   int texture_base = rdp_cmd_cur + 8;
945   int zbuffer_base = rdp_cmd_cur + 8;
946
947   zbuffer_base += 16;
948
949   w3 = rdp_cmd_data[rdp_cmd_cur+2];
950   w4 = rdp_cmd_data[rdp_cmd_cur+3];
951   w5 = rdp_cmd_data[rdp_cmd_cur+4];
952   w6 = rdp_cmd_data[rdp_cmd_cur+5];
953   w7 = rdp_cmd_data[rdp_cmd_cur+6];
954   w8 = rdp_cmd_data[rdp_cmd_cur+7];
955
956   yl = (w1 & 0x3fff);
957   ym = ((w2 >> 16) & 0x3fff);
958   yh = ((w2 >>  0) & 0x3fff);
959   xl = (INT32)(w3 & 0x3fffffff);
960   xh = (INT32)(w5 & 0x3fffffff);
961   xm = (INT32)(w7 & 0x3fffffff);
962   // Inverse slopes in 16.16 format
963   dxldy = (INT32)(w4);
964   dxhdy = (INT32)(w6);
965   dxmdy = (INT32)(w8);
966
967   max_level = ((w1 >> 19) & 7);
968   tilenum = (w1 >> 16) & 0x7;
969
970   if (yl & 0x2000)  yl |= 0xffffc000;
971   if (ym & 0x2000)  ym |= 0xffffc000;
972   if (yh & 0x2000)  yh |= 0xffffc000;
973
974   if (xl & 0x20000000)  xl |= 0xc0000000;
975   if (xm & 0x20000000)  xm |= 0xc0000000;
976   if (xh & 0x20000000)  xh |= 0xc0000000;
977
978   z = 0;
979   s = 0;   t = 0;   w = 0;
980
981   s    = (rdp_cmd_data[texture_base+0 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+4 ] >> 16) & 0x0000ffff);
982   t    = ((rdp_cmd_data[texture_base+0 ] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+4 ] & 0x0000ffff);
983   w    = (rdp_cmd_data[texture_base+1 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+5 ] >> 16) & 0x0000ffff);
984   dsdx = (rdp_cmd_data[texture_base+2 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+6 ] >> 16) & 0x0000ffff);
985   dtdx = ((rdp_cmd_data[texture_base+2 ] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+6 ] & 0x0000ffff);
986   dwdx = (rdp_cmd_data[texture_base+3 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+7 ] >> 16) & 0x0000ffff);
987   dsde = (rdp_cmd_data[texture_base+8 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+12] >> 16) & 0x0000ffff);
988   dtde = ((rdp_cmd_data[texture_base+8 ] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+12] & 0x0000ffff);
989   dwde = (rdp_cmd_data[texture_base+9 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+13] >> 16) & 0x0000ffff);
990   dsdy = (rdp_cmd_data[texture_base+10] & 0xffff0000) | ((rdp_cmd_data[texture_base+14] >> 16) & 0x0000ffff);
991   dtdy = ((rdp_cmd_data[texture_base+10] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+14] & 0x0000ffff);
992   dwdy = (rdp_cmd_data[texture_base+11] & 0xffff0000) | ((rdp_cmd_data[texture_base+15] >> 16) & 0x0000ffff);
993   z    = rdp_cmd_data[zbuffer_base+0];
994   dzdx = rdp_cmd_data[zbuffer_base+1];
995   dzde = rdp_cmd_data[zbuffer_base+2];
996   dzdy = rdp_cmd_data[zbuffer_base+3];
997
998   span[0].ds.w = dsdx;
999   span[0].dt.w = dtdx;
1000   span[0].dw.w = dwdx;
1001   span[0].dz.w = dzdx;
1002   dzdy_dz = (dzdy >> 16) & 0xffff;
1003   dzdx_dz = (dzdx >> 16) & 0xffff;
1004   span[0].dzpix = ((dzdy_dz & 0x8000) ? ((~dzdy_dz) & 0x7fff) : dzdy_dz) + ((dzdx_dz & 0x8000) ? ((~dzdx_dz) & 0x7fff) : dzdx_dz);
1005   span[0].dzpix = normalize_dzpix(span[0].dzpix);
1006   dsdylod = dsdy >> 16;
1007   dtdylod = dtdy >> 16;
1008   if (dsdylod & 0x20000)
1009   {
1010      dsdylod = ~dsdylod & 0x1ffff;
1011   }
1012   if (dtdylod & 0x20000)
1013   {
1014      dtdylod = ~dtdylod & 0x1ffff;
1015   }
1016   span[0].dymax = (dsdylod > dtdylod)? dsdylod : dtdylod;
1017
1018   xleft_inc = dxmdy >> 2;
1019   xright_inc = dxhdy >> 2;
1020
1021   xright = xh;
1022   xleft = xm;
1023
1024   limcvg = ((yl>>2) <= 1023) ? (yl>>2) : 1023; // Needed by 40 Winks
1025   if (limcvg < 0)
1026   {
1027      limcvg = 0;
1028   }
1029
1030   startcvg = ((yh>>2)>=0) ? (yh>>2) : 0;
1031   for (k = startcvg; k <= limcvg; k++)
1032   {
1033      memset((void*)&span[k].cvg[0],0,640);
1034   }
1035
1036   sign_dxldy = (dxldy & 0x80000000) ? 1 : 0;
1037   sign_dxmdy = (dxmdy & 0x80000000) ? 1 : 0;
1038   samesign = !(sign_dxldy ^ sign_dxmdy);
1039
1040   sign_dxhdy = (dxhdy & 0x80000000) ? 1 : 0;
1041
1042   do_offset = !(sign_dxhdy ^ (flip));
1043
1044   if (do_offset)
1045   {
1046      dsdeh = dsde >> 9;   dsdyh = dsdy >> 9;
1047      dtdeh = dtde >> 9;   dtdyh = dtdy >> 9;
1048      dwdeh = dwde >> 9;   dwdyh = dwdy >> 9;
1049      dzdeh = dzde >> 9;   dzdyh = dzdy >> 9;
1050
1051      dsdiff = (dsdeh*3 - dsdyh*3) << 7;
1052      dtdiff = (dtdeh*3 - dtdyh*3) << 7;
1053      dwdiff = (dwdeh*3 - dwdyh*3) << 7;
1054      dzdiff = (dzdeh*3 - dzdyh*3) << 7;
1055   }
1056   else
1057   {
1058      dsdiff = dtdiff = dwdiff = dzdiff = 0;
1059   }
1060
1061   if (do_offset)
1062   {
1063      dseoff = (dsdeh*3) << 7;
1064      dteoff = (dtdeh*3) << 7;
1065      dweoff = (dwdeh*3) << 7;
1066      dzeoff = (dzdeh*3) << 7;
1067   }
1068   else
1069   {
1070      dseoff = dteoff = dweoff = dzeoff = 0;
1071   }
1072
1073#define addleft(x) addleftcvg(x,k)
1074#define addright(x) addrightcvg(x,k)
1075#define setvalues() {               \
1076         addvalues();            \
1077         adjust_attr();   \
1078}
1079
1080   dsdxh = dsdx >> 8;
1081   dtdxh = dtdx >> 8;
1082   dwdxh = dwdx >> 8;
1083   dzdxh = dzdx >> 8;
1084
1085#define adjust_attr()      \
1086{                     \
1087         span[j].s.w = (s + dsdiff - (xfrac * dsdxh)) & ~0x1f;            \
1088         span[j].t.w = (t + dtdiff - (xfrac * dtdxh)) & ~0x1f;            \
1089         span[j].w.w = (w + dwdiff - (xfrac * dwdxh)) & ~0x1f;            \
1090         span[j].z.w = z + dzdiff - (xfrac * dzdxh);            \
1091}
1092
1093#define addvalues() {   \
1094         s += dsde;   \
1095         t += dtde;   \
1096         w += dwde; \
1097         z += dzde; \
1098}
1099
1100   m_inc = flip ? 1 : -1;
1101
1102   ycur =   yh & ~3;
1103   ylfar = yl | 3;
1104   ldflag = (sign_dxhdy ^ flip) ? 0 : 3;
1105   yhpix = yh >> 2;
1106   ympix = ym >> 2;
1107   ylpix = yl >> 2;
1108
1109   for (k = ycur; k <= ylfar; k++)
1110   {
1111      if (k == ym)
1112      {
1113         xleft = xl;
1114         xleft_inc = dxldy >> 2;
1115      }
1116
1117      xstart = xleft >> 16;
1118      xend = xright >> 16;
1119      j = k >> 2;
1120      spix = k & 3;
1121
1122      if (k >= 0 && k < 0x1000)
1123      {
1124         int m = 0;
1125         int n = 0;
1126         int length = 0;
1127         min = 0; max = 3;
1128         if (j == yhpix)
1129         {
1130            min = yh & 3;
1131         }
1132         if (j == ylpix)
1133         {
1134            max = yl & 3;
1135         }
1136         if (spix >= min && spix <= max)
1137         {
1138            if (spix == min)
1139            {
1140               minxmx = maxxmx = xstart;
1141               minxhx = maxxhx = xend;
1142            }
1143            else
1144            {
1145               minxmx = (xstart < minxmx) ? xstart : minxmx;
1146               maxxmx = (xstart > maxxmx) ? xstart : maxxmx;
1147               minxhx = (xend < minxhx) ? xend : minxhx;
1148               maxxhx = (xend > maxxhx) ? xend : maxxhx;
1149            }
1150         }
1151
1152         if (spix == max)
1153         {
1154            if (flip)
1155            {
1156               span[j].lx = maxxmx;
1157               span[j].rx = minxhx;
1158            }
1159            else
1160            {
1161               span[j].lx = minxmx;
1162               span[j].rx = maxxhx;
1163            }
1164         }
1165
1166         length = flip ? (xstart - xend) : (xend - xstart);
1167
1168         if (spix == ldflag)
1169         {
1170            xfrac = ((xright >> 8) & 0xff);
1171            adjust_attr();
1172         }
1173
1174         m = flip ? (xend+1) : (xend-1);
1175
1176         if (k >= yh && length >= 0 && k <= yl)
1177         {
1178            if (xstart>=0 && xstart <1024)
1179            {
1180               if (!flip)
1181               {
1182                  span[j].cvg[xstart] += addleft(xleft);
1183               }
1184               else
1185               {
1186                  span[j].cvg[xstart] += addright(xleft);
1187               }
1188            }
1189            if (xend>=0 && xend<1024)
1190            {
1191               if (xstart != xend)
1192               {
1193                  if (!flip)
1194                  {
1195                     span[j].cvg[xend] += addright(xright);
1196                  }
1197                  else
1198                  {
1199                     span[j].cvg[xend] += addleft(xright);
1200                  }
1201               }
1202               else
1203               {
1204                  if (!flip)
1205                  {
1206                     span[j].cvg[xend] -= (2 - addright(xright));
1207                  }
1208                  else
1209                  {
1210                     span[j].cvg[xend] -= (2 - addleft(xright));
1211                  }
1212                  if (span[j].cvg[xend] > 200)
1213                  {
1214                     span[j].cvg[xend] = 0;
1215                  }
1216               }
1217            }
1218            for (n = 0; n < (length - 1); n++)
1219            {
1220               if (m>=0 && m < 640)
1221               {
1222                  span[j].cvg[m] += 2;
1223               }
1224
1225               m += m_inc;
1226            }
1227         }
1228      }
1229
1230      if (spix == 3)
1231      {
1232         addvalues();
1233      }
1234      xleft += xleft_inc;
1235      xright += xright_inc;
1236   }
1237
1238   switch (fb_size) // 8bpp needs to be implemented
1239   {
1240      case PIXEL_SIZE_16BIT:
1241         if(flip)
1242         {
1243            render_spans_16_ns_t_z_f(yh>>2, yl>>2, &tile[0]); break;
1244         }
1245         else
1246         {
1247            render_spans_16_ns_t_z_nf(yh>>2, yl>>2, &tile[0]); break;
1248         }
1249      case PIXEL_SIZE_32BIT:   render_spans_32(yh>>2, yl>>2, &tile[tilenum], 0, 1, 1, flip); break;
1250      default: break; // V-Rally2 does this, fb_size=0
1251   }
1252}
1253#undef addvalues
1254#undef adjust_attr
1255#undef addleft
1256#undef addright
1257#undef setvalues
1258
1259static void triangle_s_nt_nz(UINT32 w1, UINT32 w2)
1260{
1261   int j;
1262   int xleft, xright, xleft_inc, xright_inc;
1263   int xstart, xend;
1264   int r = 0, g = 0, b = 0, a = 0;
1265   int dr, dg, db, da;
1266   int drdx = 0, dgdx = 0, dbdx = 0, dadx = 0;
1267   int drdy = 0, dgdy = 0, dbdy = 0, dady = 0;
1268   int drde = 0, dgde = 0, dbde = 0, dade = 0;
1269   int tilenum;
1270   int flip = (w1 & 0x800000) ? 1 : 0;
1271
1272   INT32 yl, ym, yh;
1273   INT32 xl, xm, xh;
1274   INT32 dxldy, dxhdy, dxmdy;
1275   UINT32 w3, w4, w5, w6, w7, w8;
1276
1277   int k = 0;
1278
1279   INT32 limcvg = 0;
1280   INT32 startcvg = 0;
1281
1282   int sign_dxldy = 0;
1283   int sign_dxmdy = 0;
1284   int samesign = 0;
1285
1286   int drdiff = 0, dgdiff = 0, dbdiff = 0, dadiff = 0;
1287   int sign_dxhdy = 0;
1288
1289   int drdeh = 0, dgdeh = 0, dbdeh = 0, dadeh = 0, drdyh = 0, dgdyh = 0, dbdyh = 0, dadyh = 0;
1290   int do_offset = 0;
1291
1292   int xfrac = 0;
1293   int dreoff = 0, dgeoff = 0, dbeoff = 0, daeoff = 0;
1294
1295   int drdxh = 0, dgdxh = 0, dbdxh = 0, dadxh = 0;
1296
1297   int m_inc;
1298   UINT32 min=0, max=3;
1299   INT32 maxxmx = 0, minxmx = 0, maxxhx = 0, minxhx = 0;
1300
1301   int spix = 0; // Current subpixel
1302   int ycur;
1303   int ylfar;
1304   int ldflag;
1305   int yhpix;
1306   int ympix;
1307   int ylpix;
1308
1309   int shade_base = rdp_cmd_cur + 8;
1310
1311   w3 = rdp_cmd_data[rdp_cmd_cur+2];
1312   w4 = rdp_cmd_data[rdp_cmd_cur+3];
1313   w5 = rdp_cmd_data[rdp_cmd_cur+4];
1314   w6 = rdp_cmd_data[rdp_cmd_cur+5];
1315   w7 = rdp_cmd_data[rdp_cmd_cur+6];
1316   w8 = rdp_cmd_data[rdp_cmd_cur+7];
1317
1318   yl = (w1 & 0x3fff);
1319   ym = ((w2 >> 16) & 0x3fff);
1320   yh = ((w2 >>  0) & 0x3fff);
1321   xl = (INT32)(w3 & 0x3fffffff);
1322   xh = (INT32)(w5 & 0x3fffffff);
1323   xm = (INT32)(w7 & 0x3fffffff);
1324   // Inverse slopes in 16.16 format
1325   dxldy = (INT32)(w4);
1326   dxhdy = (INT32)(w6);
1327   dxmdy = (INT32)(w8);
1328
1329   max_level = ((w1 >> 19) & 7);
1330   tilenum = (w1 >> 16) & 0x7;
1331
1332   if (yl & 0x2000)  yl |= 0xffffc000;
1333   if (ym & 0x2000)  ym |= 0xffffc000;
1334   if (yh & 0x2000)  yh |= 0xffffc000;
1335
1336   if (xl & 0x20000000)  xl |= 0xc0000000;
1337   if (xm & 0x20000000)  xm |= 0xc0000000;
1338   if (xh & 0x20000000)  xh |= 0xc0000000;
1339
1340   dr = 0;      dg = 0;      db = 0;      da = 0;
1341
1342   r    = (rdp_cmd_data[shade_base+0 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+4 ] >> 16) & 0x0000ffff);
1343   g    = ((rdp_cmd_data[shade_base+0 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+4 ] & 0x0000ffff);
1344   b    = (rdp_cmd_data[shade_base+1 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+5 ] >> 16) & 0x0000ffff);
1345   a    = ((rdp_cmd_data[shade_base+1 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+5 ] & 0x0000ffff);
1346   drdx = (rdp_cmd_data[shade_base+2 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+6 ] >> 16) & 0x0000ffff);
1347   dgdx = ((rdp_cmd_data[shade_base+2 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+6 ] & 0x0000ffff);
1348   dbdx = (rdp_cmd_data[shade_base+3 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+7 ] >> 16) & 0x0000ffff);
1349   dadx = ((rdp_cmd_data[shade_base+3 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+7 ] & 0x0000ffff);
1350   drde = (rdp_cmd_data[shade_base+8 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+12] >> 16) & 0x0000ffff);
1351   dgde = ((rdp_cmd_data[shade_base+8 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+12] & 0x0000ffff);
1352   dbde = (rdp_cmd_data[shade_base+9 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+13] >> 16) & 0x0000ffff);
1353   dade = ((rdp_cmd_data[shade_base+9 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+13] & 0x0000ffff);
1354   drdy = (rdp_cmd_data[shade_base+10] & 0xffff0000) | ((rdp_cmd_data[shade_base+14] >> 16) & 0x0000ffff);
1355   dgdy = ((rdp_cmd_data[shade_base+10] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+14] & 0x0000ffff);
1356   dbdy = (rdp_cmd_data[shade_base+11] & 0xffff0000) | ((rdp_cmd_data[shade_base+15] >> 16) & 0x0000ffff);
1357   dady = ((rdp_cmd_data[shade_base+11] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+15] & 0x0000ffff);
1358
1359   span[0].dr.w = drdx & ~0x1f;
1360   span[0].dg.w = dgdx & ~0x1f;
1361   span[0].db.w = dbdx & ~0x1f;
1362   span[0].da.w = dadx & ~0x1f;
1363
1364   xleft_inc = dxmdy >> 2;
1365   xright_inc = dxhdy >> 2;
1366
1367   xright = xh;
1368   xleft = xm;
1369
1370   limcvg = ((yl>>2) <= 1023) ? (yl>>2) : 1023; // Needed by 40 Winks
1371   if (limcvg < 0)
1372   {
1373      limcvg = 0;
1374   }
1375
1376   startcvg = ((yh>>2)>=0) ? (yh>>2) : 0;
1377   for (k = startcvg; k <= limcvg; k++)
1378   {
1379      memset((void*)&span[k].cvg[0],0,640);
1380   }
1381
1382   sign_dxldy = (dxldy & 0x80000000) ? 1 : 0;
1383   sign_dxmdy = (dxmdy & 0x80000000) ? 1 : 0;
1384   samesign = !(sign_dxldy ^ sign_dxmdy);
1385
1386   sign_dxhdy = (dxhdy & 0x80000000) ? 1 : 0;
1387
1388   do_offset = !(sign_dxhdy ^ (flip));
1389
1390   if (do_offset)
1391   {
1392      drdeh = drde >> 9;   drdyh = drdy >> 9;
1393      dgdeh = dgde >> 9;   dgdyh = dgdy >> 9;
1394      dbdeh = dbde >> 9;   dbdyh = dbdy >> 9;
1395      dadeh = dade >> 9;   dadyh = dady >> 9;
1396
1397      drdiff = (drdeh*3 - drdyh*3) << 7;
1398      dgdiff = (dgdeh*3 - dgdyh*3) << 7;
1399      dbdiff = (dbdeh*3 - dbdyh*3) << 7;
1400      dadiff = (dadeh*3 - dadyh*3) << 7;
1401   }
1402   else
1403   {
1404      drdiff = dgdiff = dbdiff = dadiff;
1405   }
1406
1407   if (do_offset)
1408   {
1409      dreoff = (drdeh*3) << 7;
1410      dgeoff = (dgdeh*3) << 7;
1411      dbeoff = (dbdeh*3) << 7;
1412      daeoff = (dadeh*3) << 7;
1413   }
1414   else
1415   {
1416      dreoff = dgeoff = dbeoff = daeoff;
1417   }
1418
1419#define addleft(x) addleftcvg(x,k)
1420#define addright(x) addrightcvg(x,k)
1421#define setvalues() {               \
1422         addvalues();            \
1423         adjust_attr();   \
1424}
1425
1426   drdxh = drdx >> 8;
1427   dgdxh = dgdx >> 8;
1428   dbdxh = dbdx >> 8;
1429   dadxh = dadx >> 8;
1430
1431#define adjust_attr()      \
1432{                     \
1433         span[j].r.w = r + drdiff - (xfrac * drdxh);            \
1434         span[j].g.w = g + dgdiff - (xfrac * dgdxh);            \
1435         span[j].b.w = b + dbdiff - (xfrac * dbdxh);            \
1436         span[j].a.w = a + dadiff - (xfrac * dadxh);            \
1437}
1438
1439#define addvalues() {   \
1440         r += drde; \
1441         g += dgde; \
1442         b += dbde; \
1443         a += dade; \
1444}
1445
1446   m_inc = flip ? 1 : -1;
1447
1448   ycur =   yh & ~3;
1449   ylfar = yl | 3;
1450   ldflag = (sign_dxhdy ^ flip) ? 0 : 3;
1451   yhpix = yh >> 2;
1452   ympix = ym >> 2;
1453   ylpix = yl >> 2;
1454
1455   for (k = ycur; k <= ylfar; k++)
1456   {
1457      if (k == ym)
1458      {
1459         xleft = xl;
1460         xleft_inc = dxldy >> 2;
1461      }
1462
1463      xstart = xleft >> 16;
1464      xend = xright >> 16;
1465      j = k >> 2;
1466      spix = k & 3;
1467
1468      if (k >= 0 && k < 0x1000)
1469      {
1470         int m = 0;
1471         int n = 0;
1472         int length = 0;
1473         min = 0; max = 3;
1474         if (j == yhpix)
1475         {
1476            min = yh & 3;
1477         }
1478         if (j == ylpix)
1479         {
1480            max = yl & 3;
1481         }
1482         if (spix >= min && spix <= max)
1483         {
1484            if (spix == min)
1485            {
1486               minxmx = maxxmx = xstart;
1487               minxhx = maxxhx = xend;
1488            }
1489            else
1490            {
1491               minxmx = (xstart < minxmx) ? xstart : minxmx;
1492               maxxmx = (xstart > maxxmx) ? xstart : maxxmx;
1493               minxhx = (xend < minxhx) ? xend : minxhx;
1494               maxxhx = (xend > maxxhx) ? xend : maxxhx;
1495            }
1496         }
1497
1498         if (spix == max)
1499         {
1500            if (flip)
1501            {
1502               span[j].lx = maxxmx;
1503               span[j].rx = minxhx;
1504            }
1505            else
1506            {
1507               span[j].lx = minxmx;
1508               span[j].rx = maxxhx;
1509            }
1510         }
1511
1512         length = flip ? (xstart - xend) : (xend - xstart);
1513
1514         if (spix == ldflag)
1515         {
1516            xfrac = ((xright >> 8) & 0xff);
1517            adjust_attr();
1518         }
1519
1520         m = flip ? (xend+1) : (xend-1);
1521
1522         if (k >= yh && length >= 0 && k <= yl)
1523         {
1524            if (xstart>=0 && xstart <1024)
1525            {
1526               if (!flip)
1527               {
1528                  span[j].cvg[xstart] += addleft(xleft);
1529               }
1530               else
1531               {
1532                  span[j].cvg[xstart] += addright(xleft);
1533               }
1534            }
1535            if (xend>=0 && xend<1024)
1536            {
1537               if (xstart != xend)
1538               {
1539                  if (!flip)
1540                  {
1541                     span[j].cvg[xend] += addright(xright);
1542                  }
1543                  else
1544                  {
1545                     span[j].cvg[xend] += addleft(xright);
1546                  }
1547               }
1548               else
1549               {
1550                  if (!flip)
1551                  {
1552                     span[j].cvg[xend] -= (2 - addright(xright));
1553                  }
1554                  else
1555                  {
1556                     span[j].cvg[xend] -= (2 - addleft(xright));
1557                  }
1558                  if (span[j].cvg[xend] > 200)
1559                  {
1560                     span[j].cvg[xend] = 0;
1561                  }
1562               }
1563            }
1564            for (n = 0; n < (length - 1); n++)
1565            {
1566               if (m>=0 && m < 640)
1567               {
1568                  span[j].cvg[m] += 2;
1569               }
1570
1571               m += m_inc;
1572            }
1573         }
1574      }
1575
1576      if (spix == 3)
1577      {
1578         addvalues();
1579      }
1580      xleft += xleft_inc;
1581      xright += xright_inc;
1582   }
1583
1584   switch (fb_size) // 8bpp needs to be implemented
1585   {
1586      case PIXEL_SIZE_16BIT:
1587         if(flip)
1588         {
1589            render_spans_16_s_nt_nz_f(yh>>2, yl>>2, &tile[0]); break;
1590         }
1591         else
1592         {
1593            render_spans_16_s_nt_nz_nf(yh>>2, yl>>2, &tile[0]); break;
1594         }
1595      case PIXEL_SIZE_32BIT:   render_spans_32(yh>>2, yl>>2, &tile[tilenum], 1, 0, 0, flip); break;
1596      default: break; // V-Rally2 does this, fb_size=0
1597   }
1598}
1599#undef addvalues
1600#undef adjust_attr
1601#undef addleft
1602#undef addright
1603#undef setvalues
1604
1605static void triangle_s_nt_z(UINT32 w1, UINT32 w2)
1606{
1607   int j;
1608   int xleft, xright, xleft_inc, xright_inc;
1609   int xstart, xend;
1610   int r = 0, g = 0, b = 0, a = 0, z = 0;
1611   int dr, dg, db, da;
1612   int drdx = 0, dgdx = 0, dbdx = 0, dadx = 0, dzdx = 0;
1613   int drdy = 0, dgdy = 0, dbdy = 0, dady = 0, dzdy = 0;
1614   int drde = 0, dgde = 0, dbde = 0, dade = 0, dzde = 0;
1615   int tilenum;
1616   int flip = (w1 & 0x800000) ? 1 : 0;
1617
1618   INT32 yl, ym, yh;
1619   INT32 xl, xm, xh;
1620   INT32 dxldy, dxhdy, dxmdy;
1621   int dzdy_dz, dzdx_dz;
1622   UINT32 w3, w4, w5, w6, w7, w8;
1623
1624   int k = 0;
1625
1626   INT32 limcvg = 0;
1627   INT32 startcvg = 0;
1628
1629   int sign_dxldy = 0;
1630   int sign_dxmdy = 0;
1631   int samesign = 0;
1632
1633   int drdiff = 0, dgdiff = 0, dbdiff = 0, dadiff = 0, dzdiff = 0;
1634   int sign_dxhdy = 0;
1635
1636   int drdeh = 0, dgdeh = 0, dbdeh = 0, dadeh = 0, dzdeh = 0, drdyh = 0, dgdyh = 0, dbdyh = 0, dadyh = 0, dzdyh = 0;
1637   int do_offset = 0;
1638
1639   int xfrac = 0;
1640   int dreoff = 0, dgeoff = 0, dbeoff = 0, daeoff = 0, dzeoff = 0;
1641
1642   int drdxh = 0, dgdxh = 0, dbdxh = 0, dadxh = 0, dzdxh = 0;
1643
1644   int m_inc;
1645   UINT32 min=0, max=3;
1646   INT32 maxxmx = 0, minxmx = 0, maxxhx = 0, minxhx = 0;
1647
1648   int spix = 0; // Current subpixel
1649   int ycur;
1650   int ylfar;
1651   int ldflag;
1652   int yhpix;
1653   int ympix;
1654   int ylpix;
1655
1656   int shade_base = rdp_cmd_cur + 8;
1657   int zbuffer_base = rdp_cmd_cur + 8;
1658
1659   zbuffer_base += 16;
1660
1661   w3 = rdp_cmd_data[rdp_cmd_cur+2];
1662   w4 = rdp_cmd_data[rdp_cmd_cur+3];
1663   w5 = rdp_cmd_data[rdp_cmd_cur+4];
1664   w6 = rdp_cmd_data[rdp_cmd_cur+5];
1665   w7 = rdp_cmd_data[rdp_cmd_cur+6];
1666   w8 = rdp_cmd_data[rdp_cmd_cur+7];
1667
1668   yl = (w1 & 0x3fff);
1669   ym = ((w2 >> 16) & 0x3fff);
1670   yh = ((w2 >>  0) & 0x3fff);
1671   xl = (INT32)(w3 & 0x3fffffff);
1672   xh = (INT32)(w5 & 0x3fffffff);
1673   xm = (INT32)(w7 & 0x3fffffff);
1674   // Inverse slopes in 16.16 format
1675   dxldy = (INT32)(w4);
1676   dxhdy = (INT32)(w6);
1677   dxmdy = (INT32)(w8);
1678
1679   max_level = ((w1 >> 19) & 7);
1680   tilenum = (w1 >> 16) & 0x7;
1681
1682   if (yl & 0x2000)  yl |= 0xffffc000;
1683   if (ym & 0x2000)  ym |= 0xffffc000;
1684   if (yh & 0x2000)  yh |= 0xffffc000;
1685
1686   if (xl & 0x20000000)  xl |= 0xc0000000;
1687   if (xm & 0x20000000)  xm |= 0xc0000000;
1688   if (xh & 0x20000000)  xh |= 0xc0000000;
1689
1690   z = 0;
1691   dr = 0;      dg = 0;      db = 0;      da = 0;
1692
1693   r    = (rdp_cmd_data[shade_base+0 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+4 ] >> 16) & 0x0000ffff);
1694   g    = ((rdp_cmd_data[shade_base+0 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+4 ] & 0x0000ffff);
1695   b    = (rdp_cmd_data[shade_base+1 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+5 ] >> 16) & 0x0000ffff);
1696   a    = ((rdp_cmd_data[shade_base+1 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+5 ] & 0x0000ffff);
1697   drdx = (rdp_cmd_data[shade_base+2 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+6 ] >> 16) & 0x0000ffff);
1698   dgdx = ((rdp_cmd_data[shade_base+2 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+6 ] & 0x0000ffff);
1699   dbdx = (rdp_cmd_data[shade_base+3 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+7 ] >> 16) & 0x0000ffff);
1700   dadx = ((rdp_cmd_data[shade_base+3 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+7 ] & 0x0000ffff);
1701   drde = (rdp_cmd_data[shade_base+8 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+12] >> 16) & 0x0000ffff);
1702   dgde = ((rdp_cmd_data[shade_base+8 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+12] & 0x0000ffff);
1703   dbde = (rdp_cmd_data[shade_base+9 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+13] >> 16) & 0x0000ffff);
1704   dade = ((rdp_cmd_data[shade_base+9 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+13] & 0x0000ffff);
1705   drdy = (rdp_cmd_data[shade_base+10] & 0xffff0000) | ((rdp_cmd_data[shade_base+14] >> 16) & 0x0000ffff);
1706   dgdy = ((rdp_cmd_data[shade_base+10] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+14] & 0x0000ffff);
1707   dbdy = (rdp_cmd_data[shade_base+11] & 0xffff0000) | ((rdp_cmd_data[shade_base+15] >> 16) & 0x0000ffff);
1708   dady = ((rdp_cmd_data[shade_base+11] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+15] & 0x0000ffff);
1709   z    = rdp_cmd_data[zbuffer_base+0];
1710   dzdx = rdp_cmd_data[zbuffer_base+1];
1711   dzde = rdp_cmd_data[zbuffer_base+2];
1712   dzdy = rdp_cmd_data[zbuffer_base+3];
1713
1714   span[0].dr.w = drdx & ~0x1f;
1715   span[0].dg.w = dgdx & ~0x1f;
1716   span[0].db.w = dbdx & ~0x1f;
1717   span[0].da.w = dadx & ~0x1f;
1718   span[0].dz.w = dzdx;
1719   dzdy_dz = (dzdy >> 16) & 0xffff;
1720   dzdx_dz = (dzdx >> 16) & 0xffff;
1721   span[0].dzpix = ((dzdy_dz & 0x8000) ? ((~dzdy_dz) & 0x7fff) : dzdy_dz) + ((dzdx_dz & 0x8000) ? ((~dzdx_dz) & 0x7fff) : dzdx_dz);
1722   span[0].dzpix = normalize_dzpix(span[0].dzpix);
1723
1724   xleft_inc = dxmdy >> 2;
1725   xright_inc = dxhdy >> 2;
1726
1727   xright = xh;
1728   xleft = xm;
1729
1730   limcvg = ((yl>>2) <= 1023) ? (yl>>2) : 1023; // Needed by 40 Winks
1731   if (limcvg < 0)
1732   {
1733      limcvg = 0;
1734   }
1735
1736   startcvg = ((yh>>2)>=0) ? (yh>>2) : 0;
1737   for (k = startcvg; k <= limcvg; k++)
1738   {
1739      memset((void*)&span[k].cvg[0],0,640);
1740   }
1741
1742   sign_dxldy = (dxldy & 0x80000000) ? 1 : 0;
1743   sign_dxmdy = (dxmdy & 0x80000000) ? 1 : 0;
1744   samesign = !(sign_dxldy ^ sign_dxmdy);
1745
1746   sign_dxhdy = (dxhdy & 0x80000000) ? 1 : 0;
1747
1748   do_offset = !(sign_dxhdy ^ (flip));
1749
1750   if (do_offset)
1751   {
1752      drdeh = drde >> 9;   drdyh = drdy >> 9;
1753      dgdeh = dgde >> 9;   dgdyh = dgdy >> 9;
1754      dbdeh = dbde >> 9;   dbdyh = dbdy >> 9;
1755      dadeh = dade >> 9;   dadyh = dady >> 9;
1756      dzdeh = dzde >> 9;   dzdyh = dzdy >> 9;
1757
1758      drdiff = (drdeh*3 - drdyh*3) << 7;
1759      dgdiff = (dgdeh*3 - dgdyh*3) << 7;
1760      dbdiff = (dbdeh*3 - dbdyh*3) << 7;
1761      dadiff = (dadeh*3 - dadyh*3) << 7;
1762      dzdiff = (dzdeh*3 - dzdyh*3) << 7;
1763   }
1764   else
1765   {
1766      drdiff = dgdiff = dbdiff = dadiff = dzdiff = 0;
1767   }
1768
1769   if (do_offset)
1770   {
1771      dreoff = (drdeh*3) << 7;
1772      dgeoff = (dgdeh*3) << 7;
1773      dbeoff = (dbdeh*3) << 7;
1774      daeoff = (dadeh*3) << 7;
1775      dzeoff = (dzdeh*3) << 7;
1776   }
1777   else
1778   {
1779      dreoff = dgeoff = dbeoff = daeoff = dzeoff = 0;
1780   }
1781
1782#define addleft(x) addleftcvg(x,k)
1783#define addright(x) addrightcvg(x,k)
1784#define setvalues() {               \
1785         addvalues();            \
1786         adjust_attr();   \
1787}
1788
1789   drdxh = drdx >> 8;
1790   dgdxh = dgdx >> 8;
1791   dbdxh = dbdx >> 8;
1792   dadxh = dadx >> 8;
1793   dzdxh = dzdx >> 8;
1794
1795#define adjust_attr()      \
1796{                     \
1797         span[j].r.w = r + drdiff - (xfrac * drdxh);            \
1798         span[j].g.w = g + dgdiff - (xfrac * dgdxh);            \
1799         span[j].b.w = b + dbdiff - (xfrac * dbdxh);            \
1800         span[j].a.w = a + dadiff - (xfrac * dadxh);            \
1801         span[j].z.w = z + dzdiff - (xfrac * dzdxh);            \
1802}
1803
1804#define addvalues() {   \
1805         r += drde; \
1806         g += dgde; \
1807         b += dbde; \
1808         a += dade; \
1809         z += dzde; \
1810}
1811
1812   m_inc = flip ? 1 : -1;
1813
1814   ycur =   yh & ~3;
1815   ylfar = yl | 3;
1816   ldflag = (sign_dxhdy ^ flip) ? 0 : 3;
1817   yhpix = yh >> 2;
1818   ympix = ym >> 2;
1819   ylpix = yl >> 2;
1820
1821   for (k = ycur; k <= ylfar; k++)
1822   {
1823      if (k == ym)
1824      {
1825         xleft = xl;
1826         xleft_inc = dxldy >> 2;
1827      }
1828
1829      xstart = xleft >> 16;
1830      xend = xright >> 16;
1831      j = k >> 2;
1832      spix = k & 3;
1833
1834      if (k >= 0 && k < 0x1000)
1835      {
1836         int m = 0;
1837         int n = 0;
1838         int length = 0;
1839         min = 0; max = 3;
1840         if (j == yhpix)
1841         {
1842            min = yh & 3;
1843         }
1844         if (j == ylpix)
1845         {
1846            max = yl & 3;
1847         }
1848         if (spix >= min && spix <= max)
1849         {
1850            if (spix == min)
1851            {
1852               minxmx = maxxmx = xstart;
1853               minxhx = maxxhx = xend;
1854            }
1855            else
1856            {
1857               minxmx = (xstart < minxmx) ? xstart : minxmx;
1858               maxxmx = (xstart > maxxmx) ? xstart : maxxmx;
1859               minxhx = (xend < minxhx) ? xend : minxhx;
1860               maxxhx = (xend > maxxhx) ? xend : maxxhx;
1861            }
1862         }
1863
1864         if (spix == max)
1865         {
1866            if (flip)
1867            {
1868               span[j].lx = maxxmx;
1869               span[j].rx = minxhx;
1870            }
1871            else
1872            {
1873               span[j].lx = minxmx;
1874               span[j].rx = maxxhx;
1875            }
1876         }
1877
1878         length = flip ? (xstart - xend) : (xend - xstart);
1879
1880         if (spix == ldflag)
1881         {
1882            xfrac = ((xright >> 8) & 0xff);
1883            adjust_attr();
1884         }
1885
1886         m = flip ? (xend+1) : (xend-1);
1887
1888         if (k >= yh && length >= 0 && k <= yl)
1889         {
1890            if (xstart>=0 && xstart <1024)
1891            {
1892               if (!flip)
1893               {
1894                  span[j].cvg[xstart] += addleft(xleft);
1895               }
1896               else
1897               {
1898                  span[j].cvg[xstart] += addright(xleft);
1899               }
1900            }
1901            if (xend>=0 && xend<1024)
1902            {
1903               if (xstart != xend)
1904               {
1905                  if (!flip)
1906                  {
1907                     span[j].cvg[xend] += addright(xright);
1908                  }
1909                  else
1910                  {
1911                     span[j].cvg[xend] += addleft(xright);
1912                  }
1913               }
1914               else
1915               {
1916                  if (!flip)
1917                  {
1918                     span[j].cvg[xend] -= (2 - addright(xright));
1919                  }
1920                  else
1921                  {
1922                     span[j].cvg[xend] -= (2 - addleft(xright));
1923                  }
1924                  if (span[j].cvg[xend] > 200)
1925                  {
1926                     span[j].cvg[xend] = 0;
1927                  }
1928               }
1929            }
1930            for (n = 0; n < (length - 1); n++)
1931            {
1932               if (m>=0 && m < 640)
1933               {
1934                  span[j].cvg[m] += 2;
1935               }
1936
1937               m += m_inc;
1938            }
1939         }
1940      }
1941
1942      if (spix == 3)
1943      {
1944         addvalues();
1945      }
1946      xleft += xleft_inc;
1947      xright += xright_inc;
1948   }
1949
1950   switch (fb_size) // 8bpp needs to be implemented
1951   {
1952      case PIXEL_SIZE_16BIT:
1953         if(flip)
1954         {
1955            render_spans_16_s_nt_z_f(yh>>2, yl>>2, &tile[0]); break;
1956         }
1957         else
1958         {
1959            render_spans_16_s_nt_z_nf(yh>>2, yl>>2, &tile[0]); break;
1960         }
1961      case PIXEL_SIZE_32BIT:   render_spans_32(yh>>2, yl>>2, &tile[tilenum], 1, 0, 1, flip); break;
1962      default: break; // V-Rally2 does this, fb_size=0
1963   }
1964}
1965#undef addvalues
1966#undef adjust_attr
1967#undef addleft
1968#undef addright
1969#undef setvalues
1970
1971static void triangle_s_t_nz(UINT32 w1, UINT32 w2)
1972{
1973   int j;
1974   int xleft, xright, xleft_inc, xright_inc;
1975   int xstart, xend;
1976   int r = 0, g = 0, b = 0, a = 0, s = 0, t = 0, w = 0;
1977   int dr, dg, db, da;
1978   int drdx = 0, dgdx = 0, dbdx = 0, dadx = 0, dsdx = 0, dtdx = 0, dwdx = 0;
1979   int drdy = 0, dgdy = 0, dbdy = 0, dady = 0, dsdy = 0, dtdy = 0, dwdy = 0;
1980   int drde = 0, dgde = 0, dbde = 0, dade = 0, dsde = 0, dtde = 0, dwde = 0;
1981   int tilenum;
1982   int flip = (w1 & 0x800000) ? 1 : 0;
1983
1984   INT32 yl, ym, yh;
1985   INT32 xl, xm, xh;
1986   INT32 dxldy, dxhdy, dxmdy;
1987   int dsdylod, dtdylod;
1988   UINT32 w3, w4, w5, w6, w7, w8;
1989
1990   int k = 0;
1991
1992   INT32 limcvg = 0;
1993   INT32 startcvg = 0;
1994
1995   int sign_dxldy = 0;
1996   int sign_dxmdy = 0;
1997   int samesign = 0;
1998
1999   int dsdiff = 0, dtdiff = 0, dwdiff = 0, drdiff = 0, dgdiff = 0, dbdiff = 0, dadiff = 0;
2000   int sign_dxhdy = 0;
2001
2002   int dsdeh = 0, dtdeh = 0, dwdeh = 0, drdeh = 0, dgdeh = 0, dbdeh = 0, dadeh = 0, dsdyh = 0, dtdyh = 0, dwdyh = 0, drdyh = 0, dgdyh = 0, dbdyh = 0, dadyh = 0;
2003   int do_offset = 0;
2004
2005   int xfrac = 0;
2006   int dseoff = 0, dteoff = 0, dweoff = 0, dreoff = 0, dgeoff = 0, dbeoff = 0, daeoff = 0;
2007
2008   int dsdxh = 0, dtdxh = 0, dwdxh = 0, drdxh = 0, dgdxh = 0, dbdxh = 0, dadxh = 0;
2009
2010   int m_inc;
2011   UINT32 min=0, max=3;
2012   INT32 maxxmx = 0, minxmx = 0, maxxhx = 0, minxhx = 0;
2013
2014   int spix = 0; // Current subpixel
2015   int ycur;
2016   int ylfar;
2017   int ldflag;
2018   int yhpix;
2019   int ympix;
2020   int ylpix;
2021
2022   int shade_base = rdp_cmd_cur + 8;
2023   int texture_base = rdp_cmd_cur + 8;
2024
2025   texture_base += 16;
2026
2027   w3 = rdp_cmd_data[rdp_cmd_cur+2];
2028   w4 = rdp_cmd_data[rdp_cmd_cur+3];
2029   w5 = rdp_cmd_data[rdp_cmd_cur+4];
2030   w6 = rdp_cmd_data[rdp_cmd_cur+5];
2031   w7 = rdp_cmd_data[rdp_cmd_cur+6];
2032   w8 = rdp_cmd_data[rdp_cmd_cur+7];
2033
2034   yl = (w1 & 0x3fff);
2035   ym = ((w2 >> 16) & 0x3fff);
2036   yh = ((w2 >>  0) & 0x3fff);
2037   xl = (INT32)(w3 & 0x3fffffff);
2038   xh = (INT32)(w5 & 0x3fffffff);
2039   xm = (INT32)(w7 & 0x3fffffff);
2040   // Inverse slopes in 16.16 format
2041   dxldy = (INT32)(w4);
2042   dxhdy = (INT32)(w6);
2043   dxmdy = (INT32)(w8);
2044
2045   max_level = ((w1 >> 19) & 7);
2046   tilenum = (w1 >> 16) & 0x7;
2047
2048   if (yl & 0x2000)  yl |= 0xffffc000;
2049   if (ym & 0x2000)  ym |= 0xffffc000;
2050   if (yh & 0x2000)  yh |= 0xffffc000;
2051
2052   if (xl & 0x20000000)  xl |= 0xc0000000;
2053   if (xm & 0x20000000)  xm |= 0xc0000000;
2054   if (xh & 0x20000000)  xh |= 0xc0000000;
2055
2056   s = 0;   t = 0;   w = 0;
2057   dr = 0;      dg = 0;      db = 0;      da = 0;
2058
2059   r    = (rdp_cmd_data[shade_base+0 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+4 ] >> 16) & 0x0000ffff);
2060   g    = ((rdp_cmd_data[shade_base+0 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+4 ] & 0x0000ffff);
2061   b    = (rdp_cmd_data[shade_base+1 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+5 ] >> 16) & 0x0000ffff);
2062   a    = ((rdp_cmd_data[shade_base+1 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+5 ] & 0x0000ffff);
2063   drdx = (rdp_cmd_data[shade_base+2 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+6 ] >> 16) & 0x0000ffff);
2064   dgdx = ((rdp_cmd_data[shade_base+2 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+6 ] & 0x0000ffff);
2065   dbdx = (rdp_cmd_data[shade_base+3 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+7 ] >> 16) & 0x0000ffff);
2066   dadx = ((rdp_cmd_data[shade_base+3 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+7 ] & 0x0000ffff);
2067   drde = (rdp_cmd_data[shade_base+8 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+12] >> 16) & 0x0000ffff);
2068   dgde = ((rdp_cmd_data[shade_base+8 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+12] & 0x0000ffff);
2069   dbde = (rdp_cmd_data[shade_base+9 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+13] >> 16) & 0x0000ffff);
2070   dade = ((rdp_cmd_data[shade_base+9 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+13] & 0x0000ffff);
2071   drdy = (rdp_cmd_data[shade_base+10] & 0xffff0000) | ((rdp_cmd_data[shade_base+14] >> 16) & 0x0000ffff);
2072   dgdy = ((rdp_cmd_data[shade_base+10] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+14] & 0x0000ffff);
2073   dbdy = (rdp_cmd_data[shade_base+11] & 0xffff0000) | ((rdp_cmd_data[shade_base+15] >> 16) & 0x0000ffff);
2074   dady = ((rdp_cmd_data[shade_base+11] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+15] & 0x0000ffff);
2075   s    = (rdp_cmd_data[texture_base+0 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+4 ] >> 16) & 0x0000ffff);
2076   t    = ((rdp_cmd_data[texture_base+0 ] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+4 ] & 0x0000ffff);
2077   w    = (rdp_cmd_data[texture_base+1 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+5 ] >> 16) & 0x0000ffff);
2078   dsdx = (rdp_cmd_data[texture_base+2 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+6 ] >> 16) & 0x0000ffff);
2079   dtdx = ((rdp_cmd_data[texture_base+2 ] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+6 ] & 0x0000ffff);
2080   dwdx = (rdp_cmd_data[texture_base+3 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+7 ] >> 16) & 0x0000ffff);
2081   dsde = (rdp_cmd_data[texture_base+8 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+12] >> 16) & 0x0000ffff);
2082   dtde = ((rdp_cmd_data[texture_base+8 ] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+12] & 0x0000ffff);
2083   dwde = (rdp_cmd_data[texture_base+9 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+13] >> 16) & 0x0000ffff);
2084   dsdy = (rdp_cmd_data[texture_base+10] & 0xffff0000) | ((rdp_cmd_data[texture_base+14] >> 16) & 0x0000ffff);
2085   dtdy = ((rdp_cmd_data[texture_base+10] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+14] & 0x0000ffff);
2086   dwdy = (rdp_cmd_data[texture_base+11] & 0xffff0000) | ((rdp_cmd_data[texture_base+15] >> 16) & 0x0000ffff);
2087
2088   span[0].ds.w = dsdx;
2089   span[0].dt.w = dtdx;
2090   span[0].dw.w = dwdx;
2091   span[0].dr.w = drdx & ~0x1f;
2092   span[0].dg.w = dgdx & ~0x1f;
2093   span[0].db.w = dbdx & ~0x1f;
2094   span[0].da.w = dadx & ~0x1f;
2095   dsdylod = dsdy >> 16;
2096   dtdylod = dtdy >> 16;
2097   if (dsdylod & 0x20000)
2098   {
2099      dsdylod = ~dsdylod & 0x1ffff;
2100   }
2101   if (dtdylod & 0x20000)
2102   {
2103      dtdylod = ~dtdylod & 0x1ffff;
2104   }
2105   span[0].dymax = (dsdylod > dtdylod)? dsdylod : dtdylod;
2106
2107   xleft_inc = dxmdy >> 2;
2108   xright_inc = dxhdy >> 2;
2109
2110   xright = xh;
2111   xleft = xm;
2112
2113   limcvg = ((yl>>2) <= 1023) ? (yl>>2) : 1023; // Needed by 40 Winks
2114   if (limcvg < 0)
2115   {
2116      limcvg = 0;
2117   }
2118
2119   startcvg = ((yh>>2)>=0) ? (yh>>2) : 0;
2120   for (k = startcvg; k <= limcvg; k++)
2121   {
2122      memset((void*)&span[k].cvg[0],0,640);
2123   }
2124
2125   sign_dxldy = (dxldy & 0x80000000) ? 1 : 0;
2126   sign_dxmdy = (dxmdy & 0x80000000) ? 1 : 0;
2127   samesign = !(sign_dxldy ^ sign_dxmdy);
2128
2129   sign_dxhdy = (dxhdy & 0x80000000) ? 1 : 0;
2130
2131   do_offset = !(sign_dxhdy ^ (flip));
2132
2133   if (do_offset)
2134   {
2135      dsdeh = dsde >> 9;   dsdyh = dsdy >> 9;
2136      dtdeh = dtde >> 9;   dtdyh = dtdy >> 9;
2137      dwdeh = dwde >> 9;   dwdyh = dwdy >> 9;
2138      drdeh = drde >> 9;   drdyh = drdy >> 9;
2139      dgdeh = dgde >> 9;   dgdyh = dgdy >> 9;
2140      dbdeh = dbde >> 9;   dbdyh = dbdy >> 9;
2141      dadeh = dade >> 9;   dadyh = dady >> 9;
2142
2143      dsdiff = (dsdeh*3 - dsdyh*3) << 7;
2144      dtdiff = (dtdeh*3 - dtdyh*3) << 7;
2145      dwdiff = (dwdeh*3 - dwdyh*3) << 7;
2146      drdiff = (drdeh*3 - drdyh*3) << 7;
2147      dgdiff = (dgdeh*3 - dgdyh*3) << 7;
2148      dbdiff = (dbdeh*3 - dbdyh*3) << 7;
2149      dadiff = (dadeh*3 - dadyh*3) << 7;
2150   }
2151   else
2152   {
2153      dsdiff = dtdiff = dwdiff = drdiff = dgdiff = dbdiff = dadiff = 0;
2154   }
2155
2156   if (do_offset)
2157   {
2158      dseoff = (dsdeh*3) << 7;
2159      dteoff = (dtdeh*3) << 7;
2160      dweoff = (dwdeh*3) << 7;
2161      dreoff = (drdeh*3) << 7;
2162      dgeoff = (dgdeh*3) << 7;
2163      dbeoff = (dbdeh*3) << 7;
2164      daeoff = (dadeh*3) << 7;
2165   }
2166   else
2167   {
2168      dseoff = dteoff = dweoff = dreoff = dgeoff = dbeoff = daeoff = 0;
2169   }
2170
2171#define addleft(x) addleftcvg(x,k)
2172#define addright(x) addrightcvg(x,k)
2173#define setvalues() {               \
2174         addvalues();            \
2175         adjust_attr();   \
2176}
2177
2178   dsdxh = dsdx >> 8;
2179   dtdxh = dtdx >> 8;
2180   dwdxh = dwdx >> 8;
2181   drdxh = drdx >> 8;
2182   dgdxh = dgdx >> 8;
2183   dbdxh = dbdx >> 8;
2184   dadxh = dadx >> 8;
2185
2186#define adjust_attr()      \
2187{                     \
2188         span[j].s.w = (s + dsdiff - (xfrac * dsdxh)) & ~0x1f;            \
2189         span[j].t.w = (t + dtdiff - (xfrac * dtdxh)) & ~0x1f;            \
2190         span[j].w.w = (w + dwdiff - (xfrac * dwdxh)) & ~0x1f;            \
2191         span[j].r.w = r + drdiff - (xfrac * drdxh);            \
2192         span[j].g.w = g + dgdiff - (xfrac * dgdxh);            \
2193         span[j].b.w = b + dbdiff - (xfrac * dbdxh);            \
2194         span[j].a.w = a + dadiff - (xfrac * dadxh);            \
2195}
2196
2197#define addvalues() {   \
2198         s += dsde;   \
2199         t += dtde;   \
2200         w += dwde; \
2201         r += drde; \
2202         g += dgde; \
2203         b += dbde; \
2204         a += dade; \
2205}
2206
2207   m_inc = flip ? 1 : -1;
2208
2209   ycur =   yh & ~3;
2210   ylfar = yl | 3;
2211   ldflag = (sign_dxhdy ^ flip) ? 0 : 3;
2212   yhpix = yh >> 2;
2213   ympix = ym >> 2;
2214   ylpix = yl >> 2;
2215
2216   for (k = ycur; k <= ylfar; k++)
2217   {
2218      if (k == ym)
2219      {
2220         xleft = xl;
2221         xleft_inc = dxldy >> 2;
2222      }
2223
2224      xstart = xleft >> 16;
2225      xend = xright >> 16;
2226      j = k >> 2;
2227      spix = k & 3;
2228
2229      if (k >= 0 && k < 0x1000)
2230      {
2231         int m = 0;
2232         int n = 0;
2233         int length = 0;
2234         min = 0; max = 3;
2235         if (j == yhpix)
2236         {
2237            min = yh & 3;
2238         }
2239         if (j == ylpix)
2240         {
2241            max = yl & 3;
2242         }
2243         if (spix >= min && spix <= max)
2244         {
2245            if (spix == min)
2246            {
2247               minxmx = maxxmx = xstart;
2248               minxhx = maxxhx = xend;
2249            }
2250            else
2251            {
2252               minxmx = (xstart < minxmx) ? xstart : minxmx;
2253               maxxmx = (xstart > maxxmx) ? xstart : maxxmx;
2254               minxhx = (xend < minxhx) ? xend : minxhx;
2255               maxxhx = (xend > maxxhx) ? xend : maxxhx;
2256            }
2257         }
2258
2259         if (spix == max)
2260         {
2261            if (flip)
2262            {
2263               span[j].lx = maxxmx;
2264               span[j].rx = minxhx;
2265            }
2266            else
2267            {
2268               span[j].lx = minxmx;
2269               span[j].rx = maxxhx;
2270            }
2271         }
2272
2273         length = flip ? (xstart - xend) : (xend - xstart);
2274
2275         if (spix == ldflag)
2276         {
2277            xfrac = ((xright >> 8) & 0xff);
2278            adjust_attr();
2279         }
2280
2281         m = flip ? (xend+1) : (xend-1);
2282
2283         if (k >= yh && length >= 0 && k <= yl)
2284         {
2285            if (xstart>=0 && xstart <1024)
2286            {
2287               if (!flip)
2288               {
2289                  span[j].cvg[xstart] += addleft(xleft);
2290               }
2291               else
2292               {
2293                  span[j].cvg[xstart] += addright(xleft);
2294               }
2295            }
2296            if (xend>=0 && xend<1024)
2297            {
2298               if (xstart != xend)
2299               {
2300                  if (!flip)
2301                  {
2302                     span[j].cvg[xend] += addright(xright);
2303                  }
2304                  else
2305                  {
2306                     span[j].cvg[xend] += addleft(xright);
2307                  }
2308               }
2309               else
2310               {
2311                  if (!flip)
2312                  {
2313                     span[j].cvg[xend] -= (2 - addright(xright));
2314                  }
2315                  else
2316                  {
2317                     span[j].cvg[xend] -= (2 - addleft(xright));
2318                  }
2319                  if (span[j].cvg[xend] > 200)
2320                  {
2321                     span[j].cvg[xend] = 0;
2322                  }
2323               }
2324            }
2325            for (n = 0; n < (length - 1); n++)
2326            {
2327               if (m>=0 && m < 640)
2328               {
2329                  span[j].cvg[m] += 2;
2330               }
2331
2332               m += m_inc;
2333            }
2334         }
2335      }
2336
2337      if (spix == 3)
2338      {
2339         addvalues();
2340      }
2341      xleft += xleft_inc;
2342      xright += xright_inc;
2343   }
2344
2345   switch (fb_size) // 8bpp needs to be implemented
2346   {
2347      case PIXEL_SIZE_16BIT:
2348         if(flip)
2349         {
2350            render_spans_16_s_t_nz_f(yh>>2, yl>>2, &tile[0]); break;
2351         }
2352         else
2353         {
2354            render_spans_16_s_t_nz_nf(yh>>2, yl>>2, &tile[0]); break;
2355         }
2356      case PIXEL_SIZE_32BIT:   render_spans_32(yh>>2, yl>>2, &tile[tilenum], 1, 1, 0, flip); break;
2357      default: break; // V-Rally2 does this, fb_size=0
2358   }
2359}
2360#undef addvalues
2361#undef adjust_attr
2362#undef addleft
2363#undef addright
2364#undef setvalues
2365
2366static void triangle_s_t_z(UINT32 w1, UINT32 w2)
2367{
2368   int j;
2369   int xleft, xright, xleft_inc, xright_inc;
2370   int xstart, xend;
2371   int r = 0, g = 0, b = 0, a = 0, z = 0, s = 0, t = 0, w = 0;
2372   int dr, dg, db, da;
2373   int drdx = 0, dgdx = 0, dbdx = 0, dadx = 0, dzdx = 0, dsdx = 0, dtdx = 0, dwdx = 0;
2374   int drdy = 0, dgdy = 0, dbdy = 0, dady = 0, dzdy = 0, dsdy = 0, dtdy = 0, dwdy = 0;
2375   int drde = 0, dgde = 0, dbde = 0, dade = 0, dzde = 0, dsde = 0, dtde = 0, dwde = 0;
2376   int tilenum;
2377   int flip = (w1 & 0x800000) ? 1 : 0;
2378
2379   INT32 yl, ym, yh;
2380   INT32 xl, xm, xh;
2381   INT32 dxldy, dxhdy, dxmdy;
2382   int dzdy_dz, dzdx_dz;
2383   int dsdylod, dtdylod;
2384   UINT32 w3, w4, w5, w6, w7, w8;
2385
2386   int k = 0;
2387
2388   INT32 limcvg = 0;
2389   INT32 startcvg = 0;
2390
2391   int sign_dxldy = 0;
2392   int sign_dxmdy = 0;
2393   int samesign = 0;
2394
2395   int dsdiff = 0, dtdiff = 0, dwdiff = 0, drdiff = 0, dgdiff = 0, dbdiff = 0, dadiff = 0, dzdiff = 0;
2396   int sign_dxhdy = 0;
2397
2398   int dsdeh = 0, dtdeh = 0, dwdeh = 0, drdeh = 0, dgdeh = 0, dbdeh = 0, dadeh = 0, dzdeh = 0, dsdyh = 0, dtdyh = 0, dwdyh = 0, drdyh = 0, dgdyh = 0, dbdyh = 0, dadyh = 0, dzdyh = 0;
2399   int do_offset = 0;
2400
2401   int xfrac = 0;
2402   int dseoff = 0, dteoff = 0, dweoff = 0, dreoff = 0, dgeoff = 0, dbeoff = 0, daeoff = 0, dzeoff = 0;
2403
2404   int dsdxh = 0, dtdxh = 0, dwdxh = 0, drdxh = 0, dgdxh = 0, dbdxh = 0, dadxh = 0, dzdxh = 0;
2405
2406   int m_inc;
2407   UINT32 min=0, max=3;
2408   INT32 maxxmx = 0, minxmx = 0, maxxhx = 0, minxhx = 0;
2409
2410   int spix = 0; // Current subpixel
2411   int ycur;
2412   int ylfar;
2413   int ldflag;
2414   int yhpix;
2415   int ympix;
2416   int ylpix;
2417
2418   int shade_base = rdp_cmd_cur + 8;
2419   int texture_base = rdp_cmd_cur + 24;
2420   int zbuffer_base = rdp_cmd_cur + 40;
2421
2422   w3 = rdp_cmd_data[rdp_cmd_cur+2];
2423   w4 = rdp_cmd_data[rdp_cmd_cur+3];
2424   w5 = rdp_cmd_data[rdp_cmd_cur+4];
2425   w6 = rdp_cmd_data[rdp_cmd_cur+5];
2426   w7 = rdp_cmd_data[rdp_cmd_cur+6];
2427   w8 = rdp_cmd_data[rdp_cmd_cur+7];
2428
2429   yl = (w1 & 0x3fff);
2430   ym = ((w2 >> 16) & 0x3fff);
2431   yh = ((w2 >>  0) & 0x3fff);
2432   xl = (INT32)(w3 & 0x3fffffff);
2433   xh = (INT32)(w5 & 0x3fffffff);
2434   xm = (INT32)(w7 & 0x3fffffff);
2435   // Inverse slopes in 16.16 format
2436   dxldy = (INT32)(w4);
2437   dxhdy = (INT32)(w6);
2438   dxmdy = (INT32)(w8);
2439
2440   max_level = ((w1 >> 19) & 7);
2441   tilenum = (w1 >> 16) & 0x7;
2442
2443   if (yl & 0x2000)  yl |= 0xffffc000;
2444   if (ym & 0x2000)  ym |= 0xffffc000;
2445   if (yh & 0x2000)  yh |= 0xffffc000;
2446
2447   if (xl & 0x20000000)  xl |= 0xc0000000;
2448   if (xm & 0x20000000)  xm |= 0xc0000000;
2449   if (xh & 0x20000000)  xh |= 0xc0000000;
2450
2451   z = 0;
2452   s = 0;   t = 0;   w = 0;
2453   dr = 0;      dg = 0;      db = 0;      da = 0;
2454
2455   r    = (rdp_cmd_data[shade_base+0 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+4 ] >> 16) & 0x0000ffff);
2456   g    = ((rdp_cmd_data[shade_base+0 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+4 ] & 0x0000ffff);
2457   b    = (rdp_cmd_data[shade_base+1 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+5 ] >> 16) & 0x0000ffff);
2458   a    = ((rdp_cmd_data[shade_base+1 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+5 ] & 0x0000ffff);
2459   drdx = (rdp_cmd_data[shade_base+2 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+6 ] >> 16) & 0x0000ffff);
2460   dgdx = ((rdp_cmd_data[shade_base+2 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+6 ] & 0x0000ffff);
2461   dbdx = (rdp_cmd_data[shade_base+3 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+7 ] >> 16) & 0x0000ffff);
2462   dadx = ((rdp_cmd_data[shade_base+3 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+7 ] & 0x0000ffff);
2463   drde = (rdp_cmd_data[shade_base+8 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+12] >> 16) & 0x0000ffff);
2464   dgde = ((rdp_cmd_data[shade_base+8 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+12] & 0x0000ffff);
2465   dbde = (rdp_cmd_data[shade_base+9 ] & 0xffff0000) | ((rdp_cmd_data[shade_base+13] >> 16) & 0x0000ffff);
2466   dade = ((rdp_cmd_data[shade_base+9 ] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+13] & 0x0000ffff);
2467   drdy = (rdp_cmd_data[shade_base+10] & 0xffff0000) | ((rdp_cmd_data[shade_base+14] >> 16) & 0x0000ffff);
2468   dgdy = ((rdp_cmd_data[shade_base+10] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+14] & 0x0000ffff);
2469   dbdy = (rdp_cmd_data[shade_base+11] & 0xffff0000) | ((rdp_cmd_data[shade_base+15] >> 16) & 0x0000ffff);
2470   dady = ((rdp_cmd_data[shade_base+11] << 16) & 0xffff0000) | (rdp_cmd_data[shade_base+15] & 0x0000ffff);
2471   s    = (rdp_cmd_data[texture_base+0 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+4 ] >> 16) & 0x0000ffff);
2472   t    = ((rdp_cmd_data[texture_base+0 ] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+4 ] & 0x0000ffff);
2473   w    = (rdp_cmd_data[texture_base+1 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+5 ] >> 16) & 0x0000ffff);
2474   dsdx = (rdp_cmd_data[texture_base+2 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+6 ] >> 16) & 0x0000ffff);
2475   dtdx = ((rdp_cmd_data[texture_base+2 ] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+6 ] & 0x0000ffff);
2476   dwdx = (rdp_cmd_data[texture_base+3 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+7 ] >> 16) & 0x0000ffff);
2477   dsde = (rdp_cmd_data[texture_base+8 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+12] >> 16) & 0x0000ffff);
2478   dtde = ((rdp_cmd_data[texture_base+8 ] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+12] & 0x0000ffff);
2479   dwde = (rdp_cmd_data[texture_base+9 ] & 0xffff0000) | ((rdp_cmd_data[texture_base+13] >> 16) & 0x0000ffff);
2480   dsdy = (rdp_cmd_data[texture_base+10] & 0xffff0000) | ((rdp_cmd_data[texture_base+14] >> 16) & 0x0000ffff);
2481   dtdy = ((rdp_cmd_data[texture_base+10] << 16) & 0xffff0000)   | (rdp_cmd_data[texture_base+14] & 0x0000ffff);
2482   dwdy = (rdp_cmd_data[texture_base+11] & 0xffff0000) | ((rdp_cmd_data[texture_base+15] >> 16) & 0x0000ffff);
2483   z    = rdp_cmd_data[zbuffer_base+0];
2484   dzdx = rdp_cmd_data[zbuffer_base+1];
2485   dzde = rdp_cmd_data[zbuffer_base+2];
2486   dzdy = rdp_cmd_data[zbuffer_base+3];
2487
2488   span[0].ds.w = dsdx;
2489   span[0].dt.w = dtdx;
2490   span[0].dw.w = dwdx;
2491   span[0].dr.w = drdx & ~0x1f;
2492   span[0].dg.w = dgdx & ~0x1f;
2493   span[0].db.w = dbdx & ~0x1f;
2494   span[0].da.w = dadx & ~0x1f;
2495   span[0].dz.w = dzdx;
2496   dzdy_dz = (dzdy >> 16) & 0xffff;
2497   dzdx_dz = (dzdx >> 16) & 0xffff;
2498   span[0].dzpix = ((dzdy_dz & 0x8000) ? ((~dzdy_dz) & 0x7fff) : dzdy_dz) + ((dzdx_dz & 0x8000) ? ((~dzdx_dz) & 0x7fff) : dzdx_dz);
2499   span[0].dzpix = normalize_dzpix(span[0].dzpix);
2500   dsdylod = dsdy >> 16;
2501   dtdylod = dtdy >> 16;
2502   if (dsdylod & 0x20000)
2503   {
2504      dsdylod = ~dsdylod & 0x1ffff;
2505   }
2506   if (dtdylod & 0x20000)
2507   {
2508      dtdylod = ~dtdylod & 0x1ffff;
2509   }
2510   span[0].dymax = (dsdylod > dtdylod)? dsdylod : dtdylod;
2511
2512   xleft_inc = dxmdy >> 2;
2513   xright_inc = dxhdy >> 2;
2514
2515   xright = xh;
2516   xleft = xm;
2517
2518   limcvg = ((yl>>2) <= 1023) ? (yl>>2) : 1023; // Needed by 40 Winks
2519   if (limcvg < 0)
2520   {
2521      limcvg = 0;
2522   }
2523
2524   startcvg = ((yh>>2)>=0) ? (yh>>2) : 0;
2525   for (k = startcvg; k <= limcvg; k++)
2526   {
2527      memset((void*)&span[k].cvg[0],0,640);
2528   }
2529
2530   sign_dxldy = (dxldy & 0x80000000) ? 1 : 0;
2531   sign_dxmdy = (dxmdy & 0x80000000) ? 1 : 0;
2532   samesign = !(sign_dxldy ^ sign_dxmdy);
2533
2534   sign_dxhdy = (dxhdy & 0x80000000) ? 1 : 0;
2535
2536   do_offset = !(sign_dxhdy ^ (flip));
2537
2538   if (do_offset)
2539   {
2540      dsdeh = dsde >> 9;   dsdyh = dsdy >> 9;
2541      dtdeh = dtde >> 9;   dtdyh = dtdy >> 9;
2542      dwdeh = dwde >> 9;   dwdyh = dwdy >> 9;
2543      drdeh = drde >> 9;   drdyh = drdy >> 9;
2544      dgdeh = dgde >> 9;   dgdyh = dgdy >> 9;
2545      dbdeh = dbde >> 9;   dbdyh = dbdy >> 9;
2546      dadeh = dade >> 9;   dadyh = dady >> 9;
2547      dzdeh = dzde >> 9;   dzdyh = dzdy >> 9;
2548
2549      dsdiff = (dsdeh*3 - dsdyh*3) << 7;
2550      dtdiff = (dtdeh*3 - dtdyh*3) << 7;
2551      dwdiff = (dwdeh*3 - dwdyh*3) << 7;
2552      drdiff = (drdeh*3 - drdyh*3) << 7;
2553      dgdiff = (dgdeh*3 - dgdyh*3) << 7;
2554      dbdiff = (dbdeh*3 - dbdyh*3) << 7;
2555      dadiff = (dadeh*3 - dadyh*3) << 7;
2556      dzdiff = (dzdeh*3 - dzdyh*3) << 7;
2557   }
2558   else
2559   {
2560      dsdiff = dtdiff = dwdiff = drdiff = dgdiff = dbdiff = dadiff = dzdiff = 0;
2561   }
2562
2563   if (do_offset)
2564   {
2565      dseoff = (dsdeh*3) << 7;
2566      dteoff = (dtdeh*3) << 7;
2567      dweoff = (dwdeh*3) << 7;
2568      dreoff = (drdeh*3) << 7;
2569      dgeoff = (dgdeh*3) << 7;
2570      dbeoff = (dbdeh*3) << 7;
2571      daeoff = (dadeh*3) << 7;
2572      dzeoff = (dzdeh*3) << 7;
2573   }
2574   else
2575   {
2576      dseoff = dteoff = dweoff = dreoff = dgeoff = dbeoff = daeoff = dzeoff = 0;
2577   }
2578
2579#define addleft(x) addleftcvg(x,k)
2580#define addright(x) addrightcvg(x,k)
2581#define setvalues() {               \
2582         addvalues();            \
2583         adjust_attr();   \
2584}
2585
2586   dsdxh = dsdx >> 8;
2587   dtdxh = dtdx >> 8;
2588   dwdxh = dwdx >> 8;
2589   drdxh = drdx >> 8;
2590   dgdxh = dgdx >> 8;
2591   dbdxh = dbdx >> 8;
2592   dadxh = dadx >> 8;
2593   dzdxh = dzdx >> 8;
2594
2595#define adjust_attr()      \
2596{                     \
2597         span[j].s.w = (s + dsdiff - (xfrac * dsdxh)) & ~0x1f;            \
2598         span[j].t.w = (t + dtdiff - (xfrac * dtdxh)) & ~0x1f;            \
2599         span[j].w.w = (w + dwdiff - (xfrac * dwdxh)) & ~0x1f;            \
2600         span[j].r.w = r + drdiff - (xfrac * drdxh);            \
2601         span[j].g.w = g + dgdiff - (xfrac * dgdxh);            \
2602         span[j].b.w = b + dbdiff - (xfrac * dbdxh);            \
2603         span[j].a.w = a + dadiff - (xfrac * dadxh);            \
2604         span[j].z.w = z + dzdiff - (xfrac * dzdxh);            \
2605}
2606
2607#define addvalues() {   \
2608         s += dsde;   \
2609         t += dtde;   \
2610         w += dwde; \
2611         r += drde; \
2612         g += dgde; \
2613         b += dbde; \
2614         a += dade; \
2615         z += dzde; \
2616}
2617
2618   m_inc = flip ? 1 : -1;
2619
2620   ycur =   yh & ~3;
2621   ylfar = yl | 3;
2622   ldflag = (sign_dxhdy ^ flip) ? 0 : 3;
2623   yhpix = yh >> 2;
2624   ympix = ym >> 2;
2625   ylpix = yl >> 2;
2626
2627   for (k = ycur; k <= ylfar; k++)
2628   {
2629      if (k == ym)
2630      {
2631         xleft = xl;
2632         xleft_inc = dxldy >> 2;
2633      }
2634
2635      xstart = xleft >> 16;
2636      xend = xright >> 16;
2637      j = k >> 2;
2638      spix = k & 3;
2639
2640      if (k >= 0 && k < 0x1000)
2641      {
2642         int m = 0;
2643         int n = 0;
2644         int length = 0;
2645         min = 0; max = 3;
2646         if (j == yhpix)
2647         {
2648            min = yh & 3;
2649         }
2650         if (j == ylpix)
2651         {
2652            max = yl & 3;
2653         }
2654         if (spix >= min && spix <= max)
2655         {
2656            if (spix == min)
2657            {
2658               minxmx = maxxmx = xstart;
2659               minxhx = maxxhx = xend;
2660            }
2661            else
2662            {
2663               minxmx = (xstart < minxmx) ? xstart : minxmx;
2664               maxxmx = (xstart > maxxmx) ? xstart : maxxmx;
2665               minxhx = (xend < minxhx) ? xend : minxhx;
2666               maxxhx = (xend > maxxhx) ? xend : maxxhx;
2667            }
2668         }
2669
2670         if (spix == max)
2671         {
2672            if (flip)
2673            {
2674               span[j].lx = maxxmx;
2675               span[j].rx = minxhx;
2676            }
2677            else
2678            {
2679               span[j].lx = minxmx;
2680               span[j].rx = maxxhx;
2681            }
2682         }
2683
2684         length = flip ? (xstart - xend) : (xend - xstart);
2685
2686         if (spix == ldflag)
2687         {
2688            xfrac = ((xright >> 8) & 0xff);
2689            adjust_attr();
2690         }
2691
2692         m = flip ? (xend+1) : (xend-1);
2693
2694         if (k >= yh && length >= 0 && k <= yl)
2695         {
2696            if (xstart>=0 && xstart <1024)
2697            {
2698               if (!flip)
2699               {
2700                  span[j].cvg[xstart] += addleft(xleft);
2701               }
2702               else
2703               {
2704                  span[j].cvg[xstart] += addright(xleft);
2705               }
2706            }
2707            if (xend>=0 && xend<1024)
2708            {
2709               if (xstart != xend)
2710               {
2711                  if (!flip)
2712                  {
2713                     span[j].cvg[xend] += addright(xright);
2714                  }
2715                  else
2716                  {
2717                     span[j].cvg[xend] += addleft(xright);
2718                  }
2719               }
2720               else
2721               {
2722                  if (!flip)
2723                  {
2724                     span[j].cvg[xend] -= (2 - addright(xright));
2725                  }
2726                  else
2727                  {
2728                     span[j].cvg[xend] -= (2 - addleft(xright));
2729                  }
2730                  if (span[j].cvg[xend] > 200)
2731                  {
2732                     span[j].cvg[xend] = 0;
2733                  }
2734               }
2735            }
2736            for (n = 0; n < (length - 1); n++)
2737            {
2738               if (m>=0 && m < 640)
2739               {
2740                  span[j].cvg[m] += 2;
2741               }
2742
2743               m += m_inc;
2744            }
2745         }
2746      }
2747
2748      if (spix == 3)
2749      {
2750         addvalues();
2751      }
2752      xleft += xleft_inc;
2753      xright += xright_inc;
2754   }
2755
2756   switch (fb_size) // 8bpp needs to be implemented
2757   {
2758      case PIXEL_SIZE_16BIT:
2759         if(flip)
2760         {
2761            render_spans_16_s_t_z_f(yh>>2, yl>>2, &tile[0]); break;
2762         }
2763         else
2764         {
2765            render_spans_16_s_t_z_nf(yh>>2, yl>>2, &tile[0]); break;
2766         }
2767      case PIXEL_SIZE_32BIT:   render_spans_32(yh>>2, yl>>2, &tile[tilenum], 1, 1, 1, flip); break;
2768      default: break; // V-Rally2 does this, fb_size=0
2769   }
2770}
2771#undef addvalues
2772#undef adjust_attr
2773#undef addleft
2774#undef addright
2775#undef setvalues
src/mame/video/rdptri.h
r0r6716
1static void triangle_ns_nt_nz(UINT32 w1, UINT32 w2);
2static void triangle_ns_nt_z(UINT32 w1, UINT32 w2);
3static void triangle_ns_t_nz(UINT32 w1, UINT32 w2);
4static void triangle_ns_t_z(UINT32 w1, UINT32 w2);
5static void triangle_s_nt_nz(UINT32 w1, UINT32 w2);
6static void triangle_s_nt_z(UINT32 w1, UINT32 w2);
7static void triangle_s_t_nz(UINT32 w1, UINT32 w2);
8static void triangle_s_t_z(UINT32 w1, UINT32 w2);
src/mame/video/rdpblend.c
r0r6716
1#if defined(RGBDITHER1)
2   #if defined(ZCOMPARE)
3      #if defined(IMGREAD)
4      INLINE int BLENDER1_16_IMR_ZC_DITH(UINT16 *fb, UINT8* hb, COLOR c, int dith)
5      #else
6      INLINE int BLENDER1_16_NIMR_ZC_DITH(UINT16 *fb, UINT8* hb, COLOR c, int dith)
7      #endif
8   #else
9      #if defined(IMGREAD)
10      INLINE int BLENDER1_16_IMR_NZC_DITH(UINT16 *fb, UINT8* hb, COLOR c, int dith)
11      #else
12      INLINE int BLENDER1_16_NIMR_NZC_DITH(UINT16 *fb, UINT8* hb, COLOR c, int dith)
13      #endif
14   #endif
15#else
16   #if defined(ZCOMPARE)
17      #if defined(IMGREAD)
18      INLINE int BLENDER1_16_IMR_ZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c, int dith)
19      #else
20      INLINE int BLENDER1_16_NIMR_ZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c, int dith)
21      #endif
22   #else
23      #if defined(IMGREAD)
24      INLINE int BLENDER1_16_IMR_NZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c, int dith)
25      #else
26      INLINE int BLENDER1_16_NIMR_NZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c, int dith)
27      #endif
28   #endif
29#endif
30{
31   int r, g, b;
32   int special_bsel = 0;
33   UINT16 mem = *fb;
34#if defined(IMGREAD)
35   UINT32 memory_cvg = ((mem & 1) << 2) + (*hb & 3);
36#endif
37
38   // Alpha compare
39   if (!alpha_compare(c.i.a))
40   {
41      return 0;
42   }
43
44   if (!curpixel_cvg) // New coverage is zero, so abort
45   {
46      return 0;
47   }
48
49   if (blender2b_a[0] == &memory_color.i.a)
50   {
51      special_bsel = 1;
52   }
53
54   pixel_color.c = c.c;
55
56#if !defined(ZCOMPARE)
57   curpixel_overlap = 0;
58#endif
59
60   memory_color.i.r = ((mem >> 8) & 0xf8) | (mem >> 13);
61   memory_color.i.g = ((mem >> 3) & 0xf8) | ((mem >>  8) & 0x07);
62   memory_color.i.b = ((mem << 2) & 0xf8) | ((mem >>  3) & 0x07);
63
64#if defined(IMGREAD)
65   memory_color.i.a = (memory_cvg << 5) & 0xe0;
66#else
67   memory_color.i.a = 0xe0;
68#endif
69
70   if (!curpixel_overlap && !other_modes.force_blend)
71   {
72      r = *blender1a_r[0];
73      g = *blender1a_g[0];
74      b = *blender1a_b[0];
75   }
76   else
77   {
78      inv_pixel_color.i.a = 0xff - *blender1b_a[0];
79
80      BLENDER_EQUATION0(&r, &g, &b, special_bsel);
81   }
82
83#if !defined(RGBDITHER1)
84   // Hack to prevent "double-dithering" artifacts
85   if (!(((r & 0xf8)==(memory_color.i.r&0xf8) && (g & 0xf8) == (memory_color.i.g & 0xf8) &&(b&0xf8)==(memory_color.i.b&0xf8))))
86   {
87      rgb_dither(&r, &g, &b, dith);
88   }
89#endif
90
91    return (FBWRITE_16(fb, hb, r, g, b));
92}
93
94#if defined(RGBDITHER1)
95   #if defined(ZCOMPARE)
96      #if defined(IMGREAD)
97      INLINE int BLENDER2_16_IMR_ZC_DITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith)
98      #else
99      INLINE int BLENDER2_16_NIMR_ZC_DITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith)
100      #endif
101   #else
102      #if defined(IMGREAD)
103      INLINE int BLENDER2_16_IMR_NZC_DITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith)
104      #else
105      INLINE int BLENDER2_16_NIMR_NZC_DITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith)
106      #endif
107   #endif
108#else
109   #if defined(ZCOMPARE)
110      #if defined(IMGREAD)
111      INLINE int BLENDER2_16_IMR_ZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith)
112      #else
113      INLINE int BLENDER2_16_NIMR_ZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith)
114      #endif
115   #else
116      #if defined(IMGREAD)
117      INLINE int BLENDER2_16_IMR_NZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith)
118      #else
119      INLINE int BLENDER2_16_NIMR_NZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith)
120      #endif
121   #endif
122#endif
123{
124   int r, g, b;
125   int special_bsel = 0;
126   UINT16 mem = *fb;
127#if defined(IMGREAD)
128   UINT32 memory_cvg = ((mem & 1) << 2) + (*hb & 3);
129#endif
130
131   // Alpha compare
132   if (!alpha_compare(c2.i.a))
133   {
134      return 0;
135   }
136   if (!curpixel_cvg)
137   {
138      return 0;
139   }
140
141   if (blender2b_a[0] == &memory_color.i.a)
142   {
143      special_bsel = 1;
144   }
145
146   pixel_color.c = c2.c;
147
148#if !defined(ZCOMPARE)
149   curpixel_overlap = 0;
150#endif
151
152   memory_color.i.r = ((mem >> 8) & 0xf8) | (mem >> 13);
153   memory_color.i.g = ((mem >> 3) & 0xf8) | ((mem >>  8) & 0x07);
154   memory_color.i.b = ((mem << 2) & 0xf8) | ((mem >>  3) & 0x07);
155
156#if defined(IMGREAD)
157   memory_color.i.a = (memory_cvg << 5) & 0xe0;
158#else
159   memory_color.i.a = 0xe0;
160#endif
161
162   inv_pixel_color.i.a = 0xff - *blender1b_a[0];
163
164   BLENDER_EQUATION0(&r, &g, &b, special_bsel);
165
166   blended_pixel_color.i.r = r;
167   blended_pixel_color.i.g = g;
168   blended_pixel_color.i.b = b;
169   blended_pixel_color.i.a = pixel_color.i.a;
170
171   pixel_color.i.r = r;
172   pixel_color.i.g = g;
173   pixel_color.i.b = b;
174
175   inv_pixel_color.i.a = 0xff - *blender1b_a[1];
176
177   if (!curpixel_overlap && !other_modes.force_blend)
178   {
179      r = *blender1a_r[1];
180      g = *blender1a_g[1];
181      b = *blender1a_b[1];
182   }
183   else
184   {
185      if (blender2b_a[1] == &memory_color.i.a)
186      {
187         special_bsel = 1;
188      }
189      else
190      {
191         special_bsel = 0;
192      }
193
194      BLENDER_EQUATION1(&r, &g, &b, special_bsel);
195   }
196
197#if !defined(RGBDITH1)
198   // Hack to prevent "double-dithering" artifacts
199   if (!(((r & 0xf8)==(memory_color.i.r&0xf8) && (g & 0xf8) == (memory_color.i.g & 0xf8) &&(b&0xf8)==(memory_color.i.b&0xf8))))
200   {
201      rgb_dither(&r, &g, &b, dith);
202   }
203#endif
204
205   return (FBWRITE_16(fb, hb, r, g, b));
206}
src/mame/video/rdpblend.h
r0r6716
1INLINE int BLENDER1_16_IMR_ZC_DITH(UINT16 *fb, UINT8* hb, COLOR c, int dith);
2INLINE int BLENDER1_16_IMR_ZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c, int dith);
3INLINE int BLENDER1_16_IMR_NZC_DITH(UINT16 *fb, UINT8* hb, COLOR c, int dith);
4INLINE int BLENDER1_16_IMR_NZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c, int dith);
5INLINE int BLENDER1_16_NIMR_ZC_DITH(UINT16 *fb, UINT8* hb, COLOR c, int dith);
6INLINE int BLENDER1_16_NIMR_ZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c, int dith);
7INLINE int BLENDER1_16_NIMR_NZC_DITH(UINT16 *fb, UINT8* hb, COLOR c, int dith);
8INLINE int BLENDER1_16_NIMR_NZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c, int dith);
9
10INLINE int BLENDER2_16_IMR_ZC_DITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith);
11INLINE int BLENDER2_16_IMR_ZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith);
12INLINE int BLENDER2_16_IMR_NZC_DITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith);
13INLINE int BLENDER2_16_IMR_NZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith);
14INLINE int BLENDER2_16_NIMR_ZC_DITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith);
15INLINE int BLENDER2_16_NIMR_ZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith);
16INLINE int BLENDER2_16_NIMR_NZC_DITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith);
17INLINE int BLENDER2_16_NIMR_NZC_NDITH(UINT16 *fb, UINT8* hb, COLOR c1, COLOR c2, int dith);
18
19static int (*rdp_blender1_16_func[8])(UINT16 *, UINT8 *, COLOR, int) =
20{
21   BLENDER1_16_NIMR_NZC_NDITH,   BLENDER1_16_NIMR_ZC_NDITH,
22   BLENDER1_16_NIMR_ZC_NDITH,    BLENDER1_16_NIMR_ZC_DITH,
23   BLENDER1_16_IMR_NZC_NDITH,    BLENDER1_16_IMR_NZC_DITH,
24   BLENDER1_16_IMR_ZC_NDITH,    BLENDER1_16_IMR_ZC_DITH,
25};
26
27static int (*rdp_blender2_16_func[8])(UINT16 *, UINT8 *, COLOR, COLOR, int) =
28{
29   BLENDER2_16_NIMR_NZC_NDITH,   BLENDER2_16_NIMR_NZC_DITH,
30   BLENDER2_16_NIMR_ZC_NDITH,    BLENDER2_16_NIMR_ZC_DITH,
31   BLENDER2_16_IMR_NZC_NDITH,    BLENDER2_16_IMR_NZC_DITH,
32   BLENDER2_16_IMR_ZC_NDITH,    BLENDER2_16_IMR_ZC_DITH,
33};
src/mame/video/rdpupd16.c
r0r6716
1#if defined(FSAA)
2   #if defined(DIVOT)
3      static void video_update_n64_16_fsaa_divot(bitmap_t *bitmap)
4   #else
5      static void video_update_n64_16_fsaa_nodivot(bitmap_t *bitmap)
6   #endif
7#else
8   #if defined(DIVOT)
9      static void video_update_n64_16_nofsaa_divot(bitmap_t *bitmap)
10   #else
11      static void video_update_n64_16_nofsaa_nodivot(bitmap_t *bitmap)
12   #endif
13#endif
14{
15   int i, j;
16   UINT32 final = 0;
17#if defined(DIVOT)
18   UINT32 prev_cvg = 0, next_cvg = 0;
19#endif
20    //int dither_filter = (n64_vi_control >> 16) & 1;
21    //int vibuffering = ((n64_vi_control & 2) && fsaa && divot);
22
23   UINT16 *frame_buffer;
24   UINT32 hb;
25   UINT8* hidden_buffer;
26
27   UINT32 pixels = 0;
28   UINT16 pix = 0;
29
30   INT32 hdiff = (n64_vi_hstart & 0x3ff) - ((n64_vi_hstart >> 16) & 0x3ff);
31   float hcoeff = ((float)(n64_vi_xscale & 0xfff) / (1 << 10));
32   UINT32 hres = ((float)hdiff * hcoeff);
33   INT32 invisiblewidth = n64_vi_width - hres;
34
35   INT32 vdiff = ((n64_vi_vstart & 0x3ff) - ((n64_vi_vstart >> 16) & 0x3ff)) >> 1;
36   float vcoeff = ((float)(n64_vi_yscale & 0xfff) / (1 << 10));
37   UINT32 vres = ((float)vdiff * vcoeff);
38
39   if (vdiff <= 0 || hdiff <= 0)
40   {
41      return;
42   }
43
44   frame_buffer = (UINT16*)&rdram[(n64_vi_origin & 0xffffff) >> 2];
45   hb = ((n64_vi_origin & 0xffffff) >> 2) >> 1;
46   hidden_buffer = &hidden_bits[hb];
47
48   if (hres > 640) // Needed by Top Gear Overdrive (E)
49   {
50      invisiblewidth += (hres - 640);
51      hres = 640;
52   }
53
54   pixels = 0;
55
56   if (frame_buffer)
57   {
58      for (j=0; j < vres; j++)
59      {
60         UINT32 *d = BITMAP_ADDR32(bitmap, j, 0);
61
62         for (i=0; i < hres; i++)
63         {
64            int r, g, b;
65
66            pix = frame_buffer[pixels ^ WORD_ADDR_XOR];
67            curpixel_cvg = ((pix & 1) << 2) | (hidden_buffer[pixels ^ BYTE_ADDR_XOR] & 3);
68
69#if defined(DIVOT)
70            if (i > 0 && i < (hres - 1))
71            {
72               prev_cvg = ((frame_buffer[(pixels - 1)^WORD_ADDR_XOR] & 1) << 2) | (hidden_buffer[(pixels - 1)^BYTE_ADDR_XOR] & 3);
73               next_cvg = ((frame_buffer[(pixels + 1)^WORD_ADDR_XOR] & 1) << 2) | (hidden_buffer[(pixels + 1)^BYTE_ADDR_XOR] & 3);
74            }
75#endif
76            r = ((pix >> 8) & 0xf8) | (pix >> 13);
77            g = ((pix >> 3) & 0xf8) | ((pix >>  8) & 0x07);
78            b = ((pix << 2) & 0xf8) | ((pix >>  3) & 0x07);
79
80#if defined(FSAA)
81            if (/*!vibuffering &&*/ curpixel_cvg < 7 && i > 1 && j > 1 && i < (hres - 2) && j < (vres - 2))
82            {
83               video_filter16(&r, &g, &b, &frame_buffer[pixels ^ WORD_ADDR_XOR],&hidden_buffer[pixels ^ BYTE_ADDR_XOR], n64_vi_width);
84            }
85#endif
86            //else if (dither_filter && curpixel_cvg == 7 && i > 0 && j > 0 && i < (hres - 1) && j < (vres - 1))
87            //{
88               //if (vibuffering)
89               //{
90               //   restore_filter16_buffer(&r, &g, &b, &ViBuffer[i][j], n64_vi_width);
91               //}
92               //else
93               //{
94                  //restore_filter16(&r, &g, &b, &frame_buffer[pixels ^ WORD_ADDR_XOR], pixels ^ WORD_ADDR_XOR, n64_vi_width);
95               //}
96            //}
97#if defined(DIVOT)
98            if (i > 0 && i < (hres - 1) && (curpixel_cvg != 7 || prev_cvg != 7 || next_cvg != 7))
99            {
100               //if (vibuffering)
101               //{
102               //   divot_filter16_buffer(&r, &g, &b, &ViBuffer[i][j]);
103               //}
104               //else
105               //{
106                  divot_filter16(&r, &g, &b, &frame_buffer[pixels ^ WORD_ADDR_XOR], pixels ^ WORD_ADDR_XOR);
107               //}
108            }
109#endif
110
111            /*
112            if (gamma_dither)
113            {
114               dith = mame_rand(screen->machine) & 0x3f;
115            }
116            if (gamma)
117            {
118               if (gamma_dither)
119               {
120                  r = gamma_dither_table[(r << 6)|dith];
121                  g = gamma_dither_table[(g << 6)|dith];
122                  b = gamma_dither_table[(b << 6)|dith];
123               }
124               else
125               {
126                  r = gamma_table[r];
127                  g = gamma_table[g];
128                  b = gamma_table[b];
129               }
130            }
131            else if (gamma_dither)
132            {
133               if (r < 255)
134                  r += (dith & 1);
135               if (g < 255)
136                  g += (dith & 1);
137               if (b < 255)
138                  b += (dith & 1);
139            }
140            */
141            pixels++;
142
143            final = (r << 16) | (g << 8) | b;
144            d[i] = final; // Fix me for endianness
145         }
146         pixels +=invisiblewidth;
147      }
148   }
149}
src/mame/video/rdpupd16.h

Previous 15994 Revisions Next


© 1998-2018 The MESS Team