1 /***************************************************************************
2 * Copyright (C) 2010 PCSX4ALL Team *
3 * Copyright (C) 2010 Unai *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
19 ***************************************************************************/
21 ///////////////////////////////////////////////////////////////////////////////
22 // GPU internal polygon drawing functions
24 ///////////////////////////////////////////////////////////////////////////////
25 void gpuDrawF3(const PP gpuPolySpanDriver)
27 const int li=linesInterlace;
29 s32 xa, xb, xmin, xmax;
30 s32 ya, yb, ymin, ymax;
31 s32 x0, x1, x2, x3, dx3=0, x4, dx4=0, dx;
34 x0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[2]); GPU_TESTRANGE(x0);
35 y0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[3]); GPU_TESTRANGE(y0);
36 x1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[4]); GPU_TESTRANGE(x1);
37 y1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[5]); GPU_TESTRANGE(y1);
38 x2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[6]); GPU_TESTRANGE(x2);
39 y2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[7]); GPU_TESTRANGE(y2);
41 x0 += DrawingOffset[0]; x1 += DrawingOffset[0]; x2 += DrawingOffset[0];
42 y0 += DrawingOffset[1]; y1 += DrawingOffset[1]; y2 += DrawingOffset[1];
44 xmin = DrawingArea[0]; xmax = DrawingArea[2];
45 ymin = DrawingArea[1]; ymax = DrawingArea[3];
48 int rx0 = Max2(xmin,Min3(x0,x1,x2));
49 int ry0 = Max2(ymin,Min3(y0,y1,y2));
50 int rx1 = Min2(xmax,Max3(x0,x1,x2));
51 int ry1 = Min2(ymax,Max3(y0,y1,y2));
52 if( rx0>=rx1 || ry0>=ry1) return;
55 PixelData = GPU_RGB16(PacketBuffer.U4[0]);
61 GPU_SWAP(x0, x1, temp);
62 GPU_SWAP(y0, y1, temp);
69 GPU_SWAP(x1, x2, temp);
70 GPU_SWAP(y1, y2, temp);
77 GPU_SWAP(x0, x1, temp);
78 GPU_SWAP(y0, y1, temp);
84 dx =(x2 - x1) * ya - (x2 - x0) * yb;
86 for (s32 loop0 = 2; loop0; --loop0)
93 x4 = y0!=y1 ? x3 : i2x(x1);
96 dx3 = xLoDivx((x2 - x0), (y2 - y0));
97 dx4 = xLoDivx((x1 - x0), (y1 - y0));
101 dx3 = xLoDivx((x1 - x0), (y1 - y0));
102 dx4 = xLoDivx((x2 - x0), (y2 - y0));
112 x3 = i2x(x0) + (dx3 * (y1 - y0));
113 dx4 = xLoDivx((x2 - x1), (y2 - y1));
118 x4 = i2x(x0) + (dx4 * (y1 - y0));
119 dx3 = xLoDivx((x2 - x1), (y2 - y1));
130 if (yb > ymax) yb = ymax;
131 if (ya>=yb) continue;
136 u16* PixelBase = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(0, ya)];
138 if (!progressInterlace)
140 for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4)
145 if( (xa>xmax) || (xb<xmin) ) continue;
146 if(xa < xmin) xa = xmin;
147 if(xb > xmax) xb = xmax;
149 if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
154 bool flag=progressInterlace_flag;
155 for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4)
157 if ((ya&li) && (flag=!flag)) continue;
160 if( (xa>xmax) || (xb<xmin) ) continue;
161 if(xa < xmin) xa = xmin;
162 if(xb > xmax) xb = xmax;
164 if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
170 /*----------------------------------------------------------------------
172 ----------------------------------------------------------------------*/
174 void gpuDrawFT3(const PP gpuPolySpanDriver)
176 const int li=linesInterlace;
178 s32 xa, xb, xmin, xmax;
179 s32 ya, yb, ymin, ymax;
180 s32 x0, x1, x2, x3, dx3=0, x4, dx4=0, dx;
182 s32 u0, u1, u2, u3, du3=0;
183 s32 v0, v1, v2, v3, dv3=0;
185 x0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[2] ); GPU_TESTRANGE(x0);
186 y0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[3] ); GPU_TESTRANGE(y0);
187 x1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[6] ); GPU_TESTRANGE(x1);
188 y1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[7] ); GPU_TESTRANGE(y1);
189 x2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[10]); GPU_TESTRANGE(x2);
190 y2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[11]); GPU_TESTRANGE(y2);
192 x0 += DrawingOffset[0]; x1 += DrawingOffset[0]; x2 += DrawingOffset[0];
193 y0 += DrawingOffset[1]; y1 += DrawingOffset[1]; y2 += DrawingOffset[1];
195 xmin = DrawingArea[0]; xmax = DrawingArea[2];
196 ymin = DrawingArea[1]; ymax = DrawingArea[3];
199 int rx0 = Max2(xmin,Min3(x0,x1,x2));
200 int ry0 = Max2(ymin,Min3(y0,y1,y2));
201 int rx1 = Min2(xmax,Max3(x0,x1,x2));
202 int ry1 = Min2(ymax,Max3(y0,y1,y2));
203 if( rx0>=rx1 || ry0>=ry1) return;
206 u0 = PacketBuffer.U1[8]; v0 = PacketBuffer.U1[9];
207 u1 = PacketBuffer.U1[16]; v1 = PacketBuffer.U1[17];
208 u2 = PacketBuffer.U1[24]; v2 = PacketBuffer.U1[25];
210 r4 = s32(PacketBuffer.U1[0]);
211 g4 = s32(PacketBuffer.U1[1]);
212 b4 = s32(PacketBuffer.U1[2]);
217 if( y0!=y1 || x0>x1 )
219 GPU_SWAP(x0, x1, temp);
220 GPU_SWAP(y0, y1, temp);
221 GPU_SWAP(u0, u1, temp);
222 GPU_SWAP(v0, v1, temp);
227 if( y1!=y2 || x1>x2 )
229 GPU_SWAP(x1, x2, temp);
230 GPU_SWAP(y1, y2, temp);
231 GPU_SWAP(u1, u2, temp);
232 GPU_SWAP(v1, v2, temp);
237 if( y0!=y1 || x0>x1 )
239 GPU_SWAP(x0, x1, temp);
240 GPU_SWAP(y0, y1, temp);
241 GPU_SWAP(u0, u1, temp);
242 GPU_SWAP(v0, v1, temp);
248 dx = (x2 - x1) * ya - (x2 - x0) * yb;
249 du4 = (u2 - u1) * ya - (u2 - u0) * yb;
250 dv4 = (v2 - v1) * ya - (v2 - v0) * yb;
254 du4 = xInvMulx( du4, iF, iS);
255 dv4 = xInvMulx( dv4, iF, iS);
256 tInc = ((u32)(du4<<7)&0x7fff0000) | ((u32)(dv4>>9)&0x00007fff);
257 tMsk = (TextureWindow[2]<<23) | (TextureWindow[3]<<7) | 0x00ff00ff;
259 for (s32 loop0 = 2; loop0; --loop0)
268 x4 = y0!=y1 ? x3 : i2x(x1);
271 xInv( (y2 - y0), iF, iS);
272 dx3 = xInvMulx( (x2 - x0), iF, iS);
273 du3 = xInvMulx( (u2 - u0), iF, iS);
274 dv3 = xInvMulx( (v2 - v0), iF, iS);
275 dx4 = xLoDivx ( (x1 - x0), (y1 - y0));
279 xInv( (y1 - y0), iF, iS);
280 dx3 = xInvMulx( (x1 - x0), iF, iS);
281 du3 = xInvMulx( (u1 - u0), iF, iS);
282 dv3 = xInvMulx( (v1 - v0), iF, iS);
283 dx4 = xLoDivx ( (x2 - x0), (y2 - y0));
293 u3 = i2x(u0) + (du3 * temp);
294 v3 = i2x(v0) + (dv3 * temp);
295 x3 = i2x(x0) + (dx3 * temp);
297 dx4 = xLoDivx((x2 - x1), (y2 - y1));
304 x4 = i2x(x0) + (dx4 * (y1 - y0));
305 xInv( (y2 - y1), iF, iS);
306 dx3 = xInvMulx( (x2 - x1), iF, iS);
307 du3 = xInvMulx( (u2 - u1), iF, iS);
308 dv3 = xInvMulx( (v2 - v1), iF, iS);
321 if (yb > ymax) yb = ymax;
322 if (ya>=yb) continue;
329 u16* PixelBase = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(0, ya)];
331 if (!progressInterlace)
333 for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, u3+=du3, v3+=dv3)
338 if( (xa>xmax) || (xb<xmin) ) continue;
352 if(xb > xmax) xb = xmax;
354 if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
359 bool flag=progressInterlace_flag;
360 for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, u3+=du3, v3+=dv3)
362 if ((ya&li) && (flag=!flag)) continue;
365 if( (xa>xmax) || (xb<xmin) ) continue;
379 if(xb > xmax) xb = xmax;
381 if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
387 /*----------------------------------------------------------------------
389 ----------------------------------------------------------------------*/
391 void gpuDrawG3(const PP gpuPolySpanDriver)
393 const int li=linesInterlace;
395 s32 xa, xb, xmin, xmax;
396 s32 ya, yb, ymin, ymax;
397 s32 x0, x1, x2, x3, dx3=0, x4, dx4=0, dx;
399 s32 r0, r1, r2, r3, dr3=0;
400 s32 g0, g1, g2, g3, dg3=0;
401 s32 b0, b1, b2, b3, db3=0;
403 x0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[2] ); GPU_TESTRANGE(x0);
404 y0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[3] ); GPU_TESTRANGE(y0);
405 x1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[6] ); GPU_TESTRANGE(x1);
406 y1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[7] ); GPU_TESTRANGE(y1);
407 x2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[10]); GPU_TESTRANGE(x2);
408 y2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[11]); GPU_TESTRANGE(y2);
410 x0 += DrawingOffset[0]; x1 += DrawingOffset[0]; x2 += DrawingOffset[0];
411 y0 += DrawingOffset[1]; y1 += DrawingOffset[1]; y2 += DrawingOffset[1];
413 xmin = DrawingArea[0]; xmax = DrawingArea[2];
414 ymin = DrawingArea[1]; ymax = DrawingArea[3];
417 int rx0 = Max2(xmin,Min3(x0,x1,x2));
418 int ry0 = Max2(ymin,Min3(y0,y1,y2));
419 int rx1 = Min2(xmax,Max3(x0,x1,x2));
420 int ry1 = Min2(ymax,Max3(y0,y1,y2));
421 if( rx0>=rx1 || ry0>=ry1) return;
424 r0 = PacketBuffer.U1[0]; g0 = PacketBuffer.U1[1]; b0 = PacketBuffer.U1[2];
425 r1 = PacketBuffer.U1[8]; g1 = PacketBuffer.U1[9]; b1 = PacketBuffer.U1[10];
426 r2 = PacketBuffer.U1[16]; g2 = PacketBuffer.U1[17]; b2 = PacketBuffer.U1[18];
430 if( y0!=y1 || x0>x1 )
432 GPU_SWAP(x0, x1, temp); GPU_SWAP(y0, y1, temp);
433 GPU_SWAP(r0, r1, temp); GPU_SWAP(g0, g1, temp); GPU_SWAP(b0, b1, temp);
438 if( y1!=y2 || x1>x2 )
440 GPU_SWAP(x1, x2, temp); GPU_SWAP(y1, y2, temp);
441 GPU_SWAP(r1, r2, temp); GPU_SWAP(g1, g2, temp); GPU_SWAP(b1, b2, temp);
446 if( y0!=y1 || x0>x1 )
448 GPU_SWAP(x0, x1, temp); GPU_SWAP(y0, y1, temp);
449 GPU_SWAP(r0, r1, temp); GPU_SWAP(g0, g1, temp); GPU_SWAP(b0, b1, temp);
455 dx = (x2 - x1) * ya - (x2 - x0) * yb;
456 dr4 = (r2 - r1) * ya - (r2 - r0) * yb;
457 dg4 = (g2 - g1) * ya - (g2 - g0) * yb;
458 db4 = (b2 - b1) * ya - (b2 - b0) * yb;
462 dr4 = xInvMulx( dr4, iF, iS);
463 dg4 = xInvMulx( dg4, iF, iS);
464 db4 = xInvMulx( db4, iF, iS);
465 u32 dr = (u32)(dr4<< 8)&(0xffffffff<<21); if(dr4<0) dr+= 1<<21;
466 u32 dg = (u32)(dg4>> 3)&(0xffffffff<<10); if(dg4<0) dg+= 1<<10;
467 u32 db = (u32)(db4>>14)&(0xffffffff ); if(db4<0) db+= 1<< 0;
470 for (s32 loop0 = 2; loop0; --loop0)
480 x4 = y0!=y1 ? x3 : i2x(x1);
483 xInv( (y2 - y0), iF, iS);
484 dx3 = xInvMulx( (x2 - x0), iF, iS);
485 dr3 = xInvMulx( (r2 - r0), iF, iS);
486 dg3 = xInvMulx( (g2 - g0), iF, iS);
487 db3 = xInvMulx( (b2 - b0), iF, iS);
488 dx4 = xLoDivx ( (x1 - x0), (y1 - y0));
492 xInv( (y1 - y0), iF, iS);
493 dx3 = xInvMulx( (x1 - x0), iF, iS);
494 dr3 = xInvMulx( (r1 - r0), iF, iS);
495 dg3 = xInvMulx( (g1 - g0), iF, iS);
496 db3 = xInvMulx( (b1 - b0), iF, iS);
497 dx4 = xLoDivx ( (x2 - x0), (y2 - y0));
507 r3 = i2x(r0) + (dr3 * temp);
508 g3 = i2x(g0) + (dg3 * temp);
509 b3 = i2x(b0) + (db3 * temp);
510 x3 = i2x(x0) + (dx3 * temp);
512 dx4 = xLoDivx((x2 - x1), (y2 - y1));
520 x4 = i2x(x0) + (dx4 * (y1 - y0));
522 xInv( (y2 - y1), iF, iS);
523 dx3 = xInvMulx( (x2 - x1), iF, iS);
524 dr3 = xInvMulx( (r2 - r1), iF, iS);
525 dg3 = xInvMulx( (g2 - g1), iF, iS);
526 db3 = xInvMulx( (b2 - b1), iF, iS);
534 x3 += dx3*temp; x4 += dx4*temp;
535 r3 += dr3*temp; g3 += dg3*temp; b3 += db3*temp;
537 if (yb > ymax) yb = ymax;
538 if (ya>=yb) continue;
540 x3+= fixed_HALF; x4+= fixed_HALF;
541 r3+= fixed_HALF; g3+= fixed_HALF; b3+= fixed_HALF;
543 u16* PixelBase = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(0, ya)];
545 if (!progressInterlace)
547 for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, r3+=dr3, g3+=dg3, b3+=db3)
552 if( (xa>xmax) || (xb<xmin) ) continue;
558 r4 = r3 + dr4*temp; g4 = g3 + dg4*temp; b4 = b3 + db4*temp;
562 r4 = r3; g4 = g3; b4 = b3;
564 if(xb > xmax) xb = xmax;
566 if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
571 bool flag=progressInterlace_flag;
572 for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, r3+=dr3, g3+=dg3, b3+=db3)
574 if ((ya&li) && (flag=!flag)) continue;
577 if( (xa>xmax) || (xb<xmin) ) continue;
583 r4 = r3 + dr4*temp; g4 = g3 + dg4*temp; b4 = b3 + db4*temp;
587 r4 = r3; g4 = g3; b4 = b3;
589 if(xb > xmax) xb = xmax;
591 if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
597 /*----------------------------------------------------------------------
599 ----------------------------------------------------------------------*/
601 void gpuDrawGT3(const PP gpuPolySpanDriver)
603 const int li=linesInterlace;
605 s32 xa, xb, xmin, xmax;
606 s32 ya, yb, ymin, ymax;
607 s32 x0, x1, x2, x3, dx3=0, x4, dx4=0, dx;
609 s32 u0, u1, u2, u3, du3=0;
610 s32 v0, v1, v2, v3, dv3=0;
611 s32 r0, r1, r2, r3, dr3=0;
612 s32 g0, g1, g2, g3, dg3=0;
613 s32 b0, b1, b2, b3, db3=0;
615 x0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[2] ); GPU_TESTRANGE(x0);
616 y0 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[3] ); GPU_TESTRANGE(y0);
617 x1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[8] ); GPU_TESTRANGE(x1);
618 y1 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[9] ); GPU_TESTRANGE(y1);
619 x2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[14]); GPU_TESTRANGE(x2);
620 y2 = GPU_EXPANDSIGN_POLY(PacketBuffer.S2[15]); GPU_TESTRANGE(y2);
622 x0 += DrawingOffset[0]; x1 += DrawingOffset[0]; x2 += DrawingOffset[0];
623 y0 += DrawingOffset[1]; y1 += DrawingOffset[1]; y2 += DrawingOffset[1];
625 xmin = DrawingArea[0]; xmax = DrawingArea[2];
626 ymin = DrawingArea[1]; ymax = DrawingArea[3];
629 int rx0 = Max2(xmin,Min3(x0,x1,x2));
630 int ry0 = Max2(ymin,Min3(y0,y1,y2));
631 int rx1 = Min2(xmax,Max3(x0,x1,x2));
632 int ry1 = Min2(ymax,Max3(y0,y1,y2));
633 if( rx0>=rx1 || ry0>=ry1) return;
636 r0 = PacketBuffer.U1[0]; g0 = PacketBuffer.U1[1]; b0 = PacketBuffer.U1[2];
637 u0 = PacketBuffer.U1[8]; v0 = PacketBuffer.U1[9];
638 r1 = PacketBuffer.U1[12]; g1 = PacketBuffer.U1[13]; b1 = PacketBuffer.U1[14];
639 u1 = PacketBuffer.U1[20]; v1 = PacketBuffer.U1[21];
640 r2 = PacketBuffer.U1[24]; g2 = PacketBuffer.U1[25]; b2 = PacketBuffer.U1[26];
641 u2 = PacketBuffer.U1[32]; v2 = PacketBuffer.U1[33];
645 if( y0!=y1 || x0>x1 )
647 GPU_SWAP(x0, x1, temp); GPU_SWAP(y0, y1, temp);
648 GPU_SWAP(u0, u1, temp); GPU_SWAP(v0, v1, temp);
649 GPU_SWAP(r0, r1, temp); GPU_SWAP(g0, g1, temp); GPU_SWAP(b0, b1, temp);
654 if( y1!=y2 || x1>x2 )
656 GPU_SWAP(x1, x2, temp); GPU_SWAP(y1, y2, temp);
657 GPU_SWAP(u1, u2, temp); GPU_SWAP(v1, v2, temp);
658 GPU_SWAP(r1, r2, temp); GPU_SWAP(g1, g2, temp); GPU_SWAP(b1, b2, temp);
663 if( y0!=y1 || x0>x1 )
665 GPU_SWAP(x0, x1, temp); GPU_SWAP(y0, y1, temp);
666 GPU_SWAP(u0, u1, temp); GPU_SWAP(v0, v1, temp);
667 GPU_SWAP(r0, r1, temp); GPU_SWAP(g0, g1, temp); GPU_SWAP(b0, b1, temp);
673 dx = (x2 - x1) * ya - (x2 - x0) * yb;
674 du4 = (u2 - u1) * ya - (u2 - u0) * yb;
675 dv4 = (v2 - v1) * ya - (v2 - v0) * yb;
676 dr4 = (r2 - r1) * ya - (r2 - r0) * yb;
677 dg4 = (g2 - g1) * ya - (g2 - g0) * yb;
678 db4 = (b2 - b1) * ya - (b2 - b0) * yb;
683 du4 = xInvMulx( du4, iF, iS);
684 dv4 = xInvMulx( dv4, iF, iS);
685 dr4 = xInvMulx( dr4, iF, iS);
686 dg4 = xInvMulx( dg4, iF, iS);
687 db4 = xInvMulx( db4, iF, iS);
688 u32 dr = (u32)(dr4<< 8)&(0xffffffff<<21); if(dr4<0) dr+= 1<<21;
689 u32 dg = (u32)(dg4>> 3)&(0xffffffff<<10); if(dg4<0) dg+= 1<<10;
690 u32 db = (u32)(db4>>14)&(0xffffffff ); if(db4<0) db+= 1<< 0;
692 tInc = ((u32)(du4<<7)&0x7fff0000) | ((u32)(dv4>>9)&0x00007fff);
693 tMsk = (TextureWindow[2]<<23) | (TextureWindow[3]<<7) | 0x00ff00ff;
695 for (s32 loop0 = 2; loop0; --loop0)
707 x4 = y0!=y1 ? x3 : i2x(x1);
710 xInv( (y2 - y0), iF, iS);
711 dx3 = xInvMulx( (x2 - x0), iF, iS);
712 du3 = xInvMulx( (u2 - u0), iF, iS);
713 dv3 = xInvMulx( (v2 - v0), iF, iS);
714 dr3 = xInvMulx( (r2 - r0), iF, iS);
715 dg3 = xInvMulx( (g2 - g0), iF, iS);
716 db3 = xInvMulx( (b2 - b0), iF, iS);
717 dx4 = xLoDivx ( (x1 - x0), (y1 - y0));
721 xInv( (y1 - y0), iF, iS);
722 dx3 = xInvMulx( (x1 - x0), iF, iS);
723 du3 = xInvMulx( (u1 - u0), iF, iS);
724 dv3 = xInvMulx( (v1 - v0), iF, iS);
725 dr3 = xInvMulx( (r1 - r0), iF, iS);
726 dg3 = xInvMulx( (g1 - g0), iF, iS);
727 db3 = xInvMulx( (b1 - b0), iF, iS);
728 dx4 = xLoDivx ( (x2 - x0), (y2 - y0));
738 u3 = i2x(u0) + (du3 * temp);
739 v3 = i2x(v0) + (dv3 * temp);
740 r3 = i2x(r0) + (dr3 * temp);
741 g3 = i2x(g0) + (dg3 * temp);
742 b3 = i2x(b0) + (db3 * temp);
743 x3 = i2x(x0) + (dx3 * temp);
745 dx4 = xLoDivx((x2 - x1), (y2 - y1));
755 x4 = i2x(x0) + (dx4 * (y1 - y0));
757 xInv( (y2 - y1), iF, iS);
758 dx3 = xInvMulx( (x2 - x1), iF, iS);
759 du3 = xInvMulx( (u2 - u1), iF, iS);
760 dv3 = xInvMulx( (v2 - v1), iF, iS);
761 dr3 = xInvMulx( (r2 - r1), iF, iS);
762 dg3 = xInvMulx( (g2 - g1), iF, iS);
763 db3 = xInvMulx( (b2 - b1), iF, iS);
771 x3 += dx3*temp; x4 += dx4*temp;
772 u3 += du3*temp; v3 += dv3*temp;
773 r3 += dr3*temp; g3 += dg3*temp; b3 += db3*temp;
775 if (yb > ymax) yb = ymax;
776 if (ya>=yb) continue;
778 x3+= fixed_HALF; x4+= fixed_HALF;
779 u3+= fixed_HALF; v4+= fixed_HALF;
780 r3+= fixed_HALF; g3+= fixed_HALF; b3+= fixed_HALF;
781 u16* PixelBase = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(0, ya)];
783 if (!progressInterlace)
785 for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, u3+=du3, v3+=dv3, r3+=dr3, g3+=dg3, b3+=db3)
790 if( (xa>xmax) || (xb<xmin)) continue;
796 u4 = u3 + du4*temp; v4 = v3 + dv4*temp;
797 r4 = r3 + dr4*temp; g4 = g3 + dg4*temp; b4 = b3 + db4*temp;
802 r4 = r3; g4 = g3; b4 = b3;
804 if(xb > xmax) xb = xmax;
806 if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);
811 bool flag=progressInterlace_flag;
812 for(;ya<yb;++ya, PixelBase += FRAME_WIDTH, x3+=dx3, x4+=dx4, u3+=du3, v3+=dv3, r3+=dr3, g3+=dg3, b3+=db3)
814 if ((ya&li) && (flag=!flag)) continue;
817 if ((xa>xmax) || (xb<xmin)) continue;
823 u4 = u3 + du4*temp; v4 = v3 + dv4*temp;
824 r4 = r3 + dr4*temp; g4 = g3 + dg4*temp; b4 = b3 + db4*temp;
829 r4 = r3; g4 = g3; b4 = b3;
831 if(xb > xmax) xb = xmax;
833 if(xb>0) gpuPolySpanDriver(PixelBase + xa,xb);