picogame: cheaper text, triangle setup, particles and bounds tests

- canvas_text copies the atlas fields to locals, so they are not
  reloaded for every pixel.
- fill_triangle does the int64 seed multiplies only when the triangle
  is clipped at the top. edge_slope is not inlined, so 6 divide call
  sites become 2.
- Particles are rejected on Y first. The colour scale uses one divide
  instead of three (at most 1 LSB darker).
- put() and the affine sampler use unsigned bounds checks.

RP2040: 32 triangles 3367 -> 3075 us, text 294 -> 282 us.
Output is unchanged.

Co-authored-by: Petr Vavrin <pvavrin@gmail.com>

Author: lynt-smitka

shared-module/picogame/Canvas.c

@@ -52,7 +52,8 @@ static void mark(picogame_canvas_obj_t *cv, int lx1, int ly1, int lx2, int ly2)
 // 8 calls/iteration). Inlining bloated them (circle was ~1.4 KB); a real call keeps
 // them small. Shapes aren't the hot path (the sprite/tilemap blits don't use put).
 static __attribute__((noinline)) void put(picogame_canvas_obj_t *cv, int x, int y, uint16_t c) {
-    if (x >= 0 && y >= 0 && x < cv->w && y < cv->h) {
+    // Unsigned compares also reject negative coordinates.
+    if ((unsigned)x < (unsigned)cv->w && (unsigned)y < (unsigned)cv->h) {
         cv->data[y * cv->w + x] = c;
     }
 }
@@ -306,7 +307,8 @@ void picogame_canvas_line(picogame_canvas_obj_t *cv, int x0, int y0, int x1, int
 
 // Clamp a row span to the surface and word-fill it (the span-pass idiom shared by the filled
 // shapes; the per-pixel put() loops it replaced clipped and indexed every pixel).
-static inline int64_t edge_slope(int32_t dx, int32_t dy) {
+// Not inlined: each inlined copy carried both divides.
+static __attribute__((noinline)) int64_t edge_slope(int32_t dx, int32_t dy) {
     if (dx >= -32768 && dx <= 32767) {
         return (int32_t)(dx << 16) / dy;
     }
@@ -420,8 +422,15 @@ void picogame_canvas_fill_triangle(picogame_canvas_obj_t *cv,
         // top half: rows [Y0, Y1) walk edges A->C and A->B
         int ys = Y[0] < 0 ? 0 : Y[0];
         int ye = (Y[1] - 1) < (h - 1) ? (Y[1] - 1) : (h - 1);
-        int64_t accAC = ((int64_t)X[0] << 16) + sAC * (ys - Y[0]);
-        int64_t acc2 = ((int64_t)X[0] << 16) + sAB * (ys - Y[0]);
+        // skip is 0 unless the triangle is clipped at the top, so the int64 multiplies
+        // usually do not run.
+        int skip = ys - Y[0];
+        int64_t accAC = (int64_t)X[0] << 16;
+        int64_t acc2 = accAC;
+        if (skip) {
+            accAC += sAC * skip;
+            acc2 += sAB * skip;
+        }
         for (int y = ys; y <= ye; y++) {
             int xac = (int)(accAC >> 16);
             int xsh = (int)(acc2 >> 16);
@@ -441,8 +450,12 @@ void picogame_canvas_fill_triangle(picogame_canvas_obj_t *cv,
         // bottom half: rows [Y1, Y2] walk edges A->C and B->C (a flat bottom degenerates to sBC=0)
         ys = Y[1] < 0 ? 0 : Y[1];
         ye = Y[2] < (h - 1) ? Y[2] : (h - 1);
-        accAC = ((int64_t)X[0] << 16) + sAC * (ys - Y[0]);
-        acc2 = ((int64_t)X[1] << 16) + sBC * (ys - Y[1]);
+        accAC = ((int64_t)X[0] << 16) + sAC * (ys - Y[0]);   // spans the whole top half: rarely 0
+        acc2 = (int64_t)X[1] << 16;
+        skip = ys - Y[1];
+        if (skip) {
+            acc2 += sBC * skip;
+        }
         for (int y = ys; y <= ye; y++) {
             int xac = (int)(accAC >> 16);
             int xsh = (int)(acc2 >> 16);
@@ -581,6 +594,11 @@ void picogame_canvas_text(picogame_canvas_obj_t *cv, int x, int y, const char *t
     bool onebit = (sheet->bits_per_value == 1);   // terminalio.FONT is 1-bpp; other fonts take the fallback
     const uint8_t *sdata = (const uint8_t *)sheet->data;
     int sstride_b = sheet->stride * 4;            // atlas row stride in BYTES (stride counts uint32)
+    // Copy to locals: the uint16_t store may alias sheet->bitmask, so the fields
+    // would be reloaded for every pixel.
+    int sx_shift = sheet->x_shift;
+    size_t sx_mask = sheet->x_mask;
+    uint16_t sbitmask = sheet->bitmask;
     for (const uint8_t *p = (const uint8_t *)text; *p; p++) {
         uint8_t gi = fontio_builtinfont_get_glyph_index(f, *p);
         if (gi != 0xff) {                   // 0xff = no glyph -> blank advance
@@ -596,7 +614,7 @@ void picogame_canvas_text(picogame_canvas_obj_t *cv, int x, int y, const char *t
                     const uint8_t *srow = sdata + (size_t)sy * sstride_b;
                     for (int gx = gx0; gx < gx1; gx++) {
                         int sx = tx + gx;
-                        if ((srow[sx >> sheet->x_shift] >> (sheet->x_mask - (sx & sheet->x_mask))) & sheet->bitmask) {
+                        if ((srow[sx >> sx_shift] >> (sx_mask - ((size_t)sx & sx_mask))) & sbitmask) {
                             drow[gx] = fg;
                         } else if (has_bg) {
                             drow[gx] = bg;

shared-module/picogame/Particles.c

@@ -34,9 +34,11 @@ static void swap_remove(picogame_particles_obj_t *ps, int i) {
 // Dim a wire-order RGB565 color to num/den of its brightness (per channel).
 static inline uint16_t scale_wire565(uint16_t wire, int num, int den) {
     uint16_t c = (uint16_t)((wire >> 8) | (wire << 8));   // wire -> native
-    int r = ((c >> 11) & 0x1F) * num / den;
-    int g = ((c >> 5) & 0x3F) * num / den;
-    int b = (c & 0x1F) * num / den;
+    // One Q8 reciprocal for all three channels (0 <= q <= 256). At most 1 LSB darker.
+    int q = (num << 8) / den;
+    int r = (((c >> 11) & 0x1F) * q) >> 8;
+    int g = (((c >> 5) & 0x3F) * q) >> 8;
+    int b = ((c & 0x1F) * q) >> 8;
     uint16_t out = (uint16_t)((r << 11) | (g << 5) | b);
     return (uint16_t)((out >> 8) | (out << 8));           // native -> wire
 }
@@ -139,9 +141,18 @@ void picogame_blit_particles(
     int sz = ps->size;
     int rx2 = x0 + region_w;
     int ry2 = strip_top + strip_h;
-    for (int i = 0; i < ps->count; i++) {
-        int sx = (ps->px[i] >> 8) + ox;
-        int sy = (ps->py[i] >> 8) + oy;
+    // Reject on Y first: a strip spans the full width, so X rarely rejects.
+    const int32_t *pxs = ps->px, *pys = ps->py;
+    int ylo = strip_top - sz - oy;             // py >> 8 <= ylo -> entirely above
+    int yhi = ry2 - oy;                        // py >> 8 >= yhi -> entirely below
+    int count = ps->count;
+    for (int i = 0; i < count; i++) {
+        int sy8 = pys[i] >> 8;
+        if (sy8 <= ylo || sy8 >= yhi) {
+            continue;
+        }
+        int sx = (pxs[i] >> 8) + ox;
+        int sy = sy8 + oy;
         int xs = picogame_imax(sx, x0);
         int ys = picogame_imax(sy, strip_top);
         int xe = picogame_imin(sx + sz, rx2);