notgne2/tuxpaint-pencil-sharpener
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
tuxpaint-pencil-sharpener/magic/src/dither.c
Bill Kendrick 44d7d0ee5d Re-run indent.sh under GNU indent 2.2.13 
Slight change to its default behavior re: pointer variables
(before: "type * var"; now seems to prefer: "type *var").
2024-10-20 11:22:30 -07:00

467 lines
12 KiB
C
Raw Blame History

/* dither.c
A Magic tool for Tux Paint that turns (parts of) an image into
a black-and-white dithered representation.
(Using Atkinso dithering: https://en.wikipedia.org/wiki/Atkinson_dithering)
by Bill Kendrick <bill@newbreedsoftware.com>
Last updated: May 10, 2024
*/
/* Inclusion of header files */
/* ---------------------------------------------------------------------- */
#include <stdio.h>
#include <string.h>
#include <libintl.h>
#include "tp_magic_api.h"
#include "SDL_image.h"
#include "SDL_mixer.h"
enum
{
/* Use the chosen color for the non-white pixels */
TOOL_DITHER_VIA_COLOR,
/* Use the image's color (hue/saturation w/ low value) for the non-white pixels */
TOOL_DITHER_KEEP_COLOR,
NUM_TOOLS
};
char *dither_names[NUM_TOOLS] = {
gettext_noop("Dither"),
gettext_noop("Dither (Keep Color)"),
};
char *dither_descr[NUM_TOOLS][2] = {
{
gettext_noop("Click and drag to replace parts of your image with a dithered pattern of dots in your chosen color."),
gettext_noop("Click to replace your entire image with a dithered pattern of dots in your chosen color."),
},
{
gettext_noop
("Click and drag to replace parts of your image with a dithered pattern of dots using the picture's original colors."),
gettext_noop
("Click to replace your entire image with a dithered pattern of dots using the picture's original colors."),
},
};
char *dither_icon_filenames[NUM_TOOLS] = {
"dither.png",
"dither_keep_color.png",
};
char *dither_snd_filenames[NUM_TOOLS] = {
"dither.ogg",
"dither_keep_color.ogg",
};
Mix_Chunk *snd_effects[NUM_TOOLS];
#define DITHER_SIZE_COUNT 4
#define DITHER_SIZE_DEFAULT 2
#define DITHER_SIZE_SCALE 8
Uint8 dither_sizes[NUM_TOOLS];
Uint32 dither_white, dither_black, dither_color;
Uint8 *dither_touched;
float *dither_vals;
int dither_click_mode;
void dither_drag(magic_api * api, int which, SDL_Surface * canvas,
SDL_Surface * snapshot, int old_x, int old_y, int x, int y, SDL_Rect * update_rect);
void dither_line_callback(void *pointer, int which, SDL_Surface * canvas, SDL_Surface * snapshot, int x, int y);
Uint32 dither_api_version(void);
int dither_init(magic_api * api, Uint8 disabled_features, Uint8 complexity_level);
int dither_get_tool_count(magic_api * api);
SDL_Surface *dither_get_icon(magic_api * api, int which);
char *dither_get_name(magic_api * api, int which);
int dither_get_group(magic_api * api, int which);
int dither_get_order(int which);
char *dither_get_description(magic_api * api, int which, int mode);
int dither_requires_colors(magic_api * api, int which);
void dither_switchin(magic_api * api, int which, int mode, SDL_Surface * canvas);
void dither_switchout(magic_api * api, int which, int mode, SDL_Surface * canvas);
void dither_set_size(magic_api * api, int which, int mode,
SDL_Surface * canvas, SDL_Surface * snapshot, Uint8 size, SDL_Rect * update_rect);
void dither_set_color(magic_api * api, int which,
SDL_Surface * canvas, SDL_Surface * snapshot, Uint8 r, Uint8 g, Uint8 b, SDL_Rect * update_rect);
void dither_release(magic_api * api, int which,
SDL_Surface * canvas, SDL_Surface * snapshot, int x, int y, SDL_Rect * update_rect);
void dither_click(magic_api * api, int which, int mode,
SDL_Surface * canvas, SDL_Surface * snapshot, int x, int y, SDL_Rect * update_rect);
void dither_shutdown(magic_api * api);
Uint8 dither_default_size(magic_api * api, int which, int mode);
Uint8 dither_accepted_sizes(magic_api * api, int which, int mode);
int dither_modes(magic_api * api, int which);
Uint32 dither_api_version(void)
{
return (TP_MAGIC_API_VERSION);
}
int dither_init(magic_api *api, Uint8 disabled_features ATTRIBUTE_UNUSED, Uint8 complexity_level ATTRIBUTE_UNUSED)
{
int i;
char filename[1024];
for (i = 0; i < NUM_TOOLS; i++)
{
snprintf(filename, sizeof(filename), "%ssounds/magic/%s", api->data_directory, dither_snd_filenames[i]);
snd_effects[i] = Mix_LoadWAV(filename);
}
for (i = 0; i < NUM_TOOLS; i++)
{
dither_sizes[i] = DITHER_SIZE_DEFAULT * DITHER_SIZE_SCALE;
}
return (1);
}
int dither_get_tool_count(magic_api *api ATTRIBUTE_UNUSED)
{
return NUM_TOOLS;
}
SDL_Surface *dither_get_icon(magic_api *api, int which)
{
char filename[1024];
snprintf(filename, sizeof(filename), "%simages/magic/%s", api->data_directory, dither_icon_filenames[which]);
return (IMG_Load(filename));
}
char *dither_get_name(magic_api *api ATTRIBUTE_UNUSED, int which)
{
return strdup(gettext(dither_names[which]));
}
int dither_get_group(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
{
return MAGIC_TYPE_COLOR_FILTERS;
}
int dither_get_order(int which)
{
return 610 + which;
}
char *dither_get_description(magic_api *api ATTRIBUTE_UNUSED, int which, int mode)
{
if (mode == MODE_PAINT)
{
return strdup(gettext(dither_descr[which][0]));
}
else /* if (mode == MODE_FULLSCREEN) */
{
return strdup(gettext(dither_descr[which][1]));
}
}
int dither_requires_colors(magic_api *api ATTRIBUTE_UNUSED, int which)
{
if (which == TOOL_DITHER_VIA_COLOR)
return 1;
else
return 0;
}
int dither_modes(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
{
return MODE_PAINT | MODE_FULLSCREEN;
}
Uint8 dither_accepted_sizes(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED)
{
return DITHER_SIZE_COUNT;
}
Uint8 dither_default_size(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED)
{
return DITHER_SIZE_DEFAULT;
}
void dither_shutdown(magic_api *api ATTRIBUTE_UNUSED)
{
int i;
for (i = 0; i < NUM_TOOLS; i++)
{
if (snd_effects[i] != NULL)
{
Mix_FreeChunk(snd_effects[i]);
}
}
if (dither_touched == NULL)
{
free(dither_touched);
}
if (dither_vals == NULL)
{
free(dither_vals);
}
}
void
dither_click(magic_api *api, int which, int mode,
SDL_Surface *canvas, SDL_Surface *snapshot, int x, int y, SDL_Rect *update_rect)
{
int xx, yy;
Uint8 r, g, b;
dither_click_mode = mode;
for (yy = 0; yy < canvas->h; yy++)
{
for (xx = 0; xx < canvas->w; xx++)
{
if (mode == MODE_PAINT)
{
dither_touched[yy * canvas->w + xx] = 0;
}
else
{
dither_touched[yy * canvas->w + xx] = 1;
SDL_GetRGB(api->getpixel(snapshot, xx, yy), snapshot->format, &r, &g, &b);
dither_vals[yy * canvas->w + xx] =
(api->sRGB_to_linear(r) + api->sRGB_to_linear(g) + api->sRGB_to_linear(b)) / 3.0;
if (xx == 0)
{
api->update_progress_bar();
}
}
}
}
if (mode == MODE_PAINT)
{
dither_drag(api, which, canvas, snapshot, x, y, x, y, update_rect);
}
else
{
api->playsound(snd_effects[which], 128, 255);
dither_release(api, which, canvas, snapshot, x, y, update_rect);
}
}
void
dither_drag(magic_api *api, int which,
SDL_Surface *canvas, SDL_Surface *snapshot, int old_x, int old_y, int x, int y, SDL_Rect *update_rect)
{
int dither_size;
SDL_LockSurface(snapshot);
SDL_LockSurface(canvas);
api->line((void *)api, which, canvas, snapshot, old_x, old_y, x, y, 1, dither_line_callback);
SDL_UnlockSurface(canvas);
SDL_UnlockSurface(snapshot);
if (old_x > x)
{
int temp = old_x;
old_x = x;
x = temp;
}
if (old_y > y)
{
int temp = old_y;
old_y = y;
y = temp;
}
dither_size = dither_sizes[which];
update_rect->x = old_x - dither_size;
update_rect->y = old_y - dither_size;
update_rect->w = (x + dither_size) - update_rect->x + 1;
update_rect->h = (y + dither_size) - update_rect->y + 1;
api->playsound(snd_effects[which], (x * 255) / canvas->w, 255);
}
/*
* [ . P 0 1 ]
* [ 2 3 4 . ]
* [ . 5 . . ]
*/
int dither_x_pos[6] = { 1, 2, -1, 0, 1, 0 };
int dither_y_pos[6] = { 0, 0, 1, 1, 1, 2 };
void dither_release(magic_api *api, int which,
SDL_Surface *canvas, SDL_Surface *snapshot, int x, int y, SDL_Rect *update_rect)
{
Uint8 r, g, b;
float val, err, h, s, v;
int i, nx, ny;
for (y = 0; y < canvas->h; y++)
{
for (x = 0; x < canvas->w; x++)
{
if (dither_touched[y * canvas->w + x])
{
val = dither_vals[y * canvas->w + x];
if (val >= 0.5)
{
api->putpixel(canvas, x, y, dither_white);
err = val - 1.0;
}
else
{
if (which == TOOL_DITHER_VIA_COLOR)
{
api->putpixel(canvas, x, y, dither_color);
}
else if (which == TOOL_DITHER_KEEP_COLOR)
{
SDL_GetRGB(api->getpixel(snapshot, x, y), snapshot->format, &r, &g, &b);
if (r <= 32 && g <= 32 && b <= 32)
{
api->putpixel(canvas, x, y, dither_black);
}
else
{
api->rgbtohsv(r, g, b, &h, &s, &v);
api->hsvtorgb(floor(h / 2.0) * 2.0, min(s + 0.5, 1.0), v * 0.66, &r, &g, &b);
api->putpixel(canvas, x, y, SDL_MapRGB(canvas->format, r, g, b));
}
}
err = val;
}
/* Diffuse */
for (i = 0; i < 6; i++)
{
nx = x + dither_x_pos[i];
ny = y + dither_y_pos[i];
if (nx >= 0 && nx < canvas->w && ny >= 0 && ny < canvas->h)
{
if (dither_touched[ny * canvas->w + nx])
{
dither_vals[ny * canvas->w + nx] += (err / 8.0);
}
}
}
}
}
}
update_rect->x = 0;
update_rect->y = 0;
update_rect->w = canvas->w;
update_rect->h = canvas->h;
if (dither_click_mode == MODE_PAINT)
{
api->stopsound();
}
}
void dither_set_color(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED,
SDL_Surface *canvas, SDL_Surface *snapshot ATTRIBUTE_UNUSED,
Uint8 r, Uint8 g, Uint8 b, SDL_Rect *update_rect ATTRIBUTE_UNUSED)
{
if (r <= 240 || g <= 240 || b <= 240)
{
dither_color = SDL_MapRGB(canvas->format, r, g, b);
}
else
{
/* If the chosen color is very bright or white, fall back to black */
dither_color = SDL_MapRGB(canvas->format, 0, 0, 0);
}
}
void dither_set_size(magic_api *api ATTRIBUTE_UNUSED, int which, int mode ATTRIBUTE_UNUSED,
SDL_Surface *canvas ATTRIBUTE_UNUSED, SDL_Surface *snapshot ATTRIBUTE_UNUSED,
Uint8 size, SDL_Rect *update_rect ATTRIBUTE_UNUSED)
{
dither_sizes[which] = size * DITHER_SIZE_SCALE;
}
void dither_line_callback(void *pointer, int which, SDL_Surface *canvas, SDL_Surface *snapshot, int x, int y)
{
magic_api *api = (magic_api *) pointer;
int xx, yy, dither_size;
Uint8 r, g, b;
float val;
dither_size = dither_sizes[which];
if (dither_touched == NULL)
return;
/* Just do a simple threshold effect while interacting */
for (yy = -dither_size; yy < dither_size; yy++)
{
if (y + yy >= 0 && y + yy < canvas->h)
{
for (xx = -dither_size; xx < dither_size; xx++)
{
if (x + xx >= 0 && x + xx < canvas->w)
{
if (!dither_touched[(y + yy) * canvas->w + (x + xx)])
{
dither_touched[(y + yy) * canvas->w + (x + xx)] = 1;
SDL_GetRGB(api->getpixel(snapshot, x + xx, y + yy), snapshot->format, &r, &g, &b);
val = (api->sRGB_to_linear(r) + api->sRGB_to_linear(g) + api->sRGB_to_linear(b)) / 3.0;
dither_vals[(y + yy) * canvas->w + (x + xx)] = val;
api->putpixel(canvas, x + xx, y + yy, SDL_MapRGB(canvas->format, val * 255, val * 255, val * 255));
}
}
}
}
}
}
void dither_switchin(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED,
SDL_Surface *canvas)
{
if (dither_touched == NULL)
{
dither_touched = (Uint8 *) malloc(sizeof(Uint8) * canvas->h * canvas->w);
}
if (dither_vals == NULL)
{
dither_vals = (float *)malloc(sizeof(float) * canvas->h * canvas->w);
}
dither_white = SDL_MapRGB(canvas->format, 255, 255, 255);
dither_black = SDL_MapRGB(canvas->format, 0, 0, 0);
}
void dither_switchout(magic_api *api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED,
SDL_Surface *canvas ATTRIBUTE_UNUSED)
{
}
Reference in a new issue View git blame Copy permalink