notaz.gp2x.de / pcsx_rearmed.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
spu: try some reverb resample filtering
[pcsx_rearmed.git] / plugins / gpu_unai / gpu_inner_light.h
... / ...
CommitLineData
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
26static 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_unai.LightLUT[(j*32) + i] = val;
69 }
70 }
71}
72
73
74////////////////////////////////////////////////////////////////////////////////
75// Create packed Gouraud fixed-pt 8.8 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// gcol_t output: ccccccccXXXXXXXX for c in [r, g, b]
83// ^ bit 16
84// Where 'r,g,b' are integer bits of colors, 'X' fixed-pt, and '-' don't care
85////////////////////////////////////////////////////////////////////////////////
86GPU_INLINE gcol_t gpuPackGouraudCol(u32 r, u32 g, u32 b)
87{
88 return (gcol_t){
89 (u16)(r >> 2),
90 (u16)(g >> 2),
91 (u16)(b >> 2),
92 };
93}
94
95////////////////////////////////////////////////////////////////////////////////
96// Create packed increment for Gouraud fixed-pt 8.8 rgb triplet
97//
98// INPUT:
99// Sign-extended 8.10 fixed-pt r,g,b color increment values (only dr is shown)
100// 'dr' input: ssssssssssssssrrrrrrrrXXXXXXXXXX
101// ^ bit 31
102// RETURNS:
103// gcol_t output: ccccccccXXXXXXXX for c in [r, g, b]
104// ^ bit 16
105// Where 'r,g,b' are integer bits of colors, 'X' fixed-pt, and 's' sign bits
106//
107// NOTE: The correctness of this code/method has not been fully verified,
108// having been merely factored out from original code in
109// poly-drawing functions. Feel free to check/improve it -senquack
110////////////////////////////////////////////////////////////////////////////////
111GPU_INLINE gcol_t gpuPackGouraudColInc(s32 dr, s32 dg, s32 db)
112{
113 return (gcol_t){
114 (u16)((dr >> 2) + (dr < 0)),
115 (u16)((dg >> 2) + (dg < 0)),
116 (u16)((db >> 2) + (db < 0)),
117 };
118}
119
120////////////////////////////////////////////////////////////////////////////////
121// Extract bgr555 color from Gouraud u32 fixed-pt 8.8 rgb triplet
122//
123// INPUT:
124// 'gCol' input: ccccccccXXXXXXXX for c in [r, g, b]
125// ^ bit 16
126// RETURNS:
127// u16 output: 0bbbbbgggggrrrrr
128// ^ bit 16
129// Where 'r,g,b' are integer bits of colors, 'X' fixed-pt, and '0' zero
130////////////////////////////////////////////////////////////////////////////////
131GPU_INLINE uint_fast16_t gpuLightingRGB(gcol_t gCol)
132{
133 return (gCol.c.r >> 11) |
134 ((gCol.c.g >> 6) & 0x3e0) |
135 ((gCol.c.b >> 1) & 0x7c00);
136}
137
138////////////////////////////////////////////////////////////////////////////////
139// Convert packed Gouraud u32 fixed-pt 8.8 rgb triplet in 'gCol'
140// to padded u32 5.4 bgr fixed-pt triplet, suitable for use
141// with HQ 24-bit lighting/quantization.
142//
143// INPUT:
144// 'gCol' input: ccccccccXXXXXXXX for c in [r, g, b]
145// ^ bit 16
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////////////////////////////////////////////////////////////////////////////////
151GPU_INLINE u32 gpuLightingRGB24(gcol_t gCol)
152{
153 return (gCol.c.r >> 7)
154 | ((gCol.c.g >> 7) << 10)
155 | ((gCol.c.b >> 7) << 20);
156}
157
158////////////////////////////////////////////////////////////////////////////////
159// Apply fast (low-precision) 5-bit lighting to bgr555 texture color:
160//
161// INPUT:
162// 'r5','g5','b5' are unsigned 5-bit color values, value of 15
163// is midpoint that doesn't modify that component of texture
164// 'uSrc' input: -bbbbbgggggrrrrr
165// ^ bit 16
166// RETURNS:
167// u16 output: 0bbbbbgggggrrrrr
168// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
169////////////////////////////////////////////////////////////////////////////////
170GPU_INLINE uint_fast16_t gpuLightingTXTGeneric(uint_fast16_t uSrc, u8 r5, u8 g5, u8 b5)
171{
172 return (gpu_unai.LightLUT[((uSrc&0x7C00)>>5) | b5] << 10) |
173 (gpu_unai.LightLUT[ (uSrc&0x03E0) | g5] << 5) |
174 (gpu_unai.LightLUT[((uSrc&0x001F)<<5) | r5] ) |
175 (uSrc & 0x8000);
176}
177
178
179////////////////////////////////////////////////////////////////////////////////
180// Apply fast (low-precision) 5-bit Gouraud lighting to bgr555 texture color:
181//
182// INPUT:
183// 'gCol' is a Gouraud fixed-pt 8.8 rgb triplet
184// 'gCol' input: ccccccccXXXXXXXX for c in [r, g, b]
185// ^ bit 16
186// 'uSrc' input: -bbbbbgggggrrrrr
187// ^ bit 16
188// RETURNS:
189// u16 output: 0bbbbbgggggrrrrr
190// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
191////////////////////////////////////////////////////////////////////////////////
192GPU_INLINE uint_fast16_t gpuLightingTXTGouraud(uint_fast16_t uSrc, gcol_t gCol)
193{
194 return (gpu_unai.LightLUT[((uSrc&0x7C00)>>5) | (gCol.c.b >> 11)] << 10) |
195 (gpu_unai.LightLUT[ (uSrc&0x03E0) | (gCol.c.g >> 11)] << 5) |
196 (gpu_unai.LightLUT[((uSrc&0x001F)<<5) | (gCol.c.r >> 11)]) |
197 (uSrc & 0x8000);
198}
199
200////////////////////////////////////////////////////////////////////////////////
201// Apply high-precision 8-bit lighting to bgr555 texture color,
202// returning a padded u32 5.4:5.4:5.4 bgr fixed-pt triplet
203// suitable for use with HQ 24-bit lighting/quantization.
204//
205// INPUT:
206// 'r8','g8','b8' are unsigned 8-bit color component values, value of
207// 127 is midpoint that doesn't modify that component of texture
208//
209// uSrc input: -bbbbbgggggrrrrr
210// ^ bit 16
211// RETURNS:
212// u32 output: 000bbbbbXXXX0gggggXXXX0rrrrrXXXX
213// ^ bit 31
214// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
215////////////////////////////////////////////////////////////////////////////////
216GPU_INLINE u32 gpuLightingTXT24(uint_fast16_t uSrc, u8 r8, u8 g8, u8 b8)
217{
218 uint_fast16_t r1 = uSrc&0x001F;
219 uint_fast16_t g1 = uSrc&0x03E0;
220 uint_fast16_t b1 = uSrc&0x7C00;
221
222 uint_fast16_t r2 = r8;
223 uint_fast16_t g2 = g8;
224 uint_fast16_t b2 = b8;
225
226 u32 r3 = r1 * r2; if (r3 & 0xFFFFF000) r3 = ~0xFFFFF000;
227 u32 g3 = g1 * g2; if (g3 & 0xFFFE0000) g3 = ~0xFFFE0000;
228 u32 b3 = b1 * b2; if (b3 & 0xFFC00000) b3 = ~0xFFC00000;
229
230 return ((r3>> 3) ) |
231 ((g3>> 8)<<10) |
232 ((b3>>13)<<20);
233}
234
235
236////////////////////////////////////////////////////////////////////////////////
237// Apply high-precision 8-bit lighting to bgr555 texture color in 'uSrc',
238// returning a padded u32 5.4:5.4:5.4 bgr fixed-pt triplet
239// suitable for use with HQ 24-bit lighting/quantization.
240//
241// INPUT:
242// 'uSrc' input: -bbbbbgggggrrrrr
243// ^ bit 16
244// 'gCol' input: ccccccccXXXXXXXX for c in [r, g, b]
245// ^ bit 16
246// RETURNS:
247// u32 output: 000bbbbbXXXX0gggggXXXX0rrrrrXXXX
248// ^ bit 31
249// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
250////////////////////////////////////////////////////////////////////////////////
251GPU_INLINE u32 gpuLightingTXT24Gouraud(uint_fast16_t uSrc, gcol_t gCol)
252{
253 uint_fast16_t r1 = uSrc&0x001F;
254 uint_fast16_t g1 = uSrc&0x03E0;
255 uint_fast16_t b1 = uSrc&0x7C00;
256
257 uint_fast16_t r2 = gCol.c.r >> 8;
258 uint_fast16_t g2 = gCol.c.g >> 8;
259 uint_fast16_t b2 = gCol.c.b >> 8;
260
261 u32 r3 = r1 * r2; if (r3 & 0xFFFFF000) r3 = ~0xFFFFF000;
262 u32 g3 = g1 * g2; if (g3 & 0xFFFE0000) g3 = ~0xFFFE0000;
263 u32 b3 = b1 * b2; if (b3 & 0xFFC00000) b3 = ~0xFFC00000;
264
265 return ((r3>> 3) ) |
266 ((g3>> 8)<<10) |
267 ((b3>>13)<<20);
268}
269
270#endif //_OP_LIGHT_H_
ARM optimized PCSX fork