펜이 닿은 자리에 첫 댑

    /// A dab where the pen lands, as Photoshop and Procreate lay one: libmypaint
    /// lays its first only after a spacing's travel, so a tap, or a short
    /// stroke of a stamp spaced wide, laid nothing. Its first input only sets
    /// where the brush is; one 240th of a second more at a dab per 240th lays
    /// exactly one there, and the brush's own rate comes back.
    private static func layFirstDab(_ brush: Brush, at sample: StrokeSample, on surface: BrushSurface) {
        let rate = BrushAttribute.setting("dabs_per_second")
        let own = brush.baseValue(rate)
        var again = sample
        again.deltaTime = 1.0 / 240
        brush.setBaseValue(rate, 240 * 1.001)
        brush.stroke(to: again, on: surface)
        brush.setBaseValue(rate, own)
    }

        for raw in inputs {
            var input = raw
            if !current.replaying {
                input = assisted(raw, stroke: &current, viewZoom: viewZoom)
                if current.smoothing != nil {
                    input = current.smoothing!.filter(input)
                }
            }
            var sample = mapping.sample(for: input, previousTimestamp: current.lastTimestamp,
                                        viewZoom: viewZoom, viewRotationDegrees: viewRotationDegrees)
            if current.taper != nil {
                let distance = current.taper!.advance(to: SIMD2(input.x, input.y))
                brush.setBaseValue(.radiusLogarithmic, current.taper!.radius(at: distance))
                sample.pressure *= current.taper!.pressure(at: distance)
            }
            surface.setAzimuth(input.azimuth)
            brush.stroke(to: sample, on: surface)
            if current.samples == 0 { Self.layFirstDab(brush, at: sample, on: surface) }
            if let dual = current.dual {
                dual.brush.setBaseValue(.radiusLogarithmic, brush.baseValue(.radiusLogarithmic) + dual.radiusOffset)
                dual.brush.stroke(to: sample, on: dual.secondarySurface)
                if current.samples == 0 { Self.layFirstDab(dual.brush, at: sample, on: dual.secondarySurface) }
            }
            current.lastTimestamp = input.timestamp
            current.samples += 1
            if !current.replaying {
                current.inputs.append(raw)
                current.fed.append(input)
            }
        }
        surface.end()

// Count the dabs libmypaint lays for a still tap, without Ariandel's layFirstDab
// move and then with it, sweeping how long after the landing the next input comes.
// Build against libmypaint master (the 2.0 API, as Ariandel vendors it).
#include <stdio.h>
#include "mypaint-brush.h"
#include "mypaint-surface.h"

static int dabs;
static int count_dab(MyPaintSurface *s, float x, float y, float radius,
                     float r, float g, float b, float opaque, float hardness,
                     float softness, float eraser, float ratio, float angle,
                     float lock_alpha, float colorize, float posterize,
                     float posterize_num, float paint) {
    dabs++;
    return 1;
}
static void no_color(MyPaintSurface *s, float x, float y, float radius,
                     float *r, float *g, float *b, float *a, float paint) {
    *r = *g = *b = *a = 0;
}

static MyPaintSurface surface;
static MyPaintBrush *brush;
static float own;

// One tap at a single point: the landing, the move (if asked), the next input
// `next` seconds later, then fifty more samples 1/240 s apart. Prints the dab counts.
static void tap(int lay_first_dab, double next) {
    mypaint_brush_reset(brush);
    mypaint_brush_new_stroke(brush);
    dabs = 0;
    // The first input of a stroke, reported 10 s after "the last one".
    mypaint_brush_stroke_to(brush, &surface, 100, 100, 0.8f, 0, 0, 10.0, 1, 0, 0, 0);
    int after_landing = dabs;
    if (lay_first_dab) {
        mypaint_brush_set_base_value(brush, MYPAINT_BRUSH_SETTING_DABS_PER_SECOND, 240 * 1.001f);
        mypaint_brush_stroke_to(brush, &surface, 100, 100, 0.8f, 0, 0, 1.0 / 240, 1, 0, 0, 0);
        mypaint_brush_set_base_value(brush, MYPAINT_BRUSH_SETTING_DABS_PER_SECOND, own);
    }
    int after_move = dabs;
    mypaint_brush_stroke_to(brush, &surface, 100, 100, 0.8f, 0, 0, next, 1, 0, 0, 0);
    int at_next = dabs - after_move;
    for (int i = 0; i < 50; i++)
        mypaint_brush_stroke_to(brush, &surface, 100, 100, 0.8f, 0, 0, 1.0 / 240, 1, 0, 0, 0);
    printf("%-11s next input %-10.6g s later | landing %d, move %d, next input %d, total %d\n",
           lay_first_dab ? "layFirstDab" : "plain", next,
           after_landing, after_move - after_landing, at_next, dabs);
}

int main(void) {
    surface.draw_dab = count_dab;
    surface.get_color = no_color;
    surface.refcount = 1;
    brush = mypaint_brush_new();
    mypaint_brush_from_defaults(brush);
    mypaint_brush_set_base_value(brush, MYPAINT_BRUSH_SETTING_RADIUS_LOGARITHMIC, 3.7f);
    own = mypaint_brush_get_base_value(brush, MYPAINT_BRUSH_SETTING_DABS_PER_SECOND);
    printf("the brush's own dabs per second: %g\n", own);

    tap(0, 1.0 / 240);
    double nexts[] = {0.001, 0.004162, 0.004163, 1.0 / 240, 0.08, 1.0, 5.0, 5.001, 6.0};
    for (int k = 0; k < (int)(sizeof nexts / sizeof nexts[0]); k++)
        tap(1, nexts[k]);
    mypaint_brush_unref(brush);
    return 0;
}

// Prints:
// the brush's own dabs per second: 0
// plain       next input 0.00416667 s later | landing 0, move 0, next input 0, total 0
// layFirstDab next input 0.001      s later | landing 0, move 0, next input 0, total 0
// layFirstDab next input 0.004162   s later | landing 0, move 0, next input 0, total 0
// layFirstDab next input 0.004163   s later | landing 0, move 0, next input 1, total 1
// layFirstDab next input 0.00416667 s later | landing 0, move 0, next input 1, total 1
// layFirstDab next input 0.08       s later | landing 0, move 0, next input 1, total 1
// layFirstDab next input 1          s later | landing 0, move 0, next input 1, total 1
// layFirstDab next input 5          s later | landing 0, move 0, next input 1, total 1
// layFirstDab next input 5.001      s later | landing 0, move 0, next input 0, total 0
// layFirstDab next input 6          s later | landing 0, move 0, next input 0, total 0