압력, 기울기, 롤을 libmypaint 말로 옮기기

    /// libmypaint's pressure for a normalized force.
    public func pressure(for input: StylusInput) -> Float {
        guard let force = input.force else { return Float(fingerPressure) }
        let lifted = min(1, max(0, force - pressureFloor) / max(1e-6, 1 - pressureFloor))
        if let curve = pressureCurve, curve.count >= 2 {
            return Float(min(1, max(0, ToneCurves.value(curve, at: lifted))))
        }
        return Float(min(1, pow(lifted, pressureGamma)))
    }

    // ... smoothing(with:) omitted ...

    /// libmypaint's tilt components. libmypaint reads declination as
    /// 90° − 60°·|tilt|, so an altitude of 90° maps to 0 and 30° or flatter to 1.
    public func tilt(for input: StylusInput) -> (x: Float, y: Float) {
        guard let altitude = input.altitude, let azimuth = input.azimuth else { return (0, 0) }
        let altitudeDegrees = altitude * 180 / .pi
        let magnitude = min(1, max(0, (90 - altitudeDegrees) / 60))
        return (Float(magnitude * cos(azimuth)), Float(magnitude * sin(azimuth)))
    }

    /// Barrel roll in libmypaint's 0...360 degrees.
    public func barrelRotation(for input: StylusInput) -> Float {
        guard let roll = input.roll else { return 0 }
        var degrees = roll * 180 / .pi
        degrees = degrees.truncatingRemainder(dividingBy: 360)
        if degrees < 0 { degrees += 360 }
        return Float(degrees)
    }

    /// Seconds reported for the first event of a stroke. libmypaint smooths
    /// the position (slow tracking) before it checks for a fresh stroke, so a
    /// short first interval starts the stroke near wherever the brush last
    /// was and drags a line from there. Over its five-second threshold the
    /// smoothing collapses onto the real point and the brush starts clean —
    /// what MyPaint gets for free by feeding the hovering pen between strokes.
    public static let strokeStartInterval = 10.0

    /// The sample libmypaint receives for `input`, given the previous event's
    /// time (nil for the first event of a stroke).
    public func sample(for input: StylusInput, previousTimestamp: Double?, viewZoom: Double,
                       viewRotationDegrees: Double) -> StrokeSample {
        let tilt = tilt(for: input)
        let delta = previousTimestamp.map { max(1e-4, input.timestamp - $0) } ?? Self.strokeStartInterval
        return StrokeSample(x: Float(input.x), y: Float(input.y), pressure: pressure(for: input),
                            xTilt: tilt.x, yTilt: tilt.y, deltaTime: delta,
                            viewZoom: Float(viewZoom), viewRotation: Float(viewRotationDegrees),
                            barrelRotation: barrelRotation(for: input))
    }

import Foundation

// A minimal sketch of Ariandel's PencilMapping with its real defaults
// (gamma 0.8, floor 0, finger 0.5), and libmypaint's own reading of the result.
let pressureGamma = 0.8, pressureFloor = 0.0, fingerPressure = 0.5

func pressure(force: Double?) -> Double {
    guard let force else { return fingerPressure }
    let lifted = min(1, max(0, force - pressureFloor) / max(1e-6, 1 - pressureFloor))
    return min(1, pow(lifted, pressureGamma))
}

func tilt(altitude: Double, azimuth: Double) -> (x: Double, y: Double) {
    let degrees = altitude * 180 / .pi
    let magnitude = min(1, max(0, (90 - degrees) / 60))
    return (magnitude * cos(azimuth), magnitude * sin(azimuth))
}

func barrel(roll: Double) -> Double {
    var degrees = (roll * 180 / .pi).truncatingRemainder(dividingBy: 360)
    if degrees < 0 { degrees += 360 }
    return degrees
}

// libmypaint (mypaint_brush_stroke_to): declination = 90 - 60*|tilt|, ascension = atan2(-x, y).
func declination(_ t: (x: Double, y: Double)) -> Double { 90 - hypot(t.x, t.y) * 60 }
func ascension(_ t: (x: Double, y: Double)) -> Double { atan2(-t.x, t.y) * 180 / .pi }

print("force  pressure")
for force in [0.1, 0.25, 0.5, 0.75, 1.0] {
    print(String(format: "%.2f   %.3f", force, pressure(force: force)))
}
print(String(format: "finger %.3f", pressure(force: nil)))

print("\naltitude  libmypaint declination")
for altitude in [90.0, 75, 60, 45, 30, 15] {
    let t = tilt(altitude: altitude * .pi / 180, azimuth: .pi / 2)
    print(String(format: "%5.0f°    %5.1f°", altitude, declination(t)))
}

print("\ncap points      azimuth  libmypaint ascension")
for (name, azimuth) in [("right", 0.0), ("down, at you", .pi / 2), ("left", .pi), ("up, away", -.pi / 2)] {
    let t = tilt(altitude: 45 * .pi / 180, azimuth: azimuth)
    print(name.padding(toLength: 14, withPad: " ", startingAt: 0) + String(format: "  %6.0f°  %6.0f°", azimuth * 180 / .pi, (ascension(t) * 1000).rounded() / 1000 + 0.0))
}

print(String(format: "\nroll -30° -> barrel %.0f°", barrel(roll: -30 * .pi / 180)))

// Prints:
// force  pressure
// 0.10   0.158
// 0.25   0.330
// 0.50   0.574
// 0.75   0.794
// 1.00   1.000
// finger 0.500
//
// altitude  libmypaint declination
//    90°     90.0°
//    75°     75.0°
//    60°     60.0°
//    45°     45.0°
//    30°     30.0°
//    15°     30.0°
//
// cap points      azimuth  libmypaint ascension
// right                0°     -90°
// down, at you        90°       0°
// left               180°      90°
// up, away           -90°    -180°
//
// roll -30° -> barrel 330°

// What libmypaint makes of the barrel and view-rotation arguments Ariandel
// sends (degrees). 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 no_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) { 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 float seen(MyPaintBrush *brush, MyPaintSurface *surface,
                  float view_rotation, float barrel, MyPaintBrushState state) {
    mypaint_brush_reset(brush);
    mypaint_brush_new_stroke(brush);
    mypaint_brush_stroke_to(brush, surface, 100, 100, 0.5f, 0, 0, 10.0, 1, view_rotation, barrel, 0);
    mypaint_brush_stroke_to(brush, surface, 101, 100, 0.5f, 0, 0, 0.01, 1, view_rotation, barrel, 0);
    return mypaint_brush_get_state(brush, state);
}

int main(void) {
    MyPaintSurface surface = {0};
    surface.draw_dab = no_dab;
    surface.get_color = no_color;
    surface.refcount = 1;
    MyPaintBrush *brush = mypaint_brush_new();
    mypaint_brush_from_defaults(brush);

    float barrels[] = {30.0f, 90.0f, 30.25f, 30.0f / 360};
    for (int i = 0; i < 4; i++)
        printf("barrel_rotation %8.4f -> libmypaint's barrel %6.2f degrees\n", barrels[i],
               seen(brush, &surface, 0, barrels[i], MYPAINT_BRUSH_STATE_BARREL_ROTATION));
    float views[] = {90.0f, 1.5707963f};
    for (int i = 0; i < 2; i++)
        printf("viewrotation    %8.4f -> libmypaint's view %6.2f degrees\n", views[i],
               seen(brush, &surface, views[i], 0, MYPAINT_BRUSH_STATE_VIEWROTATION));
    mypaint_brush_unref(brush);
    return 0;
}

// Prints:
// barrel_rotation  30.0000 -> libmypaint's barrel   0.00 degrees
// barrel_rotation  90.0000 -> libmypaint's barrel   0.00 degrees
// barrel_rotation  30.2500 -> libmypaint's barrel  90.00 degrees
// barrel_rotation   0.0833 -> libmypaint's barrel  30.00 degrees
// viewrotation     90.0000 -> libmypaint's view 116.62 degrees
// viewrotation      1.5708 -> libmypaint's view  90.00 degrees