notgne2/tuxpaint-pencil-sharpener
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

indent flower.c

Browse source
This commit is contained in:
Bill Kendrick 2017-10-15 11:44:48 -07:00
parent b11972979c
commit 8eff6a9930
1 changed files with 233 additions and 253 deletions
Download patch file Download diff file Expand all files Collapse all files

486
magic/src/flower.c
View file

@ -36,19 +36,21 @@
/* Our globals: */ /* Our globals: */
enum { SIDE_LEFT, SIDE_RIGHT }; enum
enum { LEAFSIDE_RIGHT_DOWN, { SIDE_LEFT, SIDE_RIGHT };
LEAFSIDE_LEFT_DOWN, enum
LEAFSIDE_RIGHT_UP, { LEAFSIDE_RIGHT_DOWN,
LEAFSIDE_LEFT_UP }; LEAFSIDE_LEFT_DOWN,
LEAFSIDE_RIGHT_UP,
LEAFSIDE_LEFT_UP
};
static Mix_Chunk * flower_click_snd, * flower_release_snd; static Mix_Chunk *flower_click_snd, *flower_release_snd;
static Uint8 flower_r, flower_g, flower_b; static Uint8 flower_r, flower_g, flower_b;
static int flower_min_x, flower_max_x, flower_bottom_x, flower_bottom_y; static int flower_min_x, flower_max_x, flower_bottom_x, flower_bottom_y;
static int flower_side_first; static int flower_side_first;
static int flower_side_decided; static int flower_side_decided;
static SDL_Surface * flower_base, * flower_leaf, * flower_petals, static SDL_Surface *flower_base, *flower_leaf, *flower_petals, *flower_petals_colorized;
* flower_petals_colorized;
/* Local function prototypes: */ /* Local function prototypes: */
@ -59,36 +61,31 @@ typedef struct
static void flower_drawbase(magic_api * api, SDL_Surface * canvas); static void flower_drawbase(magic_api * api, SDL_Surface * canvas);
static void flower_drawflower(magic_api * api, SDL_Surface * canvas, int x, int y); static void flower_drawflower(magic_api * api, SDL_Surface * canvas, int x, int y);
static Point2D flower_PointOnCubicBezier(Point2D* cp, float t); static Point2D flower_PointOnCubicBezier(Point2D * cp, float t);
static void flower_ComputeBezier(Point2D* cp, int numberOfPoints, Point2D* curve); static void flower_ComputeBezier(Point2D * cp, int numberOfPoints, Point2D * curve);
static void flower_colorize_petals(magic_api * api); static void flower_colorize_petals(magic_api * api);
Uint32 flower_api_version(void); Uint32 flower_api_version(void);
int flower_init(magic_api * api); int flower_init(magic_api * api);
int flower_get_tool_count(magic_api * api); int flower_get_tool_count(magic_api * api);
SDL_Surface * flower_get_icon(magic_api * api, int which); SDL_Surface *flower_get_icon(magic_api * api, int which);
char * flower_get_name(magic_api * api, int which); char *flower_get_name(magic_api * api, int which);
char * flower_get_description(magic_api * api, int which, int mode); char *flower_get_description(magic_api * api, int which, int mode);
static void flower_predrag(magic_api * api, SDL_Surface * canvas, static void flower_predrag(magic_api * api, SDL_Surface * canvas, SDL_Surface * last, int ox, int oy, int x, int y);
SDL_Surface * last, int ox, int oy, int x, int y);
void flower_drag(magic_api * api, int which, SDL_Surface * canvas, void flower_drag(magic_api * api, int which, SDL_Surface * canvas,
SDL_Surface * last, int ox, int oy, int x, int y, SDL_Surface * last, int ox, int oy, int x, int y, SDL_Rect * update_rect);
SDL_Rect * update_rect);
void flower_click(magic_api * api, int which, int mode, void flower_click(magic_api * api, int which, int mode,
SDL_Surface * canvas, SDL_Surface * last, SDL_Surface * canvas, SDL_Surface * last, int x, int y, SDL_Rect * update_rect);
int x, int y, SDL_Rect * update_rect);
void flower_release(magic_api * api, int which, void flower_release(magic_api * api, int which,
SDL_Surface * canvas, SDL_Surface * last, SDL_Surface * canvas, SDL_Surface * last, int x, int y, SDL_Rect * update_rect);
int x, int y, SDL_Rect * update_rect);
static void flower_drawflower(magic_api * api, SDL_Surface * canvas, int x, int y); static void flower_drawflower(magic_api * api, SDL_Surface * canvas, int x, int y);
static void flower_drawbase(magic_api * api, SDL_Surface * canvas); static void flower_drawbase(magic_api * api, SDL_Surface * canvas);
static void flower_drawstalk(magic_api * api, SDL_Surface * canvas, static void flower_drawstalk(magic_api * api, SDL_Surface * canvas,
int top_x, int top_y, int minx, int maxx, int top_x, int top_y, int minx, int maxx, int bottom_x, int bottom_y, int final);
int bottom_x, int bottom_y, int final);
void flower_shutdown(magic_api * api); void flower_shutdown(magic_api * api);
void flower_set_color(magic_api * api, Uint8 r, Uint8 g, Uint8 b); void flower_set_color(magic_api * api, Uint8 r, Uint8 g, Uint8 b);
int flower_requires_colors(magic_api * api, int which); int flower_requires_colors(magic_api * api, int which);
static Point2D flower_PointOnCubicBezier( Point2D* cp, float t ); static Point2D flower_PointOnCubicBezier(Point2D * cp, float t);
static void flower_ComputeBezier( Point2D* cp, int numberOfPoints, Point2D* curve ); static void flower_ComputeBezier(Point2D * cp, int numberOfPoints, Point2D * curve);
static void flower_colorize_petals(magic_api * api); static void flower_colorize_petals(magic_api * api);
void flower_switchin(magic_api * api, int which, int mode, SDL_Surface * canvas); void flower_switchin(magic_api * api, int which, int mode, SDL_Surface * canvas);
void flower_switchout(magic_api * api, int which, int mode, SDL_Surface * canvas); void flower_switchout(magic_api * api, int which, int mode, SDL_Surface * canvas);
@ -96,7 +93,10 @@ int flower_modes(magic_api * api, int which);
Uint32 flower_api_version(void) { return(TP_MAGIC_API_VERSION); } Uint32 flower_api_version(void)
{
return (TP_MAGIC_API_VERSION);
}
// No setup required: // No setup required:
@ -104,61 +104,55 @@ int flower_init(magic_api * api)
{ {
char fname[1024]; char fname[1024];
snprintf(fname, sizeof(fname), "%s/sounds/magic/flower_click.ogg", snprintf(fname, sizeof(fname), "%s/sounds/magic/flower_click.ogg", api->data_directory);
api->data_directory);
flower_click_snd = Mix_LoadWAV(fname); flower_click_snd = Mix_LoadWAV(fname);
snprintf(fname, sizeof(fname), "%s/sounds/magic/flower_release.ogg", snprintf(fname, sizeof(fname), "%s/sounds/magic/flower_release.ogg", api->data_directory);
api->data_directory);
flower_release_snd = Mix_LoadWAV(fname); flower_release_snd = Mix_LoadWAV(fname);
snprintf(fname, sizeof(fname), "%s/images/magic/flower_base.png", snprintf(fname, sizeof(fname), "%s/images/magic/flower_base.png", api->data_directory);
api->data_directory);
flower_base = IMG_Load(fname); flower_base = IMG_Load(fname);
snprintf(fname, sizeof(fname), "%s/images/magic/flower_leaf.png", snprintf(fname, sizeof(fname), "%s/images/magic/flower_leaf.png", api->data_directory);
api->data_directory);
flower_leaf = IMG_Load(fname); flower_leaf = IMG_Load(fname);
snprintf(fname, sizeof(fname), "%s/images/magic/flower_petals.png", snprintf(fname, sizeof(fname), "%s/images/magic/flower_petals.png", api->data_directory);
api->data_directory);
flower_petals = IMG_Load(fname); flower_petals = IMG_Load(fname);
return(1); return (1);
} }
// We have multiple tools: // We have multiple tools:
int flower_get_tool_count(magic_api * api ATTRIBUTE_UNUSED) int flower_get_tool_count(magic_api * api ATTRIBUTE_UNUSED)
{ {
return(1); return (1);
} }
// Load our icons: // Load our icons:
SDL_Surface * flower_get_icon(magic_api * api, int which ATTRIBUTE_UNUSED) SDL_Surface *flower_get_icon(magic_api * api, int which ATTRIBUTE_UNUSED)
{ {
char fname[1024]; char fname[1024];
snprintf(fname, sizeof(fname), "%s/images/magic/flower.png", snprintf(fname, sizeof(fname), "%s/images/magic/flower.png", api->data_directory);
api->data_directory);
return(IMG_Load(fname)); return (IMG_Load(fname));
} }
// Return our names, localized: // Return our names, localized:
char * flower_get_name(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED) char *flower_get_name(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
{ {
return(strdup(gettext_noop("Flower"))); return (strdup(gettext_noop("Flower")));
} }
// Return our descriptions, localized: // Return our descriptions, localized:
char * flower_get_description(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED) char *flower_get_description(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED)
{ {
return(strdup(gettext_noop("Click and drag to draw a flower stalk. Let go to finish the flower."))); return (strdup(gettext_noop("Click and drag to draw a flower stalk. Let go to finish the flower.")));
} }
// Affect the canvas on drag: // Affect the canvas on drag:
static void flower_predrag(magic_api * api ATTRIBUTE_UNUSED, SDL_Surface * canvas ATTRIBUTE_UNUSED, static void flower_predrag(magic_api * api ATTRIBUTE_UNUSED, SDL_Surface * canvas ATTRIBUTE_UNUSED,
SDL_Surface * last ATTRIBUTE_UNUSED, int ox, int oy, int x, int y) SDL_Surface * last ATTRIBUTE_UNUSED, int ox, int oy, int x, int y)
{ {
if (x < flower_min_x) if (x < flower_min_x)
flower_min_x = x; flower_min_x = x;
@ -177,23 +171,22 @@ static void flower_predrag(magic_api * api ATTRIBUTE_UNUSED, SDL_Surface * canva
// Determine which way to bend first: // Determine which way to bend first:
// //
if (flower_side_decided == 0) if (flower_side_decided == 0)
{
if (x < flower_bottom_x - 10)
{ {
flower_side_first = SIDE_LEFT; if (x < flower_bottom_x - 10)
flower_side_decided = 1; {
flower_side_first = SIDE_LEFT;
flower_side_decided = 1;
}
else if (x > flower_bottom_x + 10)
{
flower_side_first = SIDE_RIGHT;
flower_side_decided = 1;
}
} }
else if (x > flower_bottom_x + 10)
{
flower_side_first = SIDE_RIGHT;
flower_side_decided = 1;
}
}
} }
void flower_drag(magic_api * api, int which ATTRIBUTE_UNUSED, SDL_Surface * canvas, void flower_drag(magic_api * api, int which ATTRIBUTE_UNUSED, SDL_Surface * canvas,
SDL_Surface * last, int ox, int oy, int x, int y, SDL_Surface * last, int ox, int oy, int x, int y, SDL_Rect * update_rect)
SDL_Rect * update_rect)
{ {
flower_predrag(api, canvas, last, ox, oy, x, y); flower_predrag(api, canvas, last, ox, oy, x, y);
@ -206,21 +199,19 @@ void flower_drag(magic_api * api, int which ATTRIBUTE_UNUSED, SDL_Surface * canv
/* Draw the base and the stalk (low-quality) for now: */ /* Draw the base and the stalk (low-quality) for now: */
flower_drawstalk(api, canvas, flower_drawstalk(api, canvas,
x, y, flower_min_x, flower_max_x, x, y, flower_min_x, flower_max_x, flower_bottom_x, flower_bottom_y, !(api->button_down()));
flower_bottom_x, flower_bottom_y, !(api->button_down()));
flower_drawbase(api, canvas); flower_drawbase(api, canvas);
update_rect->x = 0; update_rect->x = 0;
update_rect->y = 0; update_rect->y = 0;
update_rect->w = canvas->w; update_rect->w = canvas->w;
update_rect->h = canvas->h; update_rect->h = canvas->h;
} }
// Affect the canvas on click: // Affect the canvas on click:
void flower_click(magic_api * api, int which, int mode ATTRIBUTE_UNUSED, void flower_click(magic_api * api, int which, int mode ATTRIBUTE_UNUSED,
SDL_Surface * canvas, SDL_Surface * last, SDL_Surface * canvas, SDL_Surface * last, int x, int y, SDL_Rect * update_rect)
int x, int y, SDL_Rect * update_rect)
{ {
flower_min_x = x; flower_min_x = x;
flower_max_x = x; flower_max_x = x;
@ -231,14 +222,13 @@ void flower_click(magic_api * api, int which, int mode ATTRIBUTE_UNUSED,
flower_side_first = SIDE_LEFT; flower_side_first = SIDE_LEFT;
flower_drag(api, which, canvas, last, x, y, x, y, update_rect); flower_drag(api, which, canvas, last, x, y, x, y, update_rect);
api->playsound(flower_click_snd, (x * 255) / canvas->w, 255); api->playsound(flower_click_snd, (x * 255) / canvas->w, 255);
} }
// Affect the canvas on release: // Affect the canvas on release:
void flower_release(magic_api * api, int which ATTRIBUTE_UNUSED, void flower_release(magic_api * api, int which ATTRIBUTE_UNUSED,
SDL_Surface * canvas, SDL_Surface * last, SDL_Surface * canvas, SDL_Surface * last, int x, int y, SDL_Rect * update_rect)
int x, int y, SDL_Rect * update_rect)
{ {
/* Don't let flower be too low compared to base: */ /* Don't let flower be too low compared to base: */
@ -250,7 +240,7 @@ void flower_release(magic_api * api, int which ATTRIBUTE_UNUSED,
flower_predrag(api, canvas, last, x, y, x, y); flower_predrag(api, canvas, last, x, y, x, y);
/* Erase any old stuff: */ /* Erase any old stuff: */
SDL_BlitSurface(last, NULL, canvas, NULL); SDL_BlitSurface(last, NULL, canvas, NULL);
@ -258,15 +248,13 @@ void flower_release(magic_api * api, int which ATTRIBUTE_UNUSED,
/* Draw high-quality stalk, and flower: */ /* Draw high-quality stalk, and flower: */
flower_drawstalk(api, canvas, flower_drawstalk(api, canvas, x, y, flower_min_x, flower_max_x, flower_bottom_x, flower_bottom_y, 1);
x, y, flower_min_x, flower_max_x,
flower_bottom_x, flower_bottom_y, 1);
flower_drawflower(api, canvas, x, y); flower_drawflower(api, canvas, x, y);
flower_drawbase(api, canvas); flower_drawbase(api, canvas);
update_rect->x = 0; update_rect->x = 0;
update_rect->y = 0; update_rect->y = 0;
update_rect->w = canvas->w; update_rect->w = canvas->w;
@ -297,11 +285,10 @@ static void flower_drawbase(magic_api * api ATTRIBUTE_UNUSED, SDL_Surface * canv
} }
static void flower_drawstalk(magic_api * api ATTRIBUTE_UNUSED, SDL_Surface * canvas, static void flower_drawstalk(magic_api * api ATTRIBUTE_UNUSED, SDL_Surface * canvas,
int top_x, int top_y, int minx, int maxx, int top_x, int top_y, int minx, int maxx, int bottom_x, int bottom_y, int final)
int bottom_x, int bottom_y, int final)
{ {
Point2D control_points[4]; Point2D control_points[4];
Point2D * curve; Point2D *curve;
int i, n_points; int i, n_points;
int left, right; int left, right;
SDL_Rect dest, src; SDL_Rect dest, src;
@ -315,22 +302,22 @@ static void flower_drawstalk(magic_api * api ATTRIBUTE_UNUSED, SDL_Surface * can
control_points[0].y = top_y; control_points[0].y = top_y;
if (flower_side_first == SIDE_LEFT) if (flower_side_first == SIDE_LEFT)
{ {
control_points[1].x = minx; control_points[1].x = minx;
control_points[2].x = maxx; control_points[2].x = maxx;
} }
else else
{ {
control_points[1].x = maxx; control_points[1].x = maxx;
control_points[2].x = minx; control_points[2].x = minx;
} }
control_points[1].y = ((bottom_y - top_y) / 3) + top_y; control_points[1].y = ((bottom_y - top_y) / 3) + top_y;
control_points[2].y = (((bottom_y - top_y) / 3) * 2) + top_y; control_points[2].y = (((bottom_y - top_y) / 3) * 2) + top_y;
control_points[3].x = bottom_x; control_points[3].x = bottom_x;
control_points[3].y = bottom_y; control_points[3].y = bottom_y;
if (final == 0) if (final == 0)
n_points = 8; n_points = 8;
else else
@ -342,129 +329,128 @@ static void flower_drawstalk(magic_api * api ATTRIBUTE_UNUSED, SDL_Surface * can
/* Draw the curve: */ /* Draw the curve: */
for (i = 0; i < n_points - 1; i++) for (i = 0; i < n_points - 1; i++)
{
if (final == 0)
{ {
dest.x = curve[i].x; if (final == 0)
dest.y = curve[i].y;
dest.w = 2;
dest.h = 2;
}
else
{
left = min(curve[i].x, curve[i + 1].x);
right = max(curve[i].x, curve[i + 1].x);
dest.x = left;
dest.y = curve[i].y;
dest.w = right - left + 1;
dest.h = 2;
}
SDL_FillRect(canvas, &dest, SDL_MapRGB(canvas->format, 0, 128, 0));
/* When we're done (final render), we can add some random leaves: */
if (final && i > 32 && i < n_points - 32 && (i % 16) == 0 &&
(rand() % 5) > 0)
{
/* Check for hard left/right angles: */
side = -1;
if (curve[i - 2].x - curve[i + 2].x > 5)
{
/* Hard lower-left-to-upper-right (/),
stick either a left-upward or right-downward facing leaf */
if (rand() % 10 < 5)
side = LEAFSIDE_LEFT_UP;
else
side = LEAFSIDE_RIGHT_DOWN;
}
else if (curve[i - 2].x - curve[i + 2].x < -5)
{
/* Hard lower-right-to-upper-left (\)
stick either a right-upward or left-downward facing leaf */
if (rand() % 10 < 5)
side = LEAFSIDE_LEFT_DOWN;
else
side = LEAFSIDE_RIGHT_UP;
}
else if (abs(curve[i - 2].x - curve[i + 2].x) < 5)
{
/* Mostly up; stick left- or right-downward: */
if (rand() % 10 < 5)
side = LEAFSIDE_LEFT_DOWN;
else
side = LEAFSIDE_RIGHT_DOWN;
}
/* Draw the appropriately-oriented leaf, if any: */
if (side == LEAFSIDE_RIGHT_DOWN)
{
dest.x = curve[i].x;
dest.y = curve[i].y;
SDL_BlitSurface(flower_leaf, NULL, canvas, &dest);
}
else if (side == LEAFSIDE_LEFT_DOWN)
{
for (xx = 0; xx < flower_leaf->w; xx++)
{ {
src.x = xx;
src.y = 0;
src.w = 1;
src.h = flower_leaf->h;
dest.x = curve[i].x - xx;
dest.y = curve[i].y;
SDL_BlitSurface(flower_leaf, &src, canvas, &dest);
}
}
else if (side == LEAFSIDE_RIGHT_UP)
{
for (yy = 0; yy < flower_leaf->h; yy++)
{
src.x = 0;
src.y = yy;
src.w = flower_leaf->w;
src.h = 1;
dest.x = curve[i].x; dest.x = curve[i].x;
dest.y = curve[i].y - yy; dest.y = curve[i].y;
dest.w = 2;
SDL_BlitSurface(flower_leaf, &src, canvas, &dest); dest.h = 2;
} }
} else
else if (side == LEAFSIDE_LEFT_UP)
{
for (xx = 0; xx < flower_leaf->w; xx++)
{ {
for (yy = 0; yy < flower_leaf->h; yy++) left = min(curve[i].x, curve[i + 1].x);
{ right = max(curve[i].x, curve[i + 1].x);
src.x = xx;
src.y = yy;
src.w = 1;
src.h = 1;
dest.x = curve[i].x - xx; dest.x = left;
dest.y = curve[i].y - yy; dest.y = curve[i].y;
dest.w = right - left + 1;
SDL_BlitSurface(flower_leaf, &src, canvas, &dest); dest.h = 2;
} }
SDL_FillRect(canvas, &dest, SDL_MapRGB(canvas->format, 0, 128, 0));
/* When we're done (final render), we can add some random leaves: */
if (final && i > 32 && i < n_points - 32 && (i % 16) == 0 && (rand() % 5) > 0)
{
/* Check for hard left/right angles: */
side = -1;
if (curve[i - 2].x - curve[i + 2].x > 5)
{
/* Hard lower-left-to-upper-right (/),
stick either a left-upward or right-downward facing leaf */
if (rand() % 10 < 5)
side = LEAFSIDE_LEFT_UP;
else
side = LEAFSIDE_RIGHT_DOWN;
}
else if (curve[i - 2].x - curve[i + 2].x < -5)
{
/* Hard lower-right-to-upper-left (\)
stick either a right-upward or left-downward facing leaf */
if (rand() % 10 < 5)
side = LEAFSIDE_LEFT_DOWN;
else
side = LEAFSIDE_RIGHT_UP;
}
else if (abs(curve[i - 2].x - curve[i + 2].x) < 5)
{
/* Mostly up; stick left- or right-downward: */
if (rand() % 10 < 5)
side = LEAFSIDE_LEFT_DOWN;
else
side = LEAFSIDE_RIGHT_DOWN;
}
/* Draw the appropriately-oriented leaf, if any: */
if (side == LEAFSIDE_RIGHT_DOWN)
{
dest.x = curve[i].x;
dest.y = curve[i].y;
SDL_BlitSurface(flower_leaf, NULL, canvas, &dest);
}
else if (side == LEAFSIDE_LEFT_DOWN)
{
for (xx = 0; xx < flower_leaf->w; xx++)
{
src.x = xx;
src.y = 0;
src.w = 1;
src.h = flower_leaf->h;
dest.x = curve[i].x - xx;
dest.y = curve[i].y;
SDL_BlitSurface(flower_leaf, &src, canvas, &dest);
}
}
else if (side == LEAFSIDE_RIGHT_UP)
{
for (yy = 0; yy < flower_leaf->h; yy++)
{
src.x = 0;
src.y = yy;
src.w = flower_leaf->w;
src.h = 1;
dest.x = curve[i].x;
dest.y = curve[i].y - yy;
SDL_BlitSurface(flower_leaf, &src, canvas, &dest);
}
}
else if (side == LEAFSIDE_LEFT_UP)
{
for (xx = 0; xx < flower_leaf->w; xx++)
{
for (yy = 0; yy < flower_leaf->h; yy++)
{
src.x = xx;
src.y = yy;
src.w = 1;
src.h = 1;
dest.x = curve[i].x - xx;
dest.y = curve[i].y - yy;
SDL_BlitSurface(flower_leaf, &src, canvas, &dest);
}
}
}
} }
}
} }
}
free(curve); free(curve);
} }
@ -518,32 +504,32 @@ cp[3] is the end point, or P3 in the above diagram
t is the parameter value, 0 <= t <= 1 t is the parameter value, 0 <= t <= 1
*/ */
static Point2D flower_PointOnCubicBezier( Point2D* cp, float t ) static Point2D flower_PointOnCubicBezier(Point2D * cp, float t)
{ {
float ax, bx, cx; float ax, bx, cx;
float ay, by, cy; float ay, by, cy;
float tSquared, tCubed; float tSquared, tCubed;
Point2D result; Point2D result;
/* calculate the polynomial coefficients */ /* calculate the polynomial coefficients */
cx = 3.0 * (cp[1].x - cp[0].x); cx = 3.0 * (cp[1].x - cp[0].x);
bx = 3.0 * (cp[2].x - cp[1].x) - cx; bx = 3.0 * (cp[2].x - cp[1].x) - cx;
ax = cp[3].x - cp[0].x - cx - bx; ax = cp[3].x - cp[0].x - cx - bx;
cy = 3.0 * (cp[1].y - cp[0].y); cy = 3.0 * (cp[1].y - cp[0].y);
by = 3.0 * (cp[2].y - cp[1].y) - cy; by = 3.0 * (cp[2].y - cp[1].y) - cy;
ay = cp[3].y - cp[0].y - cy - by; ay = cp[3].y - cp[0].y - cy - by;
/* calculate the curve point at parameter value t */ /* calculate the curve point at parameter value t */
tSquared = t * t; tSquared = t * t;
tCubed = tSquared * t; tCubed = tSquared * t;
result.x = (ax * tCubed) + (bx * tSquared) + (cx * t) + cp[0].x; result.x = (ax * tCubed) + (bx * tSquared) + (cx * t) + cp[0].x;
result.y = (ay * tCubed) + (by * tSquared) + (cy * t) + cp[0].y; result.y = (ay * tCubed) + (by * tSquared) + (cy * t) + cp[0].y;
return result; return result;
} }
/* /*
@ -553,15 +539,15 @@ static Point2D flower_PointOnCubicBezier( Point2D* cp, float t )
<sizeof(Point2D) numberOfPoints> <sizeof(Point2D) numberOfPoints>
*/ */
static void flower_ComputeBezier( Point2D* cp, int numberOfPoints, Point2D* curve ) static void flower_ComputeBezier(Point2D * cp, int numberOfPoints, Point2D * curve)
{ {
float dt; float dt;
int i; int i;
dt = 1.0 / ( numberOfPoints - 1 ); dt = 1.0 / (numberOfPoints - 1);
for( i = 0; i < numberOfPoints; i++) for (i = 0; i < numberOfPoints; i++)
curve[i] = flower_PointOnCubicBezier( cp, i*dt ); curve[i] = flower_PointOnCubicBezier(cp, i * dt);
} }
@ -576,9 +562,7 @@ static void flower_colorize_petals(magic_api * api)
/* Create a surface to render into: */ /* Create a surface to render into: */
amask = ~(flower_petals->format->Rmask | amask = ~(flower_petals->format->Rmask | flower_petals->format->Gmask | flower_petals->format->Bmask);
flower_petals->format->Gmask |
flower_petals->format->Bmask);
flower_petals_colorized = flower_petals_colorized =
SDL_CreateRGBSurface(SDL_SWSURFACE, SDL_CreateRGBSurface(SDL_SWSURFACE,
@ -586,8 +570,7 @@ static void flower_colorize_petals(magic_api * api)
flower_petals->h, flower_petals->h,
flower_petals->format->BitsPerPixel, flower_petals->format->BitsPerPixel,
flower_petals->format->Rmask, flower_petals->format->Rmask,
flower_petals->format->Gmask, flower_petals->format->Gmask, flower_petals->format->Bmask, amask);
flower_petals->format->Bmask, amask);
/* Render the new petals: */ /* Render the new petals: */
@ -595,40 +578,37 @@ static void flower_colorize_petals(magic_api * api)
SDL_LockSurface(flower_petals_colorized); SDL_LockSurface(flower_petals_colorized);
for (y = 0; y < flower_petals->h; y++) for (y = 0; y < flower_petals->h; y++)
{
for (x = 0; x < flower_petals->w; x++)
{ {
SDL_GetRGBA(api->getpixel(flower_petals, x, y), for (x = 0; x < flower_petals->w; x++)
flower_petals->format, &r, &g, &b, &a); {
SDL_GetRGBA(api->getpixel(flower_petals, x, y), flower_petals->format, &r, &g, &b, &a);
api->putpixel(flower_petals_colorized, x, y, api->putpixel(flower_petals_colorized, x, y,
SDL_MapRGBA(flower_petals_colorized->format, SDL_MapRGBA(flower_petals_colorized->format, flower_r, flower_g, flower_b, a));
flower_r, flower_g, flower_b, a));
if (api->in_circle((x - flower_petals->w / 2), if (api->in_circle((x - flower_petals->w / 2), (y - flower_petals->h / 2), 8))
(y - flower_petals->h / 2), {
8)) api->putpixel(flower_petals_colorized, x, y,
{ SDL_MapRGBA(flower_petals_colorized->format, 0xFF, 0xFF, 0x00, a));
api->putpixel(flower_petals_colorized, x, y, }
SDL_MapRGBA(flower_petals_colorized->format, }
0xFF, 0xFF, 0x00, a));
}
} }
}
SDL_UnlockSurface(flower_petals_colorized); SDL_UnlockSurface(flower_petals_colorized);
SDL_UnlockSurface(flower_petals); SDL_UnlockSurface(flower_petals);
} }
void flower_switchin(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED, SDL_Surface * canvas ATTRIBUTE_UNUSED) void flower_switchin(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED,
SDL_Surface * canvas ATTRIBUTE_UNUSED)
{ {
} }
void flower_switchout(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED, SDL_Surface * canvas ATTRIBUTE_UNUSED) void flower_switchout(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED,
SDL_Surface * canvas ATTRIBUTE_UNUSED)
{ {
} }
int flower_modes(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED) int flower_modes(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
{ {
return(MODE_PAINT_WITH_PREVIEW); return (MODE_PAINT_WITH_PREVIEW);
} }