Clean up indentation / add comments for assembly functions

diff --git a/plugins/gpu_unai/gpu_inner.h b/plugins/gpu_unai/gpu_inner.h
index 8314790..76479f9 100644 (file)
--- a/plugins/gpu_unai/gpu_inner.h
+++ b/plugins/gpu_unai/gpu_inner.h
@@ -357,10 +357,10 @@ static void gpuSpriteSpanFn(u16 *pDst, u32 count, u8* pTxt, u32 u0)
        // 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, the generic lighting funcs always return it unset. (bonus!)
-  const bool skip_uSrc_mask = MSB_PRESERVED ? (!CF_TEXTMODE) : (!CF_TEXTMODE) || CF_LIGHT;
+       const bool skip_uSrc_mask = MSB_PRESERVED ? (!CF_TEXTMODE) : (!CF_TEXTMODE) || CF_LIGHT;
 
        uint_fast16_t uSrc, uDst, srcMSB;
-  bool should_blend;
+       bool should_blend;
        u32 u0_mask = gpu_unai.TextureWindow[2];
 
        u8 r5, g5, b5;
@@ -402,7 +402,7 @@ static void gpuSpriteSpanFn(u16 *pDst, u32 count, u8* pTxt, u32 u0)
                if (CF_LIGHT)
                        uSrc = gpuLightingTXT(uSrc, r5, g5, b5);
 
-    should_blend = MSB_PRESERVED ? uSrc & 0x8000 : srcMSB;
+               should_blend = MSB_PRESERVED ? uSrc & 0x8000 : srcMSB;
 
                if (CF_BLEND && should_blend)
                        uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
@@ -487,8 +487,8 @@ static void gpuPolySpanFn(const gpu_unai_t &gpu_unai, u16 *pDst, u32 count)
        // 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, 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;
+       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;
 
@@ -653,7 +653,7 @@ endpolynotextgou:
                                                uSrc = gpuLightingTXT(uSrc, r5, g5, b5);
                                }
 
-        should_blend = MSB_PRESERVED ? uSrc & 0x8000 : srcMSB;
+                               should_blend = MSB_PRESERVED ? uSrc & 0x8000 : srcMSB;
                                if (CF_BLEND && should_blend)
                                        uSrc = gpuBlending<CF_BLENDMODE, skip_uSrc_mask>(uSrc, uDst);
                        }

diff --git a/plugins/gpu_unai/gpu_inner_blend_arm.h b/plugins/gpu_unai/gpu_inner_blend_arm.h
index 5ddbdbb..6413527 100644 (file)
--- a/plugins/gpu_unai/gpu_inner_blend_arm.h
+++ b/plugins/gpu_unai/gpu_inner_blend_arm.h
@@ -22,79 +22,80 @@ GPU_INLINE uint_fast16_t gpuBlendingARM(uint_fast16_t uSrc, uint_fast16_t uDst)
        //  http://blargg.8bitalley.com/info/rgb_clamped_add.html
        //  http://blargg.8bitalley.com/info/rgb_clamped_sub.html
 
-  
        uint_fast16_t mix;
 
-  asm ("bic %[uDst], %[uDst], #0x8000" : [uDst] "+r" (uDst));
+       // 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));
+       }
 
-  if (BLENDMODE == 3) {
-    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"
-         "and %[mix], %[mix], %[mask]\n\t"
-         "sub %[mix], %[uDst], %[mix]\n\t"
-         "add %[mix], %[uSrc], %[mix]\n\t"
-         "mov %[mix], %[mix], lsr #0x1\n\t"
-         : [mix] "=&r" (mix)
-         : [uSrc] "r" (uSrc), [uDst] "r" (uDst), [mask] "r" (0x0421));
-  }
+               // 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;
+       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;
+               u32 sum;
 
-    asm ("add %[sum], %[uSrc], %[uDst]\n\t"
-         "eor %[mix], %[uSrc], %[uDst]\n\t"
-         "and %[mix], %[mix], %[mask]\n\t"
-         "sub %[mix], %[sum], %[mix]\n\t"
-         "and %[mix], %[mix], %[mask], lsl #0x05\n\t"
-         "sub %[sum], %[sum], %[mix] \n\t"
-         "sub %[mix], %[mix], %[mix], lsr #0x05\n\t"
-         "orr %[mix], %[sum], %[mix]"
-         : [sum] "=&r" (sum), [mix] "=&r" (mix)
-         : [uSrc] "r" (uSrc), [uDst] "r" (uDst), [mask] "r" (0x0421));
-  }
+               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 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"
-         "add %[diff], %[diff], %[mask]\n\t"
-         "eor %[mix], %[uDst], %[uSrc]\n\t"
-         "and %[mix], %[mix], %[mask]\n\t"
-         "sub %[mix], %[diff], %[mix]\n\t"
-         "and %[mix], %[mix], %[mask]\n\t"
-         "sub %[diff], %[diff], %[mix]\n\t"
-         "sub %[mix], %[mix], %[mix], lsr #0x05\n\t"
-         "and %[mix], %[diff], %[mix]"
-         : [diff] "=&r" (diff), [mix] "=&r" (mix)
-         : [uSrc] "r" (uSrc), [uDst] "r" (uDst), [mask] "r" (0x8420));
+               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));
-  }
+       // 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;
 }

diff --git a/plugins/gpu_unai/gpu_inner_light_arm.h b/plugins/gpu_unai/gpu_inner_light_arm.h
index a1c3628..7bd5890 100644 (file)
--- a/plugins/gpu_unai/gpu_inner_light_arm.h
+++ b/plugins/gpu_unai/gpu_inner_light_arm.h
@@ -14,70 +14,99 @@
 ////////////////////////////////////////////////////////////////////////////////
 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;
+       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)
-  );
+       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;
+       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;
-  asm ("and    %[dg],  %[out],  %[src]  \n\t"
-       "orr    %[dg],  %[dg],   %[g5]   \n\t"
-       "and    %[db],  %[out],  %[src], lsr #0x05 \n\t"
-       "ldrb   %[dg],  [%[lut], %[dg]]  \n\t" 
-       "and    %[out], %[out],  %[src], lsl #0x05 \n\t"
-       "orr    %[out], %[out],  %[r5]   \n\t"
-       "orr    %[db],  %[db],   %[b5]   \n\t"
-       "ldrb   %[out], [%[lut], %[out]] \n\t"
-       "ldrb   %[db],  [%[lut], %[db]]  \n\t"
-       "tst    %[src], #0x8000\n\t"
-       "orr    %[out], %[out],  %[dg],  lsl #0x05   \n\t"
-       "orrne  %[out], %[out],  #0x8000\n\t"
-       "orr    %[out], %[out],  %[db],  lsl #0x0A   \n\t"
-    : [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;
+       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;
-  asm ("and    %[dg],  %[out],  %[src]   \n\t"
-       "and    %[gtmp],%[out],  %[gCol], lsr #0x0B \n\t"
-       "and    %[db],  %[out],  %[src],  lsr #0x05 \n\t"
-       "orr    %[dg],  %[dg],   %[gtmp], lsr #0x05 \n\t"
-       "and    %[gtmp],%[out],  %[gCol]  \n\t"
-       "ldrb   %[dg],  [%[lut], %[dg]]   \n\t"
-       "and    %[out], %[out],  %[src],  lsl #0x05 \n\t"
-       "orr    %[out], %[out],  %[gCol], lsr #0x1B \n\t"
-       "orr    %[db],  %[db],   %[gtmp], lsr #0x05 \n\t"
-       "ldrb   %[out], [%[lut], %[out]]  \n\t"
-       "ldrb   %[db],  [%[lut], %[db]]   \n\t"
-       "tst    %[src], #0x8000\n\t"
-       "orr    %[out], %[out],  %[dg],   lsl #0x05 \n\t"
-       "orrne  %[out], %[out],  #0x8000\n\t"
-       "orr    %[out], %[out],  %[db],   lsl #0x0A \n\t"
-       : [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");
+       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;
+       return out;
 }
 
 #endif  //_OP_LIGHT_ARM_H_