Draw when the picture changes, not when the clock does

The board falling into place composed the whole screen thirty-six times
to show seven pictures. Twenty-nine of those frames were identical to
the one before them, pixel for pixel, and each cost a full pass: the
scene drawn, read back, error-diffused, tinted and written out, every
pixel of it, because diffusion depends on the whole image and always
will. On a laptop that is three milliseconds and invisible. On a phone
it is several times that, the work stops fitting in a frame, the frames
queue, and a 300ms animation crawls along behind its own clock -- which
is exactly what it looked like.

Nothing here moves smoothly, and that is the way out. A slide is
quantised to the dither period so the pattern never lands out of phase.
The board falls in even units. The card's title arrives in five discrete
strengths. The jolt of a refused move is a whole number of units. Every
one of those was already stepped -- but stepped inside the painter, so
the loop could not know that a tick had produced the same picture again
and marked the frame dirty on the mere fact that a clock was running.

So the stepping moves up into the loop, beside the clocks it belongs to,
and the loop compares the stepped values rather than the continuous
ones. Same rounding, same one place doing it, and the painters read the
result instead of each rounding a clock their own way.

Measured, on the play screen: the rise went from 36 composites to 7, an
animated slide from about the same to 6, and an idle screen from 0 to 0.
Under a 6x CPU throttle the rise used to stretch past its own 300ms and
now finishes in it. Input paths are untouched -- they mark the frame
dirty themselves, as they always did; this governs only what a running
clock is entitled to ask for.

commit

e7033102a10a04bccffb8b2eb38d1a2401d9c4fe

parent

d4b2941f042440f011e7da02cf109d47b38c4f68

author

Dami <dami.etoile@gmail.com>