44d7d0ee5d
Slight change to its default behavior re: pointer variables (before: "type * var"; now seems to prefer: "type *var").
546 lines
15 KiB
C
546 lines
15 KiB
C
/*
|
|
smooth.c
|
|
|
|
FIXME: WORK IN PROGRESS
|
|
|
|
Smoothed-Line Magic Tool Plugin
|
|
Tux Paint - A simple drawing program for children.
|
|
|
|
Idea: Pere Pujal i Carabantes (https://sourceforge.net/p/tuxpaint/feature-requests/238/)
|
|
Based on: calligraphy.c by Bill Kendrick
|
|
|
|
Copyright (c) 2024 by Bill Kendrick and others; see AUTHORS.txt
|
|
bill@newbreedsoftware.com
|
|
https://tuxpaint.org/
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
(See COPYING.txt)
|
|
|
|
Last updated: Januayr 16, 2024
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include "tp_magic_api.h"
|
|
#include "SDL_image.h"
|
|
#include "SDL_mixer.h"
|
|
#include <math.h>
|
|
|
|
enum
|
|
{
|
|
TOOL_SMOOTH,
|
|
TOOL_SQUIGGLES,
|
|
TOOL_LOOPS,
|
|
NUM_TOOLS
|
|
};
|
|
|
|
char *smooth_icon_fnames[NUM_TOOLS] = {
|
|
"smooth.png",
|
|
"squiggles.png",
|
|
"loops.png",
|
|
};
|
|
|
|
char *smooth_snd_fnames[NUM_TOOLS] = {
|
|
"smooth.ogg",
|
|
"squiggles.ogg",
|
|
"loops.ogg",
|
|
};
|
|
|
|
char *smooth_names[NUM_TOOLS] = {
|
|
gettext_noop("Smooth"),
|
|
gettext_noop("Squiggles"),
|
|
gettext_noop("Loops"),
|
|
};
|
|
|
|
char *smooth_descrs[NUM_TOOLS] = {
|
|
gettext_noop("Click and drag the mouse around to draw in freehand; it will be smoothed when you let go."),
|
|
gettext_noop("Click and drag the mouse around to draw squiggles."),
|
|
gettext_noop("Click and drag the mouse around to draw loop-the-loops."),
|
|
};
|
|
|
|
int smooth_sizes[NUM_TOOLS] = {
|
|
8,
|
|
4,
|
|
8,
|
|
};
|
|
|
|
static Mix_Chunk *smooth_snds[NUM_TOOLS];
|
|
static Uint32 smooth_color;
|
|
static int smooth_size;
|
|
|
|
typedef struct
|
|
{
|
|
float x, y;
|
|
} Point2D;
|
|
|
|
#define MAX_CTRL_POINTS 4096
|
|
static Point2D smooth_control_points[MAX_CTRL_POINTS];
|
|
static int num_input_points = 0, smooth_capture = 0;
|
|
int smooth_squiggle_angle = 0, smooth_squiggle_rad = 0;
|
|
|
|
/* Local Function Prototypes */
|
|
static Point2D smooth_PointOnCubicBezier(Point2D * cp, float t);
|
|
static void smooth_ComputeBezier(Point2D * cp, int numberOfPoints, Point2D * curve);
|
|
static float smooth_dist(float x1, float y1, float x2, float y2);
|
|
|
|
int smooth_init(magic_api * api, Uint8 disabled_features, Uint8 complexity_level);
|
|
Uint32 smooth_api_version(void);
|
|
int smooth_get_tool_count(magic_api * api);
|
|
SDL_Surface *smooth_get_icon(magic_api * api, int which);
|
|
char *smooth_get_name(magic_api * api, int which);
|
|
int smooth_get_group(magic_api * api, int which);
|
|
int smooth_get_order(int which);
|
|
char *smooth_get_description(magic_api * api, int which, int mode);
|
|
static void smooth_linecb(void *ptr, int which, SDL_Surface * canvas, SDL_Surface * last, int x, int y);
|
|
static void smooth_squiggle_linecb(void *ptr, int which,
|
|
SDL_Surface * canvas, SDL_Surface * last ATTRIBUTE_UNUSED, int x, int y);
|
|
void smooth_drag(magic_api * api, int which, SDL_Surface * canvas,
|
|
SDL_Surface * last, int ox, int oy, int x, int y, SDL_Rect * update_rect);
|
|
void smooth_click(magic_api * api, int which, int mode,
|
|
SDL_Surface * canvas, SDL_Surface * last, int x, int y, SDL_Rect * update_rect);
|
|
void smooth_release(magic_api * api, int which, SDL_Surface * canvas,
|
|
SDL_Surface * last, int x, int y, SDL_Rect * update_rect);
|
|
void smooth_shutdown(magic_api * api);
|
|
void smooth_set_color(magic_api * api, int which, SDL_Surface * canvas,
|
|
SDL_Surface * last, Uint8 r, Uint8 g, Uint8 b, SDL_Rect * update_rect);
|
|
int smooth_requires_colors(magic_api * api, int which);
|
|
void smooth_switchin(magic_api * api, int which, int mode, SDL_Surface * canvas);
|
|
void smooth_switchout(magic_api * api, int which, int mode, SDL_Surface * canvas);
|
|
int smooth_modes(magic_api * api, int which);
|
|
Uint8 smooth_accepted_sizes(magic_api * api, int which, int mode);
|
|
Uint8 smooth_default_size(magic_api * api, int which, int mode);
|
|
void smooth_set_size(magic_api * api, int which, int mode, SDL_Surface * canvas, SDL_Surface * last, Uint8 size,
|
|
SDL_Rect * update_rect);
|
|
|
|
|
|
|
|
int smooth_init(magic_api *api, Uint8 disabled_features ATTRIBUTE_UNUSED, Uint8 complexity_level ATTRIBUTE_UNUSED)
|
|
{
|
|
char fname[1024];
|
|
int i;
|
|
|
|
for (i = 0; i < NUM_TOOLS; i++)
|
|
{
|
|
snprintf(fname, sizeof(fname), "%ssounds/magic/%s", api->data_directory, smooth_snd_fnames[i]);
|
|
smooth_snds[i] = Mix_LoadWAV(fname);
|
|
}
|
|
|
|
return (1);
|
|
}
|
|
|
|
Uint32 smooth_api_version(void)
|
|
{
|
|
return (TP_MAGIC_API_VERSION);
|
|
}
|
|
|
|
// Only one tool:
|
|
int smooth_get_tool_count(magic_api *api ATTRIBUTE_UNUSED)
|
|
{
|
|
return (NUM_TOOLS);
|
|
}
|
|
|
|
// Load our icon:
|
|
SDL_Surface *smooth_get_icon(magic_api *api, int which)
|
|
{
|
|
char fname[1024];
|
|
|
|
snprintf(fname, sizeof(fname), "%simages/magic/%s", api->data_directory, smooth_icon_fnames[which]);
|
|
return (IMG_Load(fname));
|
|
}
|
|
|
|
// Return our name, localized:
|
|
char *smooth_get_name(magic_api *api ATTRIBUTE_UNUSED, int which)
|
|
{
|
|
return (strdup(gettext(smooth_names[which])));
|
|
}
|
|
|
|
// Return our group
|
|
int smooth_get_group(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
|
|
{
|
|
return MAGIC_TYPE_PAINTING;
|
|
}
|
|
|
|
// Return our order
|
|
int smooth_get_order(int which)
|
|
{
|
|
return 1300 + which;
|
|
}
|
|
|
|
// Return our description, localized:
|
|
char *smooth_get_description(magic_api *api ATTRIBUTE_UNUSED, int which, int mode ATTRIBUTE_UNUSED)
|
|
{
|
|
return (strdup(gettext(smooth_descrs[which])));
|
|
}
|
|
|
|
|
|
static void smooth_linecb(void *ptr, int which, SDL_Surface *canvas, SDL_Surface *last ATTRIBUTE_UNUSED, int x, int y)
|
|
{
|
|
magic_api *api = (magic_api *) ptr;
|
|
SDL_Rect dest;
|
|
|
|
if (which == TOOL_SMOOTH)
|
|
{
|
|
/* FIXME */
|
|
dest.x = x;
|
|
dest.y = y;
|
|
dest.w = smooth_size;
|
|
dest.h = smooth_size;
|
|
|
|
SDL_FillRect(canvas, &dest, smooth_color);
|
|
}
|
|
else if (which == TOOL_LOOPS)
|
|
{
|
|
/* FIXME */
|
|
dest.x = x;
|
|
dest.y = y;
|
|
dest.w = 2;
|
|
dest.h = 2;
|
|
|
|
SDL_FillRect(canvas, &dest, smooth_color);
|
|
}
|
|
else if (which == TOOL_SQUIGGLES)
|
|
{
|
|
api->putpixel(canvas, x, y, smooth_color);
|
|
}
|
|
}
|
|
|
|
#define LOOP_RAD_CALC (smooth_size * 10)
|
|
|
|
static void smooth_squiggle_linecb(void *ptr, int which,
|
|
SDL_Surface *canvas, SDL_Surface *last ATTRIBUTE_UNUSED, int x, int y)
|
|
{
|
|
magic_api *api = (magic_api *) ptr;
|
|
int xx1, yy1, xx2, yy2, i;
|
|
|
|
xx2 = x + (cos(smooth_squiggle_angle * M_PI / 180.0) * smooth_squiggle_rad);
|
|
yy2 = y - (sin(smooth_squiggle_angle * M_PI / 180.0) * smooth_squiggle_rad);
|
|
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
xx1 = xx2;
|
|
yy1 = yy2;
|
|
|
|
if (which == TOOL_LOOPS)
|
|
{
|
|
smooth_squiggle_angle += 5;
|
|
smooth_squiggle_rad = LOOP_RAD_CALC;
|
|
}
|
|
else if (which == TOOL_SQUIGGLES)
|
|
{
|
|
smooth_squiggle_angle += (rand() % 5) + 5;
|
|
smooth_squiggle_rad += ((rand() % 3 * smooth_size) - smooth_size);
|
|
if (smooth_squiggle_rad < 5)
|
|
{
|
|
smooth_squiggle_rad += 5;
|
|
}
|
|
else if (smooth_squiggle_rad >= 15 * smooth_size)
|
|
{
|
|
smooth_squiggle_rad -= ((rand() % 10) + 10);
|
|
}
|
|
}
|
|
|
|
xx2 = x + (cos(smooth_squiggle_angle * M_PI / 180.0) * smooth_squiggle_rad);
|
|
yy2 = y - (sin(smooth_squiggle_angle * M_PI / 180.0) * smooth_squiggle_rad);
|
|
|
|
api->line((void *)api, which, canvas, last, xx1, yy1, xx2, yy2, 1, smooth_linecb);
|
|
}
|
|
|
|
if (smooth_squiggle_angle >= 360)
|
|
{
|
|
smooth_squiggle_angle -= 360;
|
|
}
|
|
}
|
|
|
|
void smooth_drag(magic_api *api, int which,
|
|
SDL_Surface *canvas, SDL_Surface *last, int ox, int oy, int x, int y, SDL_Rect *update_rect)
|
|
{
|
|
if (which == TOOL_SMOOTH)
|
|
{
|
|
if (num_input_points >= MAX_CTRL_POINTS)
|
|
{
|
|
return;
|
|
}
|
|
smooth_capture = (smooth_capture + 1) % 4;
|
|
|
|
if (smooth_capture == 1)
|
|
{
|
|
num_input_points++;
|
|
smooth_control_points[num_input_points].x = x;
|
|
smooth_control_points[num_input_points].y = y;
|
|
}
|
|
}
|
|
|
|
if (which == TOOL_SMOOTH)
|
|
{
|
|
api->line((void *)api, which, canvas, last, ox, oy, x, y, 1, smooth_linecb);
|
|
}
|
|
else if (which == TOOL_SQUIGGLES || which == TOOL_LOOPS)
|
|
{
|
|
api->line((void *)api, which, canvas, last, ox, oy, x, y, 1, smooth_squiggle_linecb);
|
|
}
|
|
|
|
if (which == TOOL_SMOOTH)
|
|
{
|
|
if (ox > x)
|
|
{
|
|
int tmp = ox;
|
|
|
|
ox = x;
|
|
x = tmp;
|
|
}
|
|
if (oy > y)
|
|
{
|
|
int tmp = oy;
|
|
|
|
oy = y;
|
|
y = tmp;
|
|
}
|
|
|
|
// FIXME
|
|
update_rect->x = ox - 16;
|
|
update_rect->y = oy - 16;
|
|
update_rect->w = (x + 16) - update_rect->x;
|
|
update_rect->h = (y + 16) - update_rect->y;
|
|
}
|
|
else if (which == TOOL_LOOPS)
|
|
{
|
|
// FIXME
|
|
update_rect->x = 0;
|
|
update_rect->y = 0;
|
|
update_rect->w = canvas->w;
|
|
update_rect->h = canvas->h;
|
|
}
|
|
else if (which == TOOL_SQUIGGLES)
|
|
{
|
|
// FIXME
|
|
update_rect->x = 0;
|
|
update_rect->y = 0;
|
|
update_rect->w = canvas->w;
|
|
update_rect->h = canvas->h;
|
|
}
|
|
|
|
api->playsound(smooth_snds[which], (x * 255) / canvas->w, 255);
|
|
}
|
|
|
|
void smooth_click(magic_api *api,
|
|
int which, int mode ATTRIBUTE_UNUSED,
|
|
SDL_Surface *canvas, SDL_Surface *last, int x, int y, SDL_Rect *update_rect)
|
|
{
|
|
num_input_points = 0;
|
|
smooth_control_points[num_input_points].x = x;
|
|
smooth_control_points[num_input_points].y = y;
|
|
|
|
smooth_capture = 0;
|
|
if (which == TOOL_SQUIGGLES)
|
|
{
|
|
smooth_squiggle_angle = 0;
|
|
smooth_squiggle_rad = 0;
|
|
smooth_drag(api, which, canvas, last, x, y, x, y, update_rect);
|
|
}
|
|
else if (which == TOOL_LOOPS)
|
|
{
|
|
smooth_squiggle_angle = 0;
|
|
smooth_squiggle_rad = LOOP_RAD_CALC;
|
|
smooth_drag(api, which, canvas, last, x, y, x, y, update_rect);
|
|
}
|
|
}
|
|
|
|
|
|
void smooth_release(magic_api *api,
|
|
int which ATTRIBUTE_UNUSED,
|
|
SDL_Surface *canvas, SDL_Surface *last, int x, int y, SDL_Rect *update_rect)
|
|
{
|
|
if (which == TOOL_SMOOTH)
|
|
{
|
|
Point2D *curve;
|
|
int p, i, n_points;
|
|
|
|
for (p = 0; p < 4; p++)
|
|
{
|
|
num_input_points++;
|
|
smooth_control_points[num_input_points].x = x;
|
|
smooth_control_points[num_input_points].y = y;
|
|
}
|
|
|
|
SDL_BlitSurface(last, NULL, canvas, NULL);
|
|
|
|
for (p = 0; p < num_input_points - 3; p += 3)
|
|
{
|
|
n_points = smooth_dist(smooth_control_points[p + 0].x,
|
|
smooth_control_points[p + 0].y,
|
|
smooth_control_points[p + 1].x,
|
|
smooth_control_points[p + 1].y) +
|
|
smooth_dist(smooth_control_points[p + 1].x,
|
|
smooth_control_points[p + 1].y,
|
|
smooth_control_points[p + 2].x,
|
|
smooth_control_points[p + 2].y) +
|
|
smooth_dist(smooth_control_points[p + 2].x,
|
|
smooth_control_points[p + 2].y, smooth_control_points[p + 3].x, smooth_control_points[p + 3].y);
|
|
|
|
if (n_points == 0)
|
|
continue; // No-op; not any points to plot
|
|
|
|
|
|
curve = (Point2D *) malloc(sizeof(Point2D) * n_points);
|
|
|
|
smooth_ComputeBezier(smooth_control_points + p, n_points, curve);
|
|
|
|
for (i = 0; i < n_points - 1; i++)
|
|
{
|
|
api->line((void *)api, which, canvas, last, curve[i].x, curve[i].y, curve[i + 1].x, curve[i + 1].y, 1,
|
|
smooth_linecb);
|
|
}
|
|
|
|
free(curve);
|
|
api->update_progress_bar();
|
|
}
|
|
}
|
|
|
|
api->stopsound();
|
|
|
|
update_rect->x = 0;
|
|
update_rect->y = 0;
|
|
update_rect->w = canvas->w;
|
|
update_rect->h = canvas->h;
|
|
}
|
|
|
|
|
|
void smooth_shutdown(magic_api *api ATTRIBUTE_UNUSED)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < NUM_TOOLS; i++)
|
|
{
|
|
if (smooth_snds[i] != NULL)
|
|
Mix_FreeChunk(smooth_snds[i]);
|
|
}
|
|
}
|
|
|
|
void smooth_set_color(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED,
|
|
SDL_Surface *canvas,
|
|
SDL_Surface *last ATTRIBUTE_UNUSED, Uint8 r, Uint8 g, Uint8 b,
|
|
SDL_Rect *update_rect ATTRIBUTE_UNUSED)
|
|
{
|
|
smooth_color = SDL_MapRGB(canvas->format, r, g, b);
|
|
}
|
|
|
|
int smooth_requires_colors(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*
|
|
Code to generate a cubic Bezier curve
|
|
*/
|
|
|
|
/*
|
|
cp is a 4 element array where:
|
|
cp[0] is the starting point, or P0 in the above diagram
|
|
cp[1] is the first control point, or P1 in the above diagram
|
|
cp[2] is the second control point, or P2 in the above diagram
|
|
cp[3] is the end point, or P3 in the above diagram
|
|
t is the parameter value, 0 <= t <= 1
|
|
*/
|
|
|
|
static Point2D smooth_PointOnCubicBezier(Point2D *cp, float t)
|
|
{
|
|
float ax, bx, cx;
|
|
float ay, by, cy;
|
|
float tSquared, tCubed;
|
|
Point2D result;
|
|
|
|
/* calculate the polynomial coefficients */
|
|
|
|
cx = 3.0 * (cp[1].x - cp[0].x);
|
|
bx = 3.0 * (cp[2].x - cp[1].x) - cx;
|
|
ax = cp[3].x - cp[0].x - cx - bx;
|
|
|
|
cy = 3.0 * (cp[1].y - cp[0].y);
|
|
by = 3.0 * (cp[2].y - cp[1].y) - cy;
|
|
ay = cp[3].y - cp[0].y - cy - by;
|
|
|
|
/* calculate the curve point at parameter value t */
|
|
|
|
tSquared = t * t;
|
|
tCubed = tSquared * t;
|
|
|
|
result.x = (ax * tCubed) + (bx * tSquared) + (cx * t) + cp[0].x;
|
|
result.y = (ay * tCubed) + (by * tSquared) + (cy * t) + cp[0].y;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/*
|
|
ComputeBezier fills an array of Point2D structs with the curve
|
|
points generated from the control points cp. Caller must
|
|
allocate sufficient memory for the result, which is
|
|
<sizeof(Point2D) numberOfPoints>
|
|
*/
|
|
|
|
static void smooth_ComputeBezier(Point2D *cp, int numberOfPoints, Point2D *curve)
|
|
{
|
|
float dt;
|
|
int i;
|
|
|
|
dt = 1.0 / (numberOfPoints - 1);
|
|
|
|
for (i = 0; i < numberOfPoints; i++)
|
|
curve[i] = smooth_PointOnCubicBezier(cp, i * dt);
|
|
}
|
|
|
|
static float smooth_dist(float x1, float y1, float x2, float y2)
|
|
{
|
|
float d;
|
|
|
|
d = (sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)));
|
|
|
|
return d;
|
|
}
|
|
|
|
void smooth_switchin(magic_api *api ATTRIBUTE_UNUSED,
|
|
int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED, SDL_Surface *canvas ATTRIBUTE_UNUSED)
|
|
{
|
|
}
|
|
|
|
void smooth_switchout(magic_api *api ATTRIBUTE_UNUSED,
|
|
int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED, SDL_Surface *canvas ATTRIBUTE_UNUSED)
|
|
{
|
|
}
|
|
|
|
int smooth_modes(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
|
|
{
|
|
return (MODE_PAINT);
|
|
}
|
|
|
|
|
|
Uint8 smooth_accepted_sizes(magic_api *api ATTRIBUTE_UNUSED, int which, int mode ATTRIBUTE_UNUSED)
|
|
{
|
|
return smooth_sizes[which];
|
|
}
|
|
|
|
Uint8 smooth_default_size(magic_api *api ATTRIBUTE_UNUSED, int which, int mode ATTRIBUTE_UNUSED)
|
|
{
|
|
return smooth_sizes[which] / 2;
|
|
}
|
|
|
|
void smooth_set_size(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED,
|
|
SDL_Surface *canvas ATTRIBUTE_UNUSED, SDL_Surface *last ATTRIBUTE_UNUSED,
|
|
Uint8 size, SDL_Rect *update_rect ATTRIBUTE_UNUSED)
|
|
{
|
|
smooth_size = size;
|
|
}
|