draw_dab 넘겨받기

/* CAriandelSurface/ariandel_surface.c (verbatim) */
ArdSurface *
ard_surface_create(void *context, ArdTileAcquire acquire, ArdTileRelease release)
{
    ArdSurface *self = calloc(1, sizeof(ArdSurface));
    if (self == NULL) {
        return NULL;
    }
    self->empty = calloc(ARD_TILE_VALUES, sizeof(uint16_t));
    self->scratch = calloc(ARD_TILE_VALUES, sizeof(uint16_t));
    if (self->empty == NULL || self->scratch == NULL) {
        free(self->empty);
        free(self->scratch);
        free(self);
        return NULL;
    }
    self->context = context;
    self->acquire = acquire;
    self->release = release;
    mypaint_tiled_surface_init(&self->parent, tile_request_start, tile_request_end);
    self->parent.parent.destroy = surface_destroy;
    self->round_dab = self->parent.parent.draw_dab;
    self->parent.parent.draw_dab = shaped_draw_dab;
    return self;
}

/* The same file, the head of the replacement (trimmed after the call-through) */
/* libmypaint's draw_dab with a shaped tip: the tip turns with the stroke and
   at random as asked, and symmetry repeats it as libmypaint repeats a round
   dab (reflections mirror the tip too). Without a shape, libmypaint's own. */
static int
shaped_draw_dab(MyPaintSurface *surface, float x, float y, float radius,
                float color_r, float color_g, float color_b,
                float opaque, float hardness, float softness, float color_a,
                float aspect_ratio, float angle, float lock_alpha, float colorize,
                float posterize, float posterize_num, float paint)
{
    ArdSurface *self = (ArdSurface *)surface;
    if (self->levels == 0) {
        return self->round_dab(surface, x, y, radius, color_r, color_g, color_b, opaque, hardness, softness,
                               color_a, aspect_ratio, angle, lock_alpha, colorize, posterize, posterize_num, paint);
    }
    /* ... the shaped path: heading, turn, flips, stamp(), symmetry ... */
}

/* libmypaint, mypaint-tiled-surface.c, inside draw_dab (trimmed) */
    // Symmetry pass

    // OPTIMIZATION: skip the symmetry pass if surface was not modified by the initial dab;
    // at current if the initial dab does not modify the surface, none of the symmetry dabs
    // will either. If/when selection masks are added, this optimization _must_ be removed,
    // and `surface_modified` must be or'ed with the result of each call to draw_dab_internal.
    MyPaintSymmetryData *symm_data = &self->symmetry_data;
    if (surface_modified && symm_data->active && symm_data->num_symmetry_matrices) {
        /* ... */
        case MYPAINT_SYMMETRY_TYPE_VERTHORZ: {
            // Reflect across horizontal line
            mypaint_transform_point(&matrices[0], x, y, &x_out, &y_out);
            DDI(x_out, y_out, -2.0 * symm.angle - angle, 1);
            // Then across the vertical line (diagonal)
            mypaint_transform_point(&matrices[1], x, y, &x_out, &y_out);
            DDI(x_out, y_out, angle, 2);
            // Then back across the horizontal line
            mypaint_transform_point(&matrices[2], x, y, &x_out, &y_out);
            DDI(x_out, y_out, -2.0 * symm.angle - angle, 3);
            num_bboxes_used = 4;
            break;
        /* ... */

/* Ariandel, ariandel_surface.c, inside shaped_draw_dab (trimmed) */
    int painted = STAMP(x, y, turn, 0);

    MyPaintSymmetryData *symm_data = &self->parent.symmetry_data;
    if (symm_data->active && symm_data->num_symmetry_matrices) {
        /* ... */
        case MYPAINT_SYMMETRY_TYPE_VERTHORZ:
            mypaint_transform_point(&matrices[0], x, y, &x_out, &y_out);
            painted |= STAMP(x_out, y_out, -2.0f * symm.angle - turn, 1);
            mypaint_transform_point(&matrices[1], x, y, &x_out, &y_out);
            painted |= STAMP(x_out, y_out, turn + 180.0f, 0);
            mypaint_transform_point(&matrices[2], x, y, &x_out, &y_out);
            painted |= STAMP(x_out, y_out, -2.0f * symm.angle - turn + 180.0f, 1);
            break;
        /* ... */

// A minimal sketch of the draw_dab takeover: keep the engine's function,
// install your own, call through when you have nothing to add.
// clang -std=c11 -Wall -Wextra wrap.c -o wrap && ./wrap
#include <stdio.h>
#include <stdlib.h>

typedef struct Surface Surface;
typedef int (*DrawDab)(Surface *self, float x, float y, float radius);
struct Surface { DrawDab draw_dab; };              /* the engine's vtable slot */

/* ---- the engine, untouched ---- */
static int engine_round_dab(Surface *self, float x, float y, float radius) {
    (void)self;
    printf("  engine: round dab r=%.1f at (%.0f, %.0f)\n", radius, x, y);
    return 1;
}
static void engine_init(Surface *s) { s->draw_dab = engine_round_dab; }
static void engine_stroke(Surface *s) { s->draw_dab(s, 5, 5, 3); s->draw_dab(s, 9, 6, 3); }

/* ---- the host ---- */
typedef struct {
    Surface parent;      /* first, so Surface* -> Host* is valid */
    DrawDab round_dab;   /* the engine's own, saved */
    const char *shape;   /* NULL: no shape set */
} Host;

static int host_draw_dab(Surface *surface, float x, float y, float radius) {
    Host *self = (Host *)surface;
    if (self->shape == NULL) {
        return self->round_dab(surface, x, y, radius);   /* straight through */
    }
    printf("  host:   stamp '%s' r=%.1f at (%.0f, %.0f)\n", self->shape, radius, x, y);
    return 1;
}

static Host *host_create(void) {
    Host *self = calloc(1, sizeof *self);
    engine_init(&self->parent);                 /* let the engine install its own first */
    self->round_dab = self->parent.draw_dab;    /* then save it */
    self->parent.draw_dab = host_draw_dab;      /* and take the slot */
    return self;
}

int main(void) {
    Host *host = host_create();
    puts("no shape:");
    engine_stroke(&host->parent);
    host->shape = "leaf";
    puts("with a shape:");
    engine_stroke(&host->parent);
    free(host);
    return 0;
}
/* Output:
   no shape:
     engine: round dab r=3.0 at (5, 5)
     engine: round dab r=3.0 at (9, 6)
   with a shape:
     host:   stamp 'leaf' r=3.0 at (5, 5)
     host:   stamp 'leaf' r=3.0 at (9, 6) */