From 8ddc801e21bb02d0de20351f692b48e2e19c94c4 Mon Sep 17 00:00:00 2001
From: tslil clingman <>
Date: Sun, 26 Sep 2021 12:10:44 -0400
Subject: Of course i didn't need i32 ...

---
 src/player.zig | 31 ++++++++++++-------------------
 1 file changed, 12 insertions(+), 19 deletions(-)

diff --git a/src/player.zig b/src/player.zig
index 491fc27..f6b82b1 100644
--- a/src/player.zig
+++ b/src/player.zig
@@ -39,30 +39,23 @@ fn fasterColourBlend(onto: Colour, from: Colour) Colour {
     const af: u16 = from.a;
     const of: u16 = onto.a;
 
-    const na: u16 = af + @divTrunc(of * (255 - af), 255);
+    const ablend: u16 = @divTrunc(of * (255 - af), 255);
+    const na: u16 = af + ablend;
     if (na == 0) return Colour.Black;
 
-    const rf: i32 = from.r;
-    const ro: i32 = onto.r;
-    const gf: i32 = from.g;
-    const go: i32 = onto.g;
-    const bf: i32 = from.b;
-    const bo: i32 = onto.b;
+    const rf: u16 = from.r;
+    const ro: u16 = onto.r;
+    const gf: u16 = from.g;
+    const go: u16 = onto.g;
+    const bf: u16 = from.b;
+    const bo: u16 = onto.b;
 
     // The most accurate i've found is
-    const nr = @divTrunc(ro * na + (rf - ro) * af, na);
-    const ng = @divTrunc(go * na + (gf - go) * af, na);
-    const nb = @divTrunc(bo * na + (bf - bo) * af, na);
+    const nr = @divTrunc(ro * ablend + rf * af, na);
+    const ng = @divTrunc(go * ablend + gf * af, na);
+    const nb = @divTrunc(bo * ablend + bf * af, na);
 
-    // Note: there are other versions which don't require using intermediate
-    // i32 division, and instead work on plain u16.
-
-    // These computations are more expensive and less accurate
-    // const nr = @divTrunc(af * rf, na) + ro - @divTrunc(af * ro, na);
-    // const ng = @divTrunc(af * gf, na) + go - @divTrunc(af * go, na);
-    // const nb = @divTrunc(af * bf, na) + bo - @divTrunc(af * bo, na);
-
-    // These computations are incorrect, but fast
+    // These computations are incorrect, but faster
     // const nr = (af * rf + (255 - af) * ro) / 255;
     // const ng = (af * gf + (255 - af) * go) / 255;
     // const nb = (af * bf + (255 - af) * bo) / 255;
-- 
cgit v1.3.1