plugins/gpu_unai/gpu_raster_line.h

   1 /***************************************************************************
   2 *   Copyright (C) 2010 PCSX4ALL Team                                      *
   3 *   Copyright (C) 2010 Unai                                               *
   4 *                                                                         *
   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.                                   *
   9 *                                                                         *
  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.                          *
  14 *                                                                         *
  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 ***************************************************************************/
  20
  21 #define GPU_TESTRANGE(x)      { if((u32)(x+1024) > 2047) return; }
  22
  23 ///////////////////////////////////////////////////////////////////////////////
  24 //  GPU internal line drawing functions
  25
  26 #define GPU_DIGITS  16
  27 #define GPU_DIGITSC (GPU_DIGITS+3)
  28
  29 INLINE long GPU_DIV(long rs, long rt)
  30 {
  31         return rt ? (rs / rt) : (0);
  32 }
  33
  34 ///////////////////////////////////////////////////////////////////////////////
  35 void gpuDrawLF(const PD gpuPixelDriver)
  36 {
  37         s32 temp;
  38         s32 xmin, xmax;
  39         s32 ymin, ymax;
  40         s32 x0, x1, dx;
  41         s32 y0, y1, dy;
  42
  43         x0 = PacketBuffer.S2[2] + DrawingOffset[0];     GPU_TESTRANGE(x0);
  44         y0 = PacketBuffer.S2[3] + DrawingOffset[1];     GPU_TESTRANGE(y0);
  45         x1 = PacketBuffer.S2[4] + DrawingOffset[0];     GPU_TESTRANGE(x1);
  46         y1 = PacketBuffer.S2[5] + DrawingOffset[1];     GPU_TESTRANGE(y1);
  47
  48         xmin = DrawingArea[0];  xmax = DrawingArea[2];
  49         ymin = DrawingArea[1];  ymax = DrawingArea[3];
  50         const u16 pixeldata = GPU_RGB16(PacketBuffer.U4[0]);
  51
  52         dy = (y1 - y0);
  53         if (dy < 0) dy = -dy;
  54         dx = (x1 - x0);
  55         if (dx < 0) dx = -dx;
  56         if (dx > dy) {
  57                 if (x0 > x1) {
  58                         GPU_SWAP(x0, x1, temp);
  59                         GPU_SWAP(y0, y1, temp);
  60                 }
  61                 y1 = GPU_DIV((y1 - y0) << GPU_DIGITS, dx);
  62                 y0 <<= GPU_DIGITS;
  63                 temp = xmin - x0;
  64                 if (temp > 0) {
  65                         x0 = xmin;
  66                         y0 += (y1 * temp);
  67                 }
  68                 if (x1 > xmax) x1 = xmax;
  69                 x1 -= x0;
  70                 if (x1 < 0) x1 = 0;
  71
  72                 const int li=linesInterlace;
  73                 for (; x1; x1--) {
  74                         temp = y0 >> GPU_DIGITS;
  75                         if( 0 == (temp&li) )  {
  76                                 if ((u32) (temp - ymin) < (u32) (ymax - ymin)) {
  77                                         gpuPixelDriver(&((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, temp)],pixeldata);
  78                                 }
  79                         }
  80                         x0++;
  81                         y0 += y1;
  82                 }
  83         } else if (dy) {
  84                 if (y0 > y1) {
  85                         GPU_SWAP(x0, x1, temp);
  86                         GPU_SWAP(y0, y1, temp);
  87                 }
  88                 x1 = GPU_DIV((x1 - x0) << GPU_DIGITS, dy);
  89                 x0 <<= GPU_DIGITS;
  90                 temp = ymin - y0;
  91                 if (temp > 0) {
  92                         y0 = ymin;
  93                         x0 += (x1 * temp);
  94                 }
  95                 if (y1 > ymax) y1 = ymax;
  96                 y1 -= y0;
  97                 if (y1 < 0) y1 = 0;
  98
  99                 const int li=linesInterlace;
 100                 for (; y1; y1--) {
 101                         if( 0 == (y0&li) )  {
 102                                 temp = x0 >> GPU_DIGITS;
 103                                 if ((u32) (temp - xmin) < (u32) (xmax - xmin)) {
 104                                         gpuPixelDriver(&((u16*)GPU_FrameBuffer)[FRAME_OFFSET(temp, y0)],pixeldata);
 105                                 }
 106                         }
 107                         y0++;
 108                         x0 += x1;
 109                 }
 110
 111         } else {
 112                 if( 0 == (y0&linesInterlace) )  {
 113                         if ((u32) (x0 - xmin) < (u32) (xmax - xmin)) {
 114                                 if ((u32) (y0 - ymin) < (u32) (ymax - ymin)) {
 115                                         gpuPixelDriver(&((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, y0)],pixeldata);
 116                                 }
 117                         }
 118                 }
 119         }
 120 }
 121
 122 /*----------------------------------------------------------------------
 123 GF
 124 ----------------------------------------------------------------------*/
 125
 126 ///////////////////////////////////////////////////////////////////////////////
 127 void gpuDrawLG(const PD gpuPixelDriver)
 128 {
 129         s32 temp;
 130         s32 xmin, xmax;
 131         s32 ymin, ymax;
 132         s32 x0, x1, dx;
 133         s32 y0, y1, dy;
 134         s32 r0, r1;
 135         s32 g0, g1;
 136         s32 b0, b1;
 137
 138         x0 = PacketBuffer.S2[2] + DrawingOffset[0];     GPU_TESTRANGE(x0);
 139         y0 = PacketBuffer.S2[3] + DrawingOffset[1];     GPU_TESTRANGE(y0);
 140         x1 = PacketBuffer.S2[6] + DrawingOffset[0];     GPU_TESTRANGE(x1);
 141         y1 = PacketBuffer.S2[7] + DrawingOffset[1];     GPU_TESTRANGE(y1);
 142
 143         r0 = PacketBuffer.U1[0];  g0 = PacketBuffer.U1[1];  b0 = PacketBuffer.U1[2];
 144         r1 = PacketBuffer.U1[8];  g1 = PacketBuffer.U1[9];      b1 = PacketBuffer.U1[10];
 145
 146         xmin = DrawingArea[0];  xmax = DrawingArea[2];
 147         ymin = DrawingArea[1];  ymax = DrawingArea[3];
 148
 149         dy = (y1 - y0);
 150         if (dy < 0)
 151         dy = -dy;
 152         dx = (x1 - x0);
 153         if (dx < 0)
 154         dx = -dx;
 155         if (dx > dy) {
 156                 if (x0 > x1) {
 157                         GPU_SWAP(x0, x1, temp);
 158                         GPU_SWAP(y0, y1, temp);
 159                         GPU_SWAP(r0, r1, temp);
 160                         GPU_SWAP(g0, g1, temp);
 161                         GPU_SWAP(b0, b1, temp);
 162                 }
 163                 y1 = GPU_DIV((y1 - y0) << GPU_DIGITS, dx);
 164                 r1 = GPU_DIV((r1 - r0) << GPU_DIGITS, dx);
 165                 g1 = GPU_DIV((g1 - g0) << GPU_DIGITS, dx);
 166                 b1 = GPU_DIV((b1 - b0) << GPU_DIGITS, dx);
 167                 y0 <<= GPU_DIGITS;
 168                 r0 <<= GPU_DIGITS;
 169                 g0 <<= GPU_DIGITS;
 170                 b0 <<= GPU_DIGITS;
 171                 temp = xmin - x0;
 172                 if (temp > 0) {
 173                         x0 = xmin;
 174                         y0 += (y1 * temp);
 175                         r0 += (r1 * temp);
 176                         g0 += (g1 * temp);
 177                         b0 += (b1 * temp);
 178                 }
 179                 if (x1 > xmax) x1 = xmax;
 180                 x1 -= x0;
 181                 if (x1 < 0) x1 = 0;
 182
 183                 const int li=linesInterlace;
 184                 for (; x1; x1--) {
 185                         temp = y0 >> GPU_DIGITS;
 186                         if( 0 == (temp&li) )  {
 187                                 if ((u32) (temp - ymin) < (u32) (ymax - ymin)) {
 188                                         gpuPixelDriver (
 189                                                 &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, temp)],
 190                                                 (((b0>>GPU_DIGITSC)&0x1F)<<10) | (((g0>>GPU_DIGITSC)&0x1F)<< 5) | ((r0>>GPU_DIGITSC)&0x1F)
 191                                         );
 192                                 }
 193                         }
 194                         x0++;
 195                         y0 += y1;
 196                         r0 += r1;
 197                         g0 += g1;
 198                         b0 += b1;
 199                 }
 200         } else if (dy) {
 201                 if (y0 > y1) {
 202                         GPU_SWAP(x0, x1, temp);
 203                         GPU_SWAP(y0, y1, temp);
 204                         GPU_SWAP(r0, r1, temp);
 205                         GPU_SWAP(g0, g1, temp);
 206                         GPU_SWAP(b0, b1, temp);
 207                 }
 208                 x1 = GPU_DIV((x1 - x0) << GPU_DIGITS, dy);
 209                 r1 = GPU_DIV((r1 - r0) << GPU_DIGITS, dy);
 210                 g1 = GPU_DIV((g1 - g0) << GPU_DIGITS, dy);
 211                 b1 = GPU_DIV((b1 - b0) << GPU_DIGITS, dy);
 212                 x0 <<= GPU_DIGITS;
 213                 r0 <<= GPU_DIGITS;
 214                 g0 <<= GPU_DIGITS;
 215                 b0 <<= GPU_DIGITS;
 216                 temp = ymin - y0;
 217                 if (temp > 0) {
 218                         y0 = ymin;
 219                         x0 += (x1 * temp);
 220                         r0 += (r1 * temp);
 221                         g0 += (g1 * temp);
 222                         b0 += (b1 * temp);
 223                 }
 224                 if (y1 > ymax) y1 = ymax;
 225                 y1 -= y0;
 226                 if (y1 < 0) y1 = 0;
 227
 228                 const int li=linesInterlace;
 229                 for (; y1; y1--) {
 230                         if( 0 == (y0&li) )  {
 231                                 temp = x0 >> GPU_DIGITS;
 232                                 if ((u32) (temp - xmin) < (u32) (xmax - xmin)) {
 233                                         gpuPixelDriver (
 234                                                 &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(temp, y0)],
 235                                                 (((b0>>GPU_DIGITSC)&0x1F)<<10) | (((g0>>GPU_DIGITSC)&0x1F)<< 5) | ((r0>>GPU_DIGITSC)&0x1F)
 236                                         );
 237                                 }
 238                         }
 239                         y0++;
 240                         x0 += x1;
 241                         r0 += r1;
 242                         g0 += g1;
 243                         b0 += b1;
 244                 }
 245         } else {
 246                 if( 0 == (y0&linesInterlace) )  {
 247                         if ((u32) (x0 - xmin) < (u32) (xmax - xmin)) {
 248                                 if ((u32) (y0 - ymin) < (u32) (ymax - ymin)) {
 249                                         gpuPixelDriver (
 250                                                 &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0, y0)],
 251                                                 (((b0>>GPU_DIGITSC)&0x1F)<<10) | (((g0>>GPU_DIGITSC)&0x1F)<< 5) | ((r0>>GPU_DIGITSC)&0x1F)
 252                                         );
 253                                 }
 254                         }
 255                 }
 256         }
 257 }