44d7d0ee5d
Slight change to its default behavior re: pointer variables (before: "type * var"; now seems to prefer: "type *var").
435 lines
13 KiB
C
435 lines
13 KiB
C
/*
|
|
spiral.c
|
|
|
|
Draws a spiral shape, or a concentric shape -- circular or square --
|
|
centered around the mouse click point. Size setting changes thickness
|
|
and spacing.
|
|
|
|
Tux Paint - A simple drawing program for children.
|
|
|
|
Copyright (c) 2024 by Bill Kendrick
|
|
|
|
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: October 7, 2024
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "tp_magic_api.h"
|
|
#include "SDL_image.h"
|
|
#include "SDL_mixer.h"
|
|
|
|
enum
|
|
{
|
|
TOOL_SPIRAL_CIRCLE,
|
|
TOOL_SPIRAL_SQUARE,
|
|
TOOL_CONCENTRIC_CIRCLE,
|
|
TOOL_CONCENTRIC_SQUARE,
|
|
NUM_TOOLS
|
|
};
|
|
|
|
const char *spiral_names[NUM_TOOLS] = {
|
|
gettext_noop("Spiral"),
|
|
gettext_noop("Square Spiral"),
|
|
gettext_noop("Concentric Circles"),
|
|
gettext_noop("Concentric Squares"),
|
|
};
|
|
|
|
const char *spiral_descrs[NUM_TOOLS] = {
|
|
gettext_noop("Click and drag to create a spiral."),
|
|
gettext_noop("Click and drag to create a square spiral."),
|
|
gettext_noop("Click and drag to create concentric circles."),
|
|
gettext_noop("Click and drag to create concentric squares."),
|
|
};
|
|
|
|
const char *spiral_sounds[NUM_TOOLS] = {
|
|
"spiral-circle.ogg",
|
|
"spiral-square.ogg",
|
|
"concentric-circle.ogg",
|
|
"concentric-square.ogg",
|
|
};
|
|
|
|
const char *spiral_icons[NUM_TOOLS] = {
|
|
"spiral-circle.png",
|
|
"spiral-square.png",
|
|
"concentric-circle.png",
|
|
"concentric-square.png",
|
|
};
|
|
|
|
static Mix_Chunk *spiral_snd[NUM_TOOLS];
|
|
static int spiral_thickness = 2;
|
|
Uint32 spiral_color;
|
|
int spiral_cx, spiral_cy, spiral_has_dragged;
|
|
|
|
/* When first clicking, and when click-and-release-ing
|
|
(without dragging), we'll draw a default spiral that
|
|
is `MIN_RADIUS` * `sprial_thickness` in radius. */
|
|
#define MIN_RADIUS 32
|
|
|
|
/* Angle will be the radius multiplied by `ITER` divided
|
|
by `spiral_thickness`; the larger the thickness, the
|
|
fewer the iterations (the slower the spiral will go around) */
|
|
#define ITER 50
|
|
|
|
Uint32 spiral_api_version(void);
|
|
int spiral_init(magic_api * api, Uint8 disabled_features, Uint8 complexity_level);
|
|
int spiral_get_tool_count(magic_api * api);
|
|
SDL_Surface *spiral_get_icon(magic_api * api, int which);
|
|
char *spiral_get_name(magic_api * api, int which);
|
|
int spiral_get_group(magic_api * api, int which);
|
|
int spiral_get_order(int which);
|
|
char *spiral_get_description(magic_api * api, int which, int mode);
|
|
|
|
void spiral_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 spiral_click(magic_api * api, int which, int mode,
|
|
SDL_Surface * canvas, SDL_Surface * last, int x, int y, SDL_Rect * update_rect);
|
|
|
|
void spiral_release(magic_api * api, int which,
|
|
SDL_Surface * canvas, SDL_Surface * last, int x, int y, SDL_Rect * update_rect);
|
|
|
|
void spiral_shutdown(magic_api * api);
|
|
void spiral_set_color(magic_api * api, int which, SDL_Surface * canvas,
|
|
SDL_Surface * last, Uint8 r, Uint8 g, Uint8 b, SDL_Rect * update_rect);
|
|
int spiral_requires_colors(magic_api * api, int which);
|
|
void spiral_switchin(magic_api * api, int which, int mode, SDL_Surface * canvas);
|
|
void spiral_switchout(magic_api * api, int which, int mode, SDL_Surface * canvas);
|
|
int spiral_modes(magic_api * api, int which);
|
|
Uint8 spiral_accepted_sizes(magic_api * api, int which, int mode);
|
|
Uint8 spiral_default_size(magic_api * api, int which, int mode);
|
|
void spiral_set_size(magic_api * api, int which, int mode, SDL_Surface * canvas, SDL_Surface * last, Uint8 size,
|
|
SDL_Rect * update_rect);
|
|
|
|
void do_spiral(magic_api * api, int which, SDL_Surface * canvas,
|
|
SDL_Surface * last, int x, int y, SDL_Rect * update_rect, int final);
|
|
|
|
Uint32 spiral_api_version(void)
|
|
{
|
|
return (TP_MAGIC_API_VERSION);
|
|
}
|
|
|
|
int spiral_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, spiral_sounds[i]);
|
|
spiral_snd[i] = Mix_LoadWAV(fname);
|
|
}
|
|
|
|
return (1);
|
|
}
|
|
|
|
int spiral_get_tool_count(magic_api *api ATTRIBUTE_UNUSED)
|
|
{
|
|
return (NUM_TOOLS);
|
|
}
|
|
|
|
SDL_Surface *spiral_get_icon(magic_api *api, int which)
|
|
{
|
|
char fname[1024];
|
|
|
|
snprintf(fname, sizeof(fname), "%simages/magic/%s", api->data_directory, spiral_icons[which]);
|
|
|
|
return (IMG_Load(fname));
|
|
}
|
|
|
|
char *spiral_get_name(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
|
|
{
|
|
return (strdup(gettext(spiral_names[which])));
|
|
}
|
|
|
|
int spiral_get_group(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
|
|
{
|
|
return MAGIC_TYPE_PAINTING;
|
|
}
|
|
|
|
int spiral_get_order(int which)
|
|
{
|
|
return 1310 + which;
|
|
}
|
|
|
|
char *spiral_get_description(magic_api *api ATTRIBUTE_UNUSED, int which, int mode ATTRIBUTE_UNUSED)
|
|
{
|
|
return (strdup(gettext(spiral_descrs[which])));
|
|
}
|
|
|
|
static void do_spiral_render(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;
|
|
int thick;
|
|
|
|
thick = spiral_thickness * 4;
|
|
|
|
if (which == TOOL_SPIRAL_CIRCLE || which == TOOL_CONCENTRIC_CIRCLE)
|
|
{
|
|
int xx, yy;
|
|
|
|
for (yy = -thick / 2; yy <= thick / 2; yy++)
|
|
for (xx = -thick / 2; xx <= thick / 2; xx++)
|
|
if (api->in_circle(xx, yy, thick / 2))
|
|
api->putpixel(canvas, x + xx, y + yy, spiral_color);
|
|
}
|
|
else if (which == TOOL_SPIRAL_SQUARE || which == TOOL_CONCENTRIC_SQUARE)
|
|
{
|
|
dest.x = x - thick / 2;
|
|
dest.y = y - thick / 2;
|
|
dest.w = thick;
|
|
dest.h = thick;
|
|
|
|
SDL_FillRect(canvas, &dest, spiral_color);
|
|
}
|
|
}
|
|
|
|
void do_spiral(magic_api *api, int which, SDL_Surface *canvas,
|
|
SDL_Surface *last, int x, int y, SDL_Rect *update_rect, int final)
|
|
{
|
|
float radius = 0, i, xx, yy, xsgn, ysgn, stp, oxx, oyy;
|
|
int vol;
|
|
|
|
SDL_BlitSurface(last, NULL, canvas, NULL);
|
|
|
|
if (x < spiral_cx)
|
|
xsgn = -1;
|
|
else
|
|
xsgn = 1;
|
|
|
|
if (y < spiral_cy)
|
|
ysgn = -1;
|
|
else
|
|
ysgn = 1;
|
|
|
|
if (which == TOOL_SPIRAL_CIRCLE)
|
|
{
|
|
if (final)
|
|
stp = 0.1;
|
|
else
|
|
stp = 0.5;
|
|
|
|
radius = sqrt(pow((x - spiral_cx), 2) + pow((y - spiral_cy), 2));
|
|
|
|
oxx = 0;
|
|
oyy = 0;
|
|
|
|
for (i = 0; i < radius; i += stp)
|
|
{
|
|
xx = (i * cos((i * (ITER / spiral_thickness)) / 180.0 * M_PI)) * xsgn;
|
|
yy = (i * sin((i * (ITER / spiral_thickness)) / 180.0 * M_PI)) * ysgn;
|
|
if (final)
|
|
{
|
|
api->line((void *)api, which, canvas, NULL,
|
|
((int)oxx) + spiral_cx, ((int)oyy) + spiral_cy,
|
|
((int)xx) + spiral_cx, ((int)yy) + spiral_cy, 1, do_spiral_render);
|
|
oxx = xx;
|
|
oyy = yy;
|
|
}
|
|
else
|
|
{
|
|
do_spiral_render(api, which, canvas, NULL, ((int)xx) + spiral_cx, ((int)yy) + spiral_cy);
|
|
}
|
|
}
|
|
}
|
|
else if (which == TOOL_SPIRAL_SQUARE)
|
|
{
|
|
int dir, oi, ooi;
|
|
|
|
radius = max(abs(x - spiral_cx), abs(y - spiral_cy));
|
|
|
|
dir = 0;
|
|
ooi = 0;
|
|
oi = 0;
|
|
for (i = spiral_thickness; i < radius; i += spiral_thickness * 2)
|
|
{
|
|
if (dir == 0) // right
|
|
api->line((void *)api, which, canvas, NULL,
|
|
spiral_cx - (ooi * xsgn), spiral_cy - (oi * ysgn),
|
|
spiral_cx + (i * xsgn), spiral_cy - (oi * ysgn), 1, do_spiral_render);
|
|
else if (dir == 1) // down
|
|
api->line((void *)api, which, canvas, NULL,
|
|
spiral_cx + (oi * xsgn), spiral_cy - (ooi * ysgn),
|
|
spiral_cx + (oi * xsgn), spiral_cy + (i * ysgn), 1, do_spiral_render);
|
|
else if (dir == 2) // left
|
|
api->line((void *)api, which, canvas, NULL,
|
|
spiral_cx + (ooi * xsgn), spiral_cy + (oi * ysgn),
|
|
spiral_cx - (i * xsgn), spiral_cy + (oi * ysgn), 1, do_spiral_render);
|
|
else if (dir == 3) // up
|
|
api->line((void *)api, which, canvas, NULL,
|
|
spiral_cx - (oi * xsgn), spiral_cy + (ooi * ysgn),
|
|
spiral_cx - (oi * xsgn), spiral_cy - (i * ysgn), 1, do_spiral_render);
|
|
|
|
dir = (dir + 1) % 4;
|
|
|
|
ooi = oi;
|
|
oi = i;
|
|
}
|
|
}
|
|
else if (which == TOOL_CONCENTRIC_CIRCLE)
|
|
{
|
|
float ang, ang_stp;
|
|
|
|
radius = sqrt(pow((x - spiral_cx), 2) + pow((y - spiral_cy), 2));
|
|
|
|
if (final)
|
|
ang_stp = 1;
|
|
else
|
|
ang_stp = 5;
|
|
|
|
for (i = 0; i < radius; i += spiral_thickness * 8)
|
|
{
|
|
oxx = (i * cos(0));
|
|
oyy = (i * sin(0));
|
|
for (ang = 0; ang < 360; ang += ang_stp)
|
|
{
|
|
xx = (i * cos(ang / 180.0 * M_PI));
|
|
yy = (i * sin(ang / 180.0 * M_PI));
|
|
if (final)
|
|
{
|
|
api->line((void *)api, which, canvas, NULL,
|
|
((int)oxx) + spiral_cx, ((int)oyy) + spiral_cy,
|
|
((int)xx) + spiral_cx, ((int)yy) + spiral_cy, 1, do_spiral_render);
|
|
oxx = xx;
|
|
oyy = yy;
|
|
}
|
|
else
|
|
{
|
|
do_spiral_render(api, which, canvas, NULL, ((int)xx) + spiral_cx, ((int)yy) + spiral_cy);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (which == TOOL_CONCENTRIC_SQUARE)
|
|
{
|
|
radius = max(abs(x - spiral_cx), abs(y - spiral_cy));
|
|
|
|
for (i = spiral_thickness; i < radius; i += spiral_thickness * 8)
|
|
{
|
|
api->line((void *)api, which, canvas, NULL,
|
|
spiral_cx - i, spiral_cy - i, spiral_cx + i, spiral_cy - i, 1, do_spiral_render);
|
|
api->line((void *)api, which, canvas, NULL,
|
|
spiral_cx + i, spiral_cy - i, spiral_cx + i, spiral_cy + i, 1, do_spiral_render);
|
|
api->line((void *)api, which, canvas, NULL,
|
|
spiral_cx + i, spiral_cy + i, spiral_cx - i, spiral_cy + i, 1, do_spiral_render);
|
|
api->line((void *)api, which, canvas, NULL,
|
|
spiral_cx - i, spiral_cy + i, spiral_cx - i, spiral_cy - i, 1, do_spiral_render);
|
|
}
|
|
}
|
|
|
|
/* FIXME */
|
|
update_rect->x = 0;
|
|
update_rect->y = 0;
|
|
update_rect->w = canvas->w;
|
|
update_rect->h = canvas->h;
|
|
|
|
vol = (radius * 255) / max(canvas->w, canvas->h);
|
|
if (vol > 255)
|
|
vol = 255;
|
|
else if (vol < 32)
|
|
vol = 32;
|
|
|
|
api->playsound(spiral_snd[which], (spiral_cx * 255) / canvas->w, vol);
|
|
}
|
|
|
|
void spiral_drag(magic_api *api, int which, SDL_Surface *canvas,
|
|
SDL_Surface *last, int ox ATTRIBUTE_UNUSED, int oy ATTRIBUTE_UNUSED, int x, int y,
|
|
SDL_Rect *update_rect)
|
|
{
|
|
spiral_has_dragged = 1;
|
|
do_spiral(api, which, canvas, last, x, y, update_rect, 0);
|
|
}
|
|
|
|
void spiral_click(magic_api *api, int which, int mode ATTRIBUTE_UNUSED,
|
|
SDL_Surface *canvas, SDL_Surface *last, int x, int y, SDL_Rect *update_rect)
|
|
{
|
|
spiral_cx = x;
|
|
spiral_cy = y;
|
|
|
|
api->stopsound();
|
|
spiral_drag(api, which, canvas, last, x, y, x + (spiral_thickness * MIN_RADIUS), y, update_rect);
|
|
|
|
spiral_has_dragged = 0;
|
|
}
|
|
|
|
void spiral_release(magic_api *api, int which,
|
|
SDL_Surface *canvas, SDL_Surface *last, int x, int y, SDL_Rect *update_rect)
|
|
{
|
|
float radius;
|
|
|
|
radius = sqrt(pow((x - spiral_cx), 2) + pow((y - spiral_cy), 2));
|
|
if (radius < spiral_thickness * MIN_RADIUS && spiral_has_dragged == 0)
|
|
x = spiral_cx + (spiral_thickness * MIN_RADIUS);
|
|
|
|
do_spiral(api, which, canvas, last, x, y, update_rect, 1);
|
|
}
|
|
|
|
void spiral_shutdown(magic_api *api ATTRIBUTE_UNUSED)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < NUM_TOOLS; i++)
|
|
if (spiral_snd[i] != NULL)
|
|
Mix_FreeChunk(spiral_snd[i]);
|
|
}
|
|
|
|
void spiral_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)
|
|
{
|
|
spiral_color = SDL_MapRGB(canvas->format, r, g, b);
|
|
}
|
|
|
|
int spiral_requires_colors(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
void spiral_switchin(magic_api *api ATTRIBUTE_UNUSED,
|
|
int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED, SDL_Surface *canvas ATTRIBUTE_UNUSED)
|
|
{
|
|
}
|
|
|
|
void spiral_switchout(magic_api *api ATTRIBUTE_UNUSED,
|
|
int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED, SDL_Surface *canvas ATTRIBUTE_UNUSED)
|
|
{
|
|
}
|
|
|
|
int spiral_modes(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
|
|
{
|
|
return MODE_PAINT;
|
|
}
|
|
|
|
|
|
Uint8 spiral_accepted_sizes(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED)
|
|
{
|
|
return 8;
|
|
}
|
|
|
|
Uint8 spiral_default_size(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED)
|
|
{
|
|
return 4;
|
|
}
|
|
|
|
void spiral_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 ATTRIBUTE_UNUSED, SDL_Rect *update_rect ATTRIBUTE_UNUSED)
|
|
{
|
|
spiral_thickness = size;
|
|
}
|