plugins/gpu_senquack/gpu_inner_light.h

   1 /***************************************************************************
   2 *   Copyright (C) 2016 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 #ifndef _OP_LIGHT_H_
  22 #define _OP_LIGHT_H_
  23
  24 //  GPU color operations for lighting calculations
  25
  26 static void SetupLightLUT()
  27 {
  28         // 1024-entry lookup table that modulates 5-bit texture + 5-bit light value.
  29         // A light value of 15 does not modify the incoming texture color.
  30         // LightLUT[32*32] array is initialized to following values:
  31         //  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  32         //  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  33         //  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
  34         //  0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5,
  35         //  0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7,
  36         //  0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9,
  37         //  0, 0, 0, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 9, 9, 9,10,10,10,11,11,
  38         //  0, 0, 0, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 7, 8, 8, 9, 9,10,10,10,11,11,12,12,13,13,
  39         //  0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15,
  40         //  0, 0, 1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6, 7, 7, 8, 9, 9,10,10,11,11,12,12,13,14,14,15,15,16,16,17,
  41         //  0, 0, 1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 7, 8, 8, 9,10,10,11,11,12,13,13,14,15,15,16,16,17,18,18,19,
  42         //  0, 0, 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9,10,11,11,12,13,13,14,15,15,16,17,17,18,19,19,20,21,
  43         //  0, 0, 1, 2, 3, 3, 4, 5, 6, 6, 7, 8, 9, 9,10,11,12,12,13,14,15,15,16,17,18,18,19,20,21,21,22,23,
  44         //  0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 8, 9,10,11,12,13,13,14,15,16,17,17,18,19,20,21,21,22,23,24,25,
  45         //  0, 0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9,10,11,12,13,14,14,15,16,17,18,19,20,21,21,22,23,24,25,26,27,
  46         //  0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,
  47         //  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
  48         //  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,31,
  49         //  0, 1, 2, 3, 4, 5, 6, 7, 9,10,11,12,13,14,15,16,18,19,20,21,22,23,24,25,27,28,29,30,31,31,31,31,
  50         //  0, 1, 2, 3, 4, 5, 7, 8, 9,10,11,13,14,15,16,17,19,20,21,22,23,24,26,27,28,29,30,31,31,31,31,31,
  51         //  0, 1, 2, 3, 5, 6, 7, 8,10,11,12,13,15,16,17,18,20,21,22,23,25,26,27,28,30,31,31,31,31,31,31,31,
  52         //  0, 1, 2, 3, 5, 6, 7, 9,10,11,13,14,15,17,18,19,21,22,23,24,26,27,28,30,31,31,31,31,31,31,31,31,
  53         //  0, 1, 2, 4, 5, 6, 8, 9,11,12,13,15,16,17,19,20,22,23,24,26,27,28,30,31,31,31,31,31,31,31,31,31,
  54         //  0, 1, 2, 4, 5, 7, 8,10,11,12,14,15,17,18,20,21,23,24,25,27,28,30,31,31,31,31,31,31,31,31,31,31,
  55         //  0, 1, 3, 4, 6, 7, 9,10,12,13,15,16,18,19,21,22,24,25,27,28,30,31,31,31,31,31,31,31,31,31,31,31,
  56         //  0, 1, 3, 4, 6, 7, 9,10,12,14,15,17,18,20,21,23,25,26,28,29,31,31,31,31,31,31,31,31,31,31,31,31,
  57         //  0, 1, 3, 4, 6, 8, 9,11,13,14,16,17,19,21,22,24,26,27,29,30,31,31,31,31,31,31,31,31,31,31,31,31,
  58         //  0, 1, 3, 5, 6, 8,10,11,13,15,16,18,20,21,23,25,27,28,30,31,31,31,31,31,31,31,31,31,31,31,31,31,
  59         //  0, 1, 3, 5, 7, 8,10,12,14,15,17,19,21,22,24,26,28,29,31,31,31,31,31,31,31,31,31,31,31,31,31,31,
  60         //  0, 1, 3, 5, 7, 9,10,12,14,16,18,19,21,23,25,27,29,30,31,31,31,31,31,31,31,31,31,31,31,31,31,31,
  61         //  0, 1, 3, 5, 7, 9,11,13,15,16,18,20,22,24,26,28,30,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,
  62         //  0, 1, 3, 5, 7, 9,11,13,15,17,19,21,23,25,27,29,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31
  63
  64         for (int j=0; j < 32; ++j) {
  65                 for (int i=0; i < 32; ++i) {
  66                         int val = i * j / 16;
  67                         if (val > 31) val = 31;
  68                         gpu_senquack.LightLUT[(j*32) + i] = val;
  69                 }
  70         }
  71 }
  72
  73
  74 ////////////////////////////////////////////////////////////////////////////////
  75 // Create packed Gouraud fixed-pt 8.3:8.3:8.2 rgb triplet
  76 //
  77 // INPUT:
  78 // 'r','g','b' are 8.10 fixed-pt color components (r shown here)
  79 //     'r' input:  --------------rrrrrrrrXXXXXXXXXX
  80 //                 ^ bit 31
  81 // RETURNS:
  82 //    u32 output:  rrrrrrrrXXXggggggggXXXbbbbbbbbXX
  83 //                 ^ bit 31
  84 // Where 'r,g,b' are integer bits of colors, 'X' fixed-pt, and '-' don't care
  85 ////////////////////////////////////////////////////////////////////////////////
  86 GPU_INLINE u32 gpuPackGouraudCol(u32 r, u32 g, u32 b)
  87 {
  88         return ((u32)(b>> 8)&(0x03ff    ))
  89              | ((u32)(g<< 3)&(0x07ff<<10))
  90              | ((u32)(r<<14)&(0x07ff<<21));
  91 }
  92
  93
  94 ////////////////////////////////////////////////////////////////////////////////
  95 // Create packed increment for Gouraud fixed-pt 8.3:8.3:8.2 rgb triplet
  96 //
  97 // INPUT:
  98 //  Sign-extended 8.10 fixed-pt r,g,b color increment values (only dr is shown)
  99 //   'dr' input:  ssssssssssssssrrrrrrrrXXXXXXXXXX
 100 //                ^ bit 31
 101 // RETURNS:
 102 //   u32 output:  rrrrrrrrXXXggggggggXXXbbbbbbbbXX
 103 //                ^ bit 31
 104 // Where 'r,g,b' are integer bits of colors, 'X' fixed-pt, and 's' sign bits
 105 //
 106 // NOTE: The correctness of this code/method has not been fully verified,
 107 //       having been merely factored out from original code in
 108 //       poly-drawing functions. Feel free to check/improve it -senquack
 109 ////////////////////////////////////////////////////////////////////////////////
 110 GPU_INLINE u32 gpuPackGouraudColInc(s32 dr, s32 dg, s32 db)
 111 {
 112         u32 dr_tmp = (u32)(dr << 14)&(0xffffffff<<21);  if (dr < 0) dr_tmp += 1<<21;
 113         u32 dg_tmp = (u32)(dg <<  3)&(0xffffffff<<10);  if (dg < 0) dg_tmp += 1<<10;
 114         u32 db_tmp = (u32)(db >>  8)&(0xffffffff    );  if (db < 0) db_tmp += 1<< 0;
 115         return db_tmp + dg_tmp + dr_tmp;
 116 }
 117
 118
 119 ////////////////////////////////////////////////////////////////////////////////
 120 // Extract bgr555 color from Gouraud u32 fixed-pt 8.3:8.3:8.2 rgb triplet
 121 //
 122 // INPUT:
 123 //  'gCol' input:  rrrrrrrrXXXggggggggXXXbbbbbbbbXX
 124 //                 ^ bit 31
 125 // RETURNS:
 126 //    u16 output:  0bbbbbgggggrrrrr
 127 //                 ^ bit 16
 128 // Where 'r,g,b' are integer bits of colors, 'X' fixed-pt, and '0' zero
 129 ////////////////////////////////////////////////////////////////////////////////
 130 GPU_INLINE uint_fast16_t gpuLightingRGBGeneric(u32 gCol)
 131 {
 132         return ((gCol<< 5)&0x7C00) |
 133                ((gCol>>11)&0x03E0) |
 134                 (gCol>>27);
 135 }
 136
 137
 138 ////////////////////////////////////////////////////////////////////////////////
 139 // Convert packed Gouraud u32 fixed-pt 8.3:8.3:8.2 rgb triplet in 'gCol'
 140 //  to padded u32 5.4:5.4:5.4 bgr fixed-pt triplet, suitable for use
 141 //  with HQ 24-bit lighting/quantization.
 142 //
 143 // INPUT:
 144 //       'gCol' input:  rrrrrrrrXXXggggggggXXXbbbbbbbbXX
 145 //                      ^ bit 31
 146 // RETURNS:
 147 //         u32 output:  000bbbbbXXXX0gggggXXXX0rrrrrXXXX
 148 //                      ^ bit 31
 149 //  Where 'X' are fixed-pt bits, '0' zero-padding, and '-' is don't care
 150 ////////////////////////////////////////////////////////////////////////////////
 151 GPU_INLINE u32 gpuLightingRGB24(u32 gCol)
 152 {
 153         return ((gCol<<19) & (0x1FF<<20)) |
 154                ((gCol>> 2) & (0x1FF<<10)) |
 155                 (gCol>>23);
 156 }
 157
 158
 159 ////////////////////////////////////////////////////////////////////////////////
 160 // Apply fast (low-precision) 5-bit lighting to bgr555 texture color:
 161 //
 162 // INPUT:
 163 //        'r5','g5','b5' are unsigned 5-bit color values, value of 15
 164 //          is midpoint that doesn't modify that component of texture
 165 //        'uSrc' input:  -bbbbbgggggrrrrr
 166 //                       ^ bit 16
 167 // RETURNS:
 168 //          u16 output:  0bbbbbgggggrrrrr
 169 // Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
 170 ////////////////////////////////////////////////////////////////////////////////
 171 GPU_INLINE uint_fast16_t gpuLightingTXTGeneric(uint_fast16_t uSrc, u8 r5, u8 g5, u8 b5)
 172 {
 173         return (gpu_senquack.LightLUT[((uSrc&0x7C00)>>5) | b5] << 10) |
 174                (gpu_senquack.LightLUT[ (uSrc&0x03E0)     | g5] <<  5) |
 175                (gpu_senquack.LightLUT[((uSrc&0x001F)<<5) | r5]      );
 176 }
 177
 178
 179 ////////////////////////////////////////////////////////////////////////////////
 180 // Apply fast (low-precision) 5-bit Gouraud lighting to bgr555 texture color:
 181 //
 182 // INPUT:
 183 //  'gCol' is a packed Gouraud u32 fixed-pt 8.3:8.3:8.2 rgb triplet, value of
 184 //     15.0 is midpoint that does not modify color of texture
 185 //         gCol input :  rrrrrXXXXXXgggggXXXXXXbbbbbXXXXX
 186 //                       ^ bit 31
 187 //        'uSrc' input:  -bbbbbgggggrrrrr
 188 //                       ^ bit 16
 189 // RETURNS:
 190 //          u16 output:  0bbbbbgggggrrrrr
 191 // Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
 192 ////////////////////////////////////////////////////////////////////////////////
 193 GPU_INLINE uint_fast16_t gpuLightingTXTGouraudGeneric(uint_fast16_t uSrc, u32 gCol)
 194 {
 195         return (gpu_senquack.LightLUT[((uSrc&0x7C00)>>5) | ((gCol>> 5)&0x1F)]<<10) |
 196                (gpu_senquack.LightLUT[ (uSrc&0x03E0)     | ((gCol>>16)&0x1F)]<< 5) |
 197                (gpu_senquack.LightLUT[((uSrc&0x001F)<<5) |  (gCol>>27)      ]    );
 198 }
 199
 200
 201 ////////////////////////////////////////////////////////////////////////////////
 202 // Apply high-precision 8-bit lighting to bgr555 texture color,
 203 //  returning a padded u32 5.4:5.4:5.4 bgr fixed-pt triplet
 204 //  suitable for use with HQ 24-bit lighting/quantization.
 205 //
 206 // INPUT:
 207 //        'r8','g8','b8' are unsigned 8-bit color component values, value of
 208 //          127 is midpoint that doesn't modify that component of texture
 209 //
 210 //         uSrc input: -bbbbbgggggrrrrr
 211 //                     ^ bit 16
 212 // RETURNS:
 213 //         u32 output: 000bbbbbXXXX0gggggXXXX0rrrrrXXXX
 214 //                     ^ bit 31
 215 // Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
 216 ////////////////////////////////////////////////////////////////////////////////
 217 GPU_INLINE u32 gpuLightingTXT24(uint_fast16_t uSrc, u8 r8, u8 g8, u8 b8)
 218 {
 219         uint_fast16_t r1 = uSrc&0x001F;
 220         uint_fast16_t g1 = uSrc&0x03E0;
 221         uint_fast16_t b1 = uSrc&0x7C00;
 222
 223         uint_fast16_t r2 = r8;
 224         uint_fast16_t g2 = g8;
 225         uint_fast16_t b2 = b8;
 226
 227         u32 r3 = r1 * r2; if (r3 & 0xFFFFF000) r3 = ~0xFFFFF000;
 228         u32 g3 = g1 * g2; if (g3 & 0xFFFE0000) g3 = ~0xFFFE0000;
 229         u32 b3 = b1 * b2; if (b3 & 0xFFC00000) b3 = ~0xFFC00000;
 230
 231         return ((r3>> 3)    ) |
 232                ((g3>> 8)<<10) |
 233                ((b3>>13)<<20);
 234 }
 235
 236
 237 ////////////////////////////////////////////////////////////////////////////////
 238 // Apply high-precision 8-bit lighting to bgr555 texture color in 'uSrc',
 239 //  returning a padded u32 5.4:5.4:5.4 bgr fixed-pt triplet
 240 //  suitable for use with HQ 24-bit lighting/quantization.
 241 //
 242 // INPUT:
 243 //       'uSrc' input: -bbbbbgggggrrrrr
 244 //                     ^ bit 16
 245 //       'gCol' input: rrrrrrrrXXXggggggggXXXbbbbbbbbXX
 246 //                     ^ bit 31
 247 // RETURNS:
 248 //         u32 output: 000bbbbbXXXX0gggggXXXX0rrrrrXXXX
 249 //                     ^ bit 31
 250 // Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
 251 ////////////////////////////////////////////////////////////////////////////////
 252 GPU_INLINE u32 gpuLightingTXT24Gouraud(uint_fast16_t uSrc, u32 gCol)
 253 {
 254         uint_fast16_t r1 = uSrc&0x001F;
 255         uint_fast16_t g1 = uSrc&0x03E0;
 256         uint_fast16_t b1 = uSrc&0x7C00;
 257
 258         uint_fast16_t r2 = (gCol>>24) & 0xFF;
 259         uint_fast16_t g2 = (gCol>>13) & 0xFF;
 260         uint_fast16_t b2 = (gCol>> 2) & 0xFF;
 261
 262         u32 r3 = r1 * r2; if (r3 & 0xFFFFF000) r3 = ~0xFFFFF000;
 263         u32 g3 = g1 * g2; if (g3 & 0xFFFE0000) g3 = ~0xFFFE0000;
 264         u32 b3 = b1 * b2; if (b3 & 0xFFC00000) b3 = ~0xFFC00000;
 265
 266         return ((r3>> 3)    ) |
 267                ((g3>> 8)<<10) |
 268                ((b3>>13)<<20);
 269 }
 270
 271 #endif  //_OP_LIGHT_H_