//#include "gpu_inner_blend.h"
//#endif
-// TODO: use the arm-optimized gpu_inner_blends for arm builds
#include "gpu_inner_blend.h"
-
#include "gpu_inner_quantization.h"
#include "gpu_inner_light.h"
+#ifdef __arm__
+#include "gpu_inner_blend_arm.h"
+#include "gpu_inner_light_arm.h"
+#define gpuBlending gpuBlendingARM
+#define gpuLightingRGB gpuLightingRGBARM
+#define gpuLightingTXT gpuLightingTXTARM
+#define gpuLightingTXTGouraud gpuLightingTXTGouraudARM
+// Non-dithering lighting and blending functions preserve uSrc
+// MSB. This saves a few operations and useless load/stores.
+#define MSB_PRESERVED (!CF_DITHER)
+#else
+#define gpuBlending gpuBlendingGeneric
+#define gpuLightingRGB gpuLightingRGBGeneric
+#define gpuLightingTXT gpuLightingTXTGeneric
+#define gpuLightingTXTGouraud gpuLightingTXTGouraudGeneric
+#define MSB_PRESERVED 0
+#endif
+
+
// If defined, Gouraud colors are fixed-point 5.11, otherwise they are 8.16
// This is only for debugging/verification of low-precision colors in C.
// Low-precision Gouraud is intended for use by SIMD-optimized inner drivers
else { *(u16*)pDst = col; }
}
} else {
- u16 uDst = *(u16*)pDst;
+ uint_fast16_t uDst = *(u16*)pDst;
if (CF_MASKCHECK) { if (uDst & 0x8000) goto endpixel; }
- u16 uSrc = col;
+ uint_fast16_t uSrc = col;
if (CF_BLEND)
uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
else { *(u16*)pDst = col; }
}
} else {
- u16 uDst = *(u16*)pDst;
+ uint_fast16_t uDst = *(u16*)pDst;
if (CF_MASKCHECK) { if (uDst & 0x8000) goto endpixel; }
col = gpuGouraudColor15bpp(r, g, b);
- u16 uSrc = col;
+ uint_fast16_t uSrc = col;
// Blend func can save an operation if it knows uSrc MSB is
// unset. For untextured prims, this is always true.
// unset. For untextured prims, this is always true.
const bool skip_uSrc_mask = true;
- u16 uSrc, uDst;
+ uint_fast16_t uSrc, uDst;
do
{
if (CF_MASKCHECK || CF_BLEND) { uDst = *pDst; }
{
// Blend func can save an operation if it knows uSrc MSB is unset.
// Untextured prims can always skip (source color always comes with MSB=0).
- // For textured prims, lighting funcs always return it unset. (bonus!)
- const bool skip_uSrc_mask = (!CF_TEXTMODE) || CF_LIGHT;
+ // For textured prims, the generic lighting funcs always return it unset. (bonus!)
+ const bool skip_uSrc_mask = MSB_PRESERVED ? (!CF_TEXTMODE) : (!CF_TEXTMODE) || CF_LIGHT;
- u16 uSrc, uDst, srcMSB;
+ uint_fast16_t uSrc, uDst, srcMSB;
+ bool should_blend;
u32 u0_mask = gpu_unai.TextureWindow[2];
u8 r5, g5, b5;
if (CF_LIGHT)
uSrc = gpuLightingTXT(uSrc, r5, g5, b5);
- if (CF_BLEND && srcMSB)
+ should_blend = MSB_PRESERVED ? uSrc & 0x8000 : srcMSB;
+
+ if (CF_BLEND && should_blend)
uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
- if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
- else if (CF_BLEND || CF_LIGHT) { *pDst = uSrc | srcMSB; }
- else { *pDst = uSrc; }
+ if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
+ else if (!MSB_PRESERVED && (CF_BLEND || CF_LIGHT)) { *pDst = uSrc | srcMSB; }
+ else { *pDst = uSrc; }
endsprite:
u0 += (CF_TEXTMODE==3) ? 2 : 1;
{
// Blend func can save an operation if it knows uSrc MSB is unset.
// Untextured prims can always skip this (src color MSB is always 0).
- // For textured prims, lighting funcs always return it unset. (bonus!)
- const bool skip_uSrc_mask = (!CF_TEXTMODE) || CF_LIGHT;
+ // For textured prims, the generic lighting funcs always return it unset. (bonus!)
+ const bool skip_uSrc_mask = MSB_PRESERVED ? (!CF_TEXTMODE) : (!CF_TEXTMODE) || CF_LIGHT;
+ bool should_blend;
u32 bMsk; if (CF_BLITMASK) bMsk = gpu_unai.blit_mask;
// UNTEXTURED, NO GOURAUD
const u16 pix15 = gpu_unai.PixelData;
do {
- u16 uSrc, uDst;
+ uint_fast16_t uSrc, uDst;
// NOTE: Don't enable CF_BLITMASK pixel skipping (speed hack)
// on untextured polys. It seems to do more harm than good: see
u32 l_gInc = gpu_unai.gInc;
do {
- u16 uDst, uSrc;
+ uint_fast16_t uDst, uSrc;
// See note in above loop regarding CF_BLITMASK
//if (CF_BLITMASK) { if ((bMsk>>((((uintptr_t)pDst)>>1)&7))&1) goto endpolynotextgou; }
{
// TEXTURED
- u16 uDst, uSrc, srcMSB;
+ uint_fast16_t uDst, uSrc, srcMSB;
//senquack - note: original UNAI code had gpu_unai.{u4/v4} packed into
// one 32-bit unsigned int, but this proved to lose too much accuracy
uSrc = gpuLightingTXT(uSrc, r5, g5, b5);
}
- if (CF_BLEND && srcMSB)
+ should_blend = MSB_PRESERVED ? uSrc & 0x8000 : srcMSB;
+ if (CF_BLEND && should_blend)
uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
}
- if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
- else if (CF_BLEND || CF_LIGHT) { *pDst = uSrc | srcMSB; }
- else { *pDst = uSrc; }
+ if (CF_MASKSET) { *pDst = uSrc | 0x8000; }
+ else if (!MSB_PRESERVED && (CF_BLEND || CF_LIGHT)) { *pDst = uSrc | srcMSB; }
+ else { *pDst = uSrc; }
endpolytext:
pDst++;
l_u = (l_u + l_u_inc) & l_u_msk;
// Where '0' is zero-padding, and '-' is don't care
////////////////////////////////////////////////////////////////////////////////
template <int BLENDMODE, bool SKIP_USRC_MSB_MASK>
-GPU_INLINE u16 gpuBlending(u16 uSrc, u16 uDst)
+GPU_INLINE uint_fast16_t gpuBlendingGeneric(uint_fast16_t uSrc, uint_fast16_t uDst)
{
// These use Blargg's bitwise modulo-clamping:
// http://blargg.8bitalley.com/info/rgb_mixing.html
// http://blargg.8bitalley.com/info/rgb_clamped_add.html
// http://blargg.8bitalley.com/info/rgb_clamped_sub.html
- u16 mix;
+ uint_fast16_t mix;
// 0.5 x Back + 0.5 x Forward
if (BLENDMODE==0) {
// ^ bit 31
// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
////////////////////////////////////////////////////////////////////////////////
-GPU_INLINE u32 gpuGetRGB24(u16 uSrc)
+GPU_INLINE u32 gpuGetRGB24(uint_fast16_t uSrc)
{
return ((uSrc & 0x7C00)<<14)
| ((uSrc & 0x03E0)<< 9)
// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
////////////////////////////////////////////////////////////////////////////////
template <int BLENDMODE>
-GPU_INLINE u32 gpuBlending24(u32 uSrc24, u16 uDst)
+GPU_INLINE u32 gpuBlending24(u32 uSrc24, uint_fast16_t uDst)
{
// These use techniques adapted from Blargg's techniques mentioned in
// in gpuBlending() comments above. Not as much bitwise trickery is
--- /dev/null
+#ifndef _OP_BLEND_ARM_H_
+#define _OP_BLEND_ARM_H_
+
+////////////////////////////////////////////////////////////////////////////////
+// Blend bgr555 color in 'uSrc' (foreground) with bgr555 color
+// in 'uDst' (background), returning resulting color.
+//
+// INPUT:
+// 'uSrc','uDst' input: -bbbbbgggggrrrrr
+// ^ bit 16
+// OUTPUT:
+// u16 output: 0bbbbbgggggrrrrr
+// ^ bit 16
+// RETURNS:
+// Where '0' is zero-padding, and '-' is don't care
+////////////////////////////////////////////////////////////////////////////////
+template <int BLENDMODE, bool SKIP_USRC_MSB_MASK>
+GPU_INLINE uint_fast16_t gpuBlendingARM(uint_fast16_t uSrc, uint_fast16_t uDst)
+{
+ // These use Blargg's bitwise modulo-clamping:
+ // http://blargg.8bitalley.com/info/rgb_mixing.html
+ // http://blargg.8bitalley.com/info/rgb_clamped_add.html
+ // http://blargg.8bitalley.com/info/rgb_clamped_sub.html
+
+ uint_fast16_t mix;
+
+ // Clear preserved msb
+ asm ("bic %[uDst], %[uDst], #0x8000" : [uDst] "+r" (uDst));
+
+ if (BLENDMODE == 3) {
+ // Prepare uSrc for blending ((0.25 * uSrc) & (0.25 * mask))
+ asm ("and %[uSrc], %[mask], %[uSrc], lsr #0x2" : [uSrc] "+r" (uSrc) : [mask] "r" (0x1ce7));
+ } else if (!SKIP_USRC_MSB_MASK) {
+ asm ("bic %[uSrc], %[uSrc], #0x8000" : [uSrc] "+r" (uSrc));
+ }
+
+
+ // 0.5 x Back + 0.5 x Forward
+ if (BLENDMODE==0) {
+ // mix = ((uSrc + uDst) - ((uSrc ^ uDst) & 0x0421)) >> 1;
+ asm ("eor %[mix], %[uSrc], %[uDst]\n\t" // uSrc ^ uDst
+ "and %[mix], %[mix], %[mask]\n\t" // ... & 0x0421
+ "sub %[mix], %[uDst], %[mix]\n\t" // uDst - ...
+ "add %[mix], %[uSrc], %[mix]\n\t" // uSrc + ...
+ "mov %[mix], %[mix], lsr #0x1\n\t" // ... >> 1
+ : [mix] "=&r" (mix)
+ : [uSrc] "r" (uSrc), [uDst] "r" (uDst), [mask] "r" (0x0421));
+ }
+
+ if (BLENDMODE == 1 || BLENDMODE == 3) {
+ // u32 sum = uSrc + uDst;
+ // u32 low_bits = (uSrc ^ uDst) & 0x0421;
+ // u32 carries = (sum - low_bits) & 0x8420;
+ // u32 modulo = sum - carries;
+ // u32 clamp = carries - (carries >> 5);
+ // mix = modulo | clamp;
+
+ u32 sum;
+
+ asm ("add %[sum], %[uSrc], %[uDst]\n\t" // sum = uSrc + uDst
+ "eor %[mix], %[uSrc], %[uDst]\n\t" // uSrc ^ uDst
+ "and %[mix], %[mix], %[mask]\n\t" // low_bits = (... & 0x0421)
+ "sub %[mix], %[sum], %[mix]\n\t" // sum - low_bits
+ "and %[mix], %[mix], %[mask], lsl #0x05\n\t" // carries = ... & 0x8420
+ "sub %[sum], %[sum], %[mix] \n\t" // modulo = sum - carries
+ "sub %[mix], %[mix], %[mix], lsr #0x05\n\t" // clamp = carries - (carries >> 5)
+ "orr %[mix], %[sum], %[mix]" // mix = modulo | clamp
+ : [sum] "=&r" (sum), [mix] "=&r" (mix)
+ : [uSrc] "r" (uSrc), [uDst] "r" (uDst), [mask] "r" (0x0421));
+ }
+
+ // 1.0 x Back - 1.0 x Forward
+ if (BLENDMODE==2) {
+ u32 diff;
+ // u32 diff = uDst - uSrc + 0x8420;
+ // u32 low_bits = (uDst ^ uSrc) & 0x8420;
+ // u32 borrows = (diff - low_bits) & 0x8420;
+ // u32 modulo = diff - borrows;
+ // u32 clamp = borrows - (borrows >> 5);
+ // mix = modulo & clamp;
+ asm ("sub %[diff], %[uDst], %[uSrc]\n\t" // uDst - uSrc
+ "add %[diff], %[diff], %[mask]\n\t" // diff = ... + 0x8420
+ "eor %[mix], %[uDst], %[uSrc]\n\t" // uDst ^ uSrc
+ "and %[mix], %[mix], %[mask]\n\t" // low_bits = ... & 0x8420
+ "sub %[mix], %[diff], %[mix]\n\t" // diff - low_bits
+ "and %[mix], %[mix], %[mask]\n\t" // borrows = ... & 0x8420
+ "sub %[diff], %[diff], %[mix]\n\t" // modulo = diff - borrows
+ "sub %[mix], %[mix], %[mix], lsr #0x05\n\t" // clamp = borrows - (borrows >> 5)
+ "and %[mix], %[diff], %[mix]" // mix = modulo & clamp
+ : [diff] "=&r" (diff), [mix] "=&r" (mix)
+ : [uSrc] "r" (uSrc), [uDst] "r" (uDst), [mask] "r" (0x8420));
+ }
+
+ // There's not a case where we can get into this function,
+ // SKIP_USRC_MSB_MASK is false, and the msb of uSrc is unset.
+ if (!SKIP_USRC_MSB_MASK) {
+ asm ("orr %[mix], %[mix], #0x8000" : [mix] "+r" (mix));
+ }
+
+ return mix;
+}
+
+#endif //_OP_BLEND_ARM_H_
// ^ bit 16
// Where 'r,g,b' are integer bits of colors, 'X' fixed-pt, and '0' zero
////////////////////////////////////////////////////////////////////////////////
-GPU_INLINE u16 gpuLightingRGB(u32 gCol)
+GPU_INLINE uint_fast16_t gpuLightingRGBGeneric(u32 gCol)
{
return ((gCol<< 5)&0x7C00) |
((gCol>>11)&0x03E0) |
// u16 output: 0bbbbbgggggrrrrr
// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
////////////////////////////////////////////////////////////////////////////////
-GPU_INLINE u16 gpuLightingTXT(u16 uSrc, u8 r5, u8 g5, u8 b5)
+GPU_INLINE uint_fast16_t gpuLightingTXTGeneric(uint_fast16_t uSrc, u8 r5, u8 g5, u8 b5)
{
return (gpu_unai.LightLUT[((uSrc&0x7C00)>>5) | b5] << 10) |
(gpu_unai.LightLUT[ (uSrc&0x03E0) | g5] << 5) |
// u16 output: 0bbbbbgggggrrrrr
// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
////////////////////////////////////////////////////////////////////////////////
-GPU_INLINE u16 gpuLightingTXTGouraud(u16 uSrc, u32 gCol)
+GPU_INLINE uint_fast16_t gpuLightingTXTGouraudGeneric(uint_fast16_t uSrc, u32 gCol)
{
return (gpu_unai.LightLUT[((uSrc&0x7C00)>>5) | ((gCol>> 5)&0x1F)]<<10) |
(gpu_unai.LightLUT[ (uSrc&0x03E0) | ((gCol>>16)&0x1F)]<< 5) |
// ^ bit 31
// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
////////////////////////////////////////////////////////////////////////////////
-GPU_INLINE u32 gpuLightingTXT24(u16 uSrc, u8 r8, u8 g8, u8 b8)
+GPU_INLINE u32 gpuLightingTXT24(uint_fast16_t uSrc, u8 r8, u8 g8, u8 b8)
{
- u16 r1 = uSrc&0x001F;
- u16 g1 = uSrc&0x03E0;
- u16 b1 = uSrc&0x7C00;
+ uint_fast16_t r1 = uSrc&0x001F;
+ uint_fast16_t g1 = uSrc&0x03E0;
+ uint_fast16_t b1 = uSrc&0x7C00;
- u16 r2 = r8;
- u16 g2 = g8;
- u16 b2 = b8;
+ uint_fast16_t r2 = r8;
+ uint_fast16_t g2 = g8;
+ uint_fast16_t b2 = b8;
u32 r3 = r1 * r2; if (r3 & 0xFFFFF000) r3 = ~0xFFFFF000;
u32 g3 = g1 * g2; if (g3 & 0xFFFE0000) g3 = ~0xFFFE0000;
// ^ bit 31
// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
////////////////////////////////////////////////////////////////////////////////
-GPU_INLINE u32 gpuLightingTXT24Gouraud(u16 uSrc, u32 gCol)
+GPU_INLINE u32 gpuLightingTXT24Gouraud(uint_fast16_t uSrc, u32 gCol)
{
- u16 r1 = uSrc&0x001F;
- u16 g1 = uSrc&0x03E0;
- u16 b1 = uSrc&0x7C00;
+ uint_fast16_t r1 = uSrc&0x001F;
+ uint_fast16_t g1 = uSrc&0x03E0;
+ uint_fast16_t b1 = uSrc&0x7C00;
- u16 r2 = (gCol>>24) & 0xFF;
- u16 g2 = (gCol>>13) & 0xFF;
- u16 b2 = (gCol>> 2) & 0xFF;
+ uint_fast16_t r2 = (gCol>>24) & 0xFF;
+ uint_fast16_t g2 = (gCol>>13) & 0xFF;
+ uint_fast16_t b2 = (gCol>> 2) & 0xFF;
u32 r3 = r1 * r2; if (r3 & 0xFFFFF000) r3 = ~0xFFFFF000;
u32 g3 = g1 * g2; if (g3 & 0xFFFE0000) g3 = ~0xFFFE0000;
--- /dev/null
+#ifndef _OP_LIGHT_ARM_H_
+#define _OP_LIGHT_ARM_H_
+
+////////////////////////////////////////////////////////////////////////////////
+// Extract bgr555 color from Gouraud u32 fixed-pt 8.3:8.3:8.2 rgb triplet
+//
+// INPUT:
+// 'gCol' input: rrrrrrrrXXXggggggggXXXbbbbbbbbXX
+// ^ bit 31
+// RETURNS:
+// u16 output: 0bbbbbgggggrrrrr
+// ^ bit 16
+// Where 'r,g,b' are integer bits of colors, 'X' fixed-pt, and '0' zero
+////////////////////////////////////////////////////////////////////////////////
+GPU_INLINE uint_fast16_t gpuLightingRGBARM(u32 gCol)
+{
+ uint_fast16_t out = 0x03E0; // don't need the mask after starting to write output
+ u32 tmp;
+
+ asm ("and %[tmp], %[gCol], %[out]\n\t" // tmp holds 0x000000bbbbb00000
+ "and %[out], %[out], %[gCol], lsr #0x0B\n\t" // out holds 0x000000ggggg00000
+ "orr %[tmp], %[out], %[tmp], lsl #0x05\n\t" // tmp holds 0x0bbbbbggggg00000
+ "orr %[out], %[tmp], %[gCol], lsr #0x1B\n\t" // out holds 0x0bbbbbgggggrrrrr
+ : [out] "+&r" (out), [tmp] "=&r" (tmp)
+ : [gCol] "r" (gCol)
+ );
+
+ return out;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Apply fast (low-precision) 5-bit lighting to bgr555 texture color:
+//
+// INPUT:
+// 'r5','g5','b5' are unsigned 5-bit color values, value of 15
+// is midpoint that doesn't modify that component of texture
+// 'uSrc' input: mbbbbbgggggrrrrr
+// ^ bit 16
+// RETURNS:
+// u16 output: mbbbbbgggggrrrrr
+// Where 'X' are fixed-pt bits.
+////////////////////////////////////////////////////////////////////////////////
+GPU_INLINE uint_fast16_t gpuLightingTXTARM(uint_fast16_t uSrc, u8 r5, u8 g5, u8 b5)
+{
+ uint_fast16_t out = 0x03E0;
+ u32 db, dg;
+
+ // Using `g` for src, `G` for dest
+ asm ("and %[dg], %[out], %[src] \n\t" // dg holds 0x000000ggggg00000
+ "orr %[dg], %[dg], %[g5] \n\t" // dg holds 0x000000gggggGGGGG
+ "and %[db], %[out], %[src], lsr #0x05 \n\t" // db holds 0x000000bbbbb00000
+ "ldrb %[dg], [%[lut], %[dg]] \n\t" // dg holds result 0x00000000000ggggg
+ "and %[out], %[out], %[src], lsl #0x05 \n\t" // out holds 0x000000rrrrr00000
+ "orr %[out], %[out], %[r5] \n\t" // out holds 0x000000rrrrrRRRRR
+ "orr %[db], %[db], %[b5] \n\t" // db holds 0x000000bbbbbBBBBB
+ "ldrb %[out], [%[lut], %[out]] \n\t" // out holds result 0x00000000000rrrrr
+ "ldrb %[db], [%[lut], %[db]] \n\t" // db holds result 0x00000000000bbbbb
+ "tst %[src], #0x8000\n\t" // check whether msb was set on uSrc
+ "orr %[out], %[out], %[dg], lsl #0x05 \n\t" // out holds 0x000000gggggrrrrr
+ "orrne %[out], %[out], #0x8000\n\t" // add msb to out if set on uSrc
+ "orr %[out], %[out], %[db], lsl #0x0A \n\t" // out holds 0xmbbbbbgggggrrrrr
+ : [out] "=&r" (out), [db] "=&r" (db), [dg] "=&r" (dg)
+ : [r5] "r" (r5), [g5] "r" (g5), [b5] "r" (b5),
+ [lut] "r" (gpu_unai.LightLUT), [src] "r" (uSrc), "0" (out)
+ : "cc");
+ return out;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Apply fast (low-precision) 5-bit Gouraud lighting to bgr555 texture color:
+//
+// INPUT:
+// 'gCol' is a packed Gouraud u32 fixed-pt 8.3:8.3:8.2 rgb triplet, value of
+// 15.0 is midpoint that does not modify color of texture
+// gCol input : rrrrrXXXXXXgggggXXXXXXbbbbbXXXXX
+// ^ bit 31
+// 'uSrc' input: mbbbbbgggggrrrrr
+// ^ bit 16
+// RETURNS:
+// u16 output: mbbbbbgggggrrrrr
+// Where 'X' are fixed-pt bits, '0' is zero-padding, and '-' is don't care
+////////////////////////////////////////////////////////////////////////////////
+GPU_INLINE uint_fast16_t gpuLightingTXTGouraudARM(uint_fast16_t uSrc, u32 gCol)
+{
+ uint_fast16_t out = 0x03E0; // don't need the mask after starting to write output
+ u32 db,dg,gtmp;
+
+ // Using `g` for src, `G` for dest
+ asm ("and %[dg], %[out], %[src] \n\t" // dg holds 0x000000ggggg00000
+ "and %[gtmp],%[out], %[gCol], lsr #0x0B \n\t" // gtmp holds 0x000000GGGGG00000
+ "and %[db], %[out], %[src], lsr #0x05 \n\t" // db holds 0x000000bbbbb00000
+ "orr %[dg], %[dg], %[gtmp], lsr #0x05 \n\t" // dg holds 0x000000gggggGGGGG
+ "and %[gtmp],%[out], %[gCol] \n\t" // gtmp holds 0x000000BBBBB00000
+ "ldrb %[dg], [%[lut], %[dg]] \n\t" // dg holds result 0x00000000000ggggg
+ "and %[out], %[out], %[src], lsl #0x05 \n\t" // out holds 0x000000rrrrr00000
+ "orr %[out], %[out], %[gCol], lsr #0x1B \n\t" // out holds 0x000000rrrrrRRRRR
+ "orr %[db], %[db], %[gtmp], lsr #0x05 \n\t" // db holds 0x000000bbbbbBBBBB
+ "ldrb %[out], [%[lut], %[out]] \n\t" // out holds result 0x00000000000rrrrr
+ "ldrb %[db], [%[lut], %[db]] \n\t" // db holds result 0x00000000000bbbbb
+ "tst %[src], #0x8000\n\t" // check whether msb was set on uSrc
+ "orr %[out], %[out], %[dg], lsl #0x05 \n\t" // out holds 0x000000gggggrrrrr
+ "orrne %[out], %[out], #0x8000\n\t" // add msb to out if set on uSrc
+ "orr %[out], %[out], %[db], lsl #0x0A \n\t" // out holds 0xmbbbbbgggggrrrrr
+ : [out] "=&r" (out), [db] "=&r" (db), [dg] "=&r" (dg),
+ [gtmp] "=&r" (gtmp) \
+ : [gCol] "r" (gCol), [lut] "r" (gpu_unai.LightLUT), "0" (out), [src] "r" (uSrc)
+ : "cc");
+
+ return out;
+}
+
+#endif //_OP_LIGHT_ARM_H_
notaz.gp2x.de / pcsx_rearmed.git / commitdiff