changed to fixed point math to always generate bars of 32 lines height

examples/cx16/colorbars.p8

@@ -14,10 +14,11 @@ main {
 
         ubyte yy
         for yy in 0 to 239
-            gfx2.horizontal_line(0, yy, 320, yy & 63)
+            gfx2.horizontal_line(0, yy, 320, yy & 31)
 
         repeat {
-            colors.random_bar()
+            colors.random_half_bar()
+            colors.mirror_bar()
             colors.set_palette()
             repeat 20
                 sys.waitvsync()
@@ -30,96 +31,85 @@ main {
 }
 
 colors {
-    ubyte cr
+    ubyte target_red
-    ubyte cg
+    ubyte target_green
-    ubyte cb
+    ubyte target_blue
-    ubyte[48+16] reds
+    ubyte[32] reds
-    ubyte[48+16] greens
+    ubyte[32] greens
-    ubyte[48+16] blues
+    ubyte[32] blues
     ubyte bar_size
 
     sub random_rgb12() {
         do {
             uword rr = rndw()
-            cr = msb(rr) & 15
+            target_red = msb(rr) & 15
-            cg = lsb(rr)
+            target_green = lsb(rr)
-            cb = cg & 15
+            target_blue = target_green & 15
-            cg >>= 4
+            target_green >>= 4
-        } until cr+cg+cb >= 12
+        } until target_red+target_green+target_blue >= 12
     }
 
-    sub random_bar() {
+    sub mirror_bar() {
-        ; fade black -> color then fade color -> white
+        ; mirror the top half bar into the bottom half
-        random_rgb12()
+        ubyte ix=14
-        ubyte r=0
+        ubyte mix=16
-        ubyte g=0
+        do {
-        ubyte b=0
+            reds[mix] = reds[ix]
-        ubyte different
+            greens[mix] = greens[ix]
-        bar_size = 0
+            blues[mix] = blues[ix]
+            mix++
+            ix--
+        } until ix==255
+        reds[mix] = 0
+        greens[mix] = 0
+        blues[mix] = 0
+    }
 
-        repeat {
+    sub random_half_bar() {
-            different = false
+        ; fade black -> color then fade color -> white
-            if r != cr {
+        ; gradient calculations in 8.8 bits fixed-point
-                different = true
+        ; could theoretically be 4.12 bits for even more fractional accuracy
-                r++
+        random_rgb12()
+        uword r = $000
+        uword g = $000
+        uword b = $000
+        uword dr = target_red
+        uword dg = target_green
+        uword db = target_blue
+        ubyte ix = 1
+
+        ; gradient from black to halfway color
+        reds[0] = 0
+        greens[0] = 0
+        blues[0] = 0
+        dr <<= 5
+        dg <<= 5
+        db <<= 5
+        continue_gradient()
+
+        ; gradient from halfway color to white
+        dr = (($f00 - r) >> 3) - 1
+        dg = (($f00 - g) >> 3) - 1
+        db = (($f00 - b) >> 3) - 1
+        continue_gradient()
+        return
+
+        sub continue_gradient() {
+            repeat 8 {
+                reds[ix] = msb(r)
+                greens[ix] = msb(g)
+                blues[ix] = msb(b)
+                r += dr
+                g += dg
+                b += db
+                ix++
             }
-            if g != cg {
-                different = true
-                g++
-            }
-            if b != cb {
-                different = true
-                b++
-            }
-            if not different
-                break
-            reds[bar_size] = r
-            greens[bar_size] = g
-            blues[bar_size] = b
-            bar_size++
-        }
-        repeat {
-            different = false
-            if r != 15 {
-                different = true
-                r++
-            }
-            if g != 15 {
-                different = true
-                g++
-            }
-            if b != 15 {
-                different = true
-                b++
-            }
-            if not different
-                break
-            reds[bar_size] = r
-            greens[bar_size] = g
-            blues[bar_size] = b
-            bar_size++
-        }
-        ; mirror bottom half from top half
-        ubyte mi = bar_size-1
-        repeat mi {
-            reds[bar_size] = reds[mi]
-            greens[bar_size] = greens[mi]
-            blues[bar_size] = blues[mi]
-            bar_size++
-            mi--
-        }
-        ; make rest of bar black (bars are not always the same length using the simplistic algorithm above...)
-        while bar_size != 48+16 {
-            reds[bar_size] = $0
-            greens[bar_size] = $0
-            blues[bar_size] = $0
-            bar_size++
         }
     }
 
     sub set_palette() {
         ubyte ix
-        for ix in 0 to 48+15 {
+        for ix in 0 to 31 {
             uword color = mkword(reds[ix], (greens[ix] << 4) | blues[ix] )
             palette.set_color(ix, color)
         }