180도 함정

// correct dab angle for view rotation
STATE(self, ACTUAL_ELLIPTICAL_DAB_ANGLE) = mod_arith(SETTING(self, ELLIPTICAL_DAB_ANGLE) - viewrotation + 180.0, 180.0) - 180.0;

/* Why an angle known modulo 180 cannot orient an asymmetric tip.
   mod_arith is libmypaint's (helpers.c); delivered() is the line in
   mypaint-brush.c that hands draw_dab its dab angle. covered() samples a
   tip the way Ariandel's stamp() does: canvas offset turned into tip space,
   (u, v) in -1...1. The tip is the probe from learning #756: only its
   top-left quarter is white. */
#include <math.h>
#include <stdio.h>

static float
mod_arith(float a, float N)
{
    float ret = a - N * floor (a / N);
    return ret;
}

/* ACTUAL_ELLIPTICAL_DAB_ANGLE, with no view rotation. */
static float
delivered(float setting)
{
    return mod_arith(setting + 180.0f, 180.0f) - 180.0f;
}

/* Does a tip stamped at (cx, cy), radius r, turned by `angle` degrees,
   cover pixel (px, py)? */
static int
covered(float cx, float cy, float r, float angle, int px, int py)
{
    const float t = angle * (float)M_PI / 180.0f, cs = cosf(t), sn = sinf(t);
    const float dx = (float)px + 0.5f - cx, dy = (float)py + 0.5f - cy;
    const float u = (dx * cs + dy * sn) / r, v = (-dx * sn + dy * cs) / r;
    if (u <= -1.0f || u >= 1.0f || v <= -1.0f || v >= 1.0f) {
        return 0;
    }
    return u < 0.0f && v < 0.0f; /* the top-left quarter of the tip */
}

int
main(void)
{
    printf("setting -> delivered\n");
    for (int s = 0; s < 360; s += 45) {
        printf("  %3d -> %6.1f\n", s, delivered((float)s));
    }

    /* Before 963bef1 the tip turned by libmypaint's angle less its rest angle
       (the default setting, 90). After it, by its own angle (0 here). */
    const float rest = 90.0f;
    const float old_turn = delivered(rest) - rest;
    const float new_turn = 0.0f;
    printf("\nprobe: stamp at (100,100), radius 30\n");
    printf("  turned by libmypaint (%.0f):  (80,80) %s  (120,120) %s\n", old_turn,
           covered(100, 100, 30, old_turn, 80, 80) ? "paint" : "none ",
           covered(100, 100, 30, old_turn, 120, 120) ? "paint" : "none ");
    printf("  turned by its own angle (%.0f): (80,80) %s  (120,120) %s\n", new_turn,
           covered(100, 100, 30, new_turn, 80, 80) ? "paint" : "none ",
           covered(100, 100, 30, new_turn, 120, 120) ? "paint" : "none ");
    return 0;
}

/* Output:
setting -> delivered
    0 -> -180.0
   45 -> -135.0
   90 ->  -90.0
  135 ->  -45.0
  180 -> -180.0
  225 -> -135.0
  270 ->  -90.0
  315 ->  -45.0

probe: stamp at (100,100), radius 30
  turned by libmypaint (-180):  (80,80) none   (120,120) paint
  turned by its own angle (0): (80,80) paint  (120,120) none 
*/

/* libmypaint's dab angle is only known modulo half a turn (an ellipse
   looks the same either way up), so a tip turns by its own angle instead. */
(void)angle;
float turn = self->angle + self->follow * (self->heading + 90.0f);
if (self->follow_tilt > 0.0f && self->has_azimuth) {
    turn += self->follow_tilt * (self->azimuth + 90.0f);
}
if (self->scatter > 0.0f) {
    turn += self->scatter * (random_unit(self) * 360.0f - 180.0f);
}
const int fx = self->flip_x && (next_random(self) & 1);
const int fy = self->flip_y && (next_random(self) & 1);