xref: /dports/games/tuxpaint/tuxpaint-0.9.26/magic/src/fold.c

/*
 * Folds the picture down from the corners.
 *
 * Last updated: 2019-08-29
 */

//optimized version soon :)
//when "folding" same corner many times it gives strange results. Now it's allowed. Let me know
//if you think it shouldn't be.

//sound playing needs fixing.

#include "tp_magic_api.h"
#include "SDL_image.h"
#include "SDL_mixer.h"

#define FOLD_LEN 80

int right_arm_x, right_arm_y, left_arm_x, left_arm_y;
int fold_ox, fold_oy;
int fold_x, fold_y;
Uint8 fold_shadow_value;
Uint8 corner;
Mix_Chunk *fold_snd;
Uint8 fold_r, fold_g, fold_b;
Uint32 fold_color;
SDL_Surface *fold_surface_src, *fold_surface_dst;


void fold_draw(magic_api * api, int which,
               SDL_Surface * canvas, SDL_Surface * snapshot, int x, int y, SDL_Rect * update_rect);
static void fold_erase(void *ptr, int which, SDL_Surface * canvas, SDL_Surface * last, int x, int y);
void translate_coords(SDL_Surface * canvas, int angle);
SDL_Surface *rotate(magic_api * api, SDL_Surface * canvas, int angle);
void fold_draw(magic_api * api, int which,
               SDL_Surface * canvas, SDL_Surface * snapshot, int x, int y, SDL_Rect * update_rect);
static void fold_print_line(void *ptr, int which, SDL_Surface * canvas, SDL_Surface * last, int x, int y);
static void fold_print_dark_line(void *ptr, int which, SDL_Surface * canvas, SDL_Surface * last, int x, int y);
void translate_xy(SDL_Surface * canvas, int x, int y, int *a, int *b, int rotation);
Uint32 fold_api_version(void);
void fold_set_color(magic_api * api, Uint8 r, Uint8 g, Uint8 b);
int fold_init(magic_api * api);
int fold_get_tool_count(magic_api * api);
SDL_Surface *fold_get_icon(magic_api * api, int which);
char *fold_get_name(magic_api * api, int which);
char *fold_get_description(magic_api * api, int which, int mode);
int fold_requires_colors(magic_api * api, int which);
void fold_release(magic_api * api, int which,
                  SDL_Surface * canvas, SDL_Surface * snapshot, int x, int y, SDL_Rect * update_rect);
void fold_shutdown(magic_api * api);
void fold_click(magic_api * ptr, int which, int mode,
                SDL_Surface * canvas, SDL_Surface * snapshot, int x, int y, SDL_Rect * update_rect);
void fold_preview(magic_api * api, int which, SDL_Surface * canvas,
                  SDL_Surface * snapshot, int ox, int oy, int x, int y, SDL_Rect * update_rect);
int fold_modes(magic_api * api, int which);

//                              Housekeeping functions

void fold_drag(magic_api * api, int which, SDL_Surface * canvas,
               SDL_Surface * snapshot, int ox, int oy, int x, int y, SDL_Rect * update_rect);
void fold_switchin(magic_api * api, int which, int mode, SDL_Surface * canvas);
inline Uint8 fold_what_corner(int x, int y, SDL_Surface * canvas);
void fold_switchout(magic_api * api, int which, int mode, SDL_Surface * canvas);

Uint32 fold_api_version(void)
{
  return (TP_MAGIC_API_VERSION);
}

void fold_set_color(magic_api * api ATTRIBUTE_UNUSED, Uint8 r, Uint8 g, Uint8 b)        //get the colors from API and store it in structure
{
  fold_r = r;
  fold_g = g;
  fold_b = b;
}

int fold_init(magic_api * api)
{
  char fname[1024];

  snprintf(fname, sizeof(fname), "%s/sounds/magic/fold.wav", api->data_directory);
  fold_snd = Mix_LoadWAV(fname);

  return (1);
}

int fold_get_tool_count(magic_api * api ATTRIBUTE_UNUSED)
{
  return 1;
}

SDL_Surface *fold_get_icon(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
{
  char fname[1024];

  snprintf(fname, sizeof(fname), "%s/images/magic/fold.png", api->data_directory);

  return (IMG_Load(fname));
}

char *fold_get_name(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
{
  return (gettext_noop("Fold"));
}

char *fold_get_description(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED)
{
  return strdup(gettext_noop("Choose a background color and click to turn the corner of the page over."));
}

int fold_requires_colors(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
{
  return 1;
}                               //selected color will be a "backpage" color


static void fold_shadow(void *ptr, int which ATTRIBUTE_UNUSED, SDL_Surface * canvas, SDL_Surface * temp, int x, int y)
{
  magic_api *api = (magic_api *) ptr;
  Uint8 r, g, b, a;

  SDL_GetRGBA(api->getpixel(temp, x, y), temp->format, &r, &g, &b, &a);
  api->putpixel(canvas, x, y, SDL_MapRGBA(canvas->format,
                                          max(r - 160 + fold_shadow_value * 4, 0), max(g - 160 + fold_shadow_value * 4,
                                                                                       0),
                                          max(b - 160 + fold_shadow_value * 4, 0), a));
}

void fold_draw(magic_api * api, int which,
               SDL_Surface * canvas, SDL_Surface * snapshot, int x, int y, SDL_Rect * update_rect ATTRIBUTE_UNUSED)
{
  float right_step_x, right_step_y, left_step_x, left_step_y;
  float dist_x, dist_y;
  int left_y, right_x;
  float w, h;
  SDL_Surface *temp;

  temp = SDL_CreateRGBSurface(SDL_ANYFORMAT, canvas->w, canvas->h, canvas->format->BitsPerPixel,
                              canvas->format->Rmask, canvas->format->Gmask, canvas->format->Bmask,
                              canvas->format->Amask);
  SDL_BlitSurface(canvas, 0, temp, 0);

  right_step_x = (float)(x - left_arm_x) / (float)(left_arm_x - fold_ox);
  right_step_y = (float)(y - left_arm_y) / (float)(left_arm_x - fold_ox);
  left_step_x = (float)(x - right_arm_x) / (float)(right_arm_y - fold_oy);
  left_step_y = (float)(y - right_arm_y) / (float)(right_arm_y - fold_oy);

  left_y = (float)right_arm_y / left_arm_x * (left_arm_x - canvas->w);
  right_x = (float)left_arm_x / right_arm_y * (right_arm_y - canvas->h);

  for (w = 0; w < canvas->w; w += 0.5)
    {
      for (h = 0; h < canvas->h; h += 0.5)
        {
          dist_x = right_step_x * w + left_step_x * h;
          dist_y = right_step_y * w + left_step_y * h;
          api->putpixel(canvas, x - dist_x, y - dist_y, api->getpixel(temp, w, h));
        }
    }

  // Erasing the triangle.
  // The 1 pixel in plus  is a workaround for api-line not getting the end in some lines.
  if (left_arm_x > canvas->w)
    {
      for (h = 0; h <= right_arm_y; h++)
        api->line((void *)api, which, canvas, snapshot, canvas->w, left_y - h, -1, right_arm_y - h, 1, fold_erase);
    }
  else if (right_arm_y > canvas->h)
    {
      for (w = 0; w <= left_arm_x; w++)
        api->line((void *)api, which, canvas, snapshot, left_arm_x - w, 0, right_x - w, canvas->h + 1, 1, fold_erase);
    }
  else
    for (w = 0; w <= min(left_arm_x, right_arm_y); w++) // The -1 values are because api->line
      api->line((void *)api, which, canvas, snapshot, left_arm_x - w, 0, -1, right_arm_y - w, 1, fold_erase);

  SDL_BlitSurface(canvas, 0, temp, 0);

  // Shadows
  if (left_arm_x > canvas->w)
    {
      for (fold_shadow_value = 0; fold_shadow_value < 40; fold_shadow_value += 1)
        api->line((void *)api, which, canvas, temp, canvas->w, left_y - fold_shadow_value, 0,
                  right_arm_y - fold_shadow_value, 1, fold_shadow);

    }
  else if (right_arm_y > canvas->h)
    {
      for (fold_shadow_value = 0; fold_shadow_value < 40; fold_shadow_value += 1)
        api->line((void *)api, which, canvas, temp, left_arm_x - fold_shadow_value, 0, right_x - fold_shadow_value,
                  canvas->h, 1, fold_shadow);

    }

  else
    for (fold_shadow_value = 0; fold_shadow_value < 40; fold_shadow_value += 1)
      api->line((void *)api, which, canvas, temp, left_arm_x - fold_shadow_value, 0, 0, right_arm_y - fold_shadow_value,
                1, fold_shadow);

  SDL_BlitSurface(canvas, 0, temp, 0);

  for (fold_shadow_value = 0; fold_shadow_value < 40; fold_shadow_value += 1)
    {
      if (fold_shadow_value * left_step_x > x || fold_shadow_value * right_step_y > y)
        break;

      dist_x = fold_shadow_value * (right_step_x + left_step_x);
      dist_y = fold_shadow_value * (right_step_y + left_step_y);
      api->line((void *)api, which, canvas, temp, left_arm_x + fold_shadow_value * right_step_x,
                fold_shadow_value * right_step_y, fold_shadow_value * left_step_x,
                right_arm_y + fold_shadow_value * left_step_y, 1, fold_shadow);
    }

  api->line((void *)api, which, canvas, snapshot, x, y, right_arm_x, right_arm_y, 1, fold_print_line);
  api->line((void *)api, which, canvas, snapshot, x, y, left_arm_x, left_arm_y, 1, fold_print_line);
  api->line((void *)api, which, canvas, snapshot, left_arm_x, left_arm_y, right_arm_x, right_arm_y, 1,
            fold_print_dark_line);

}

SDL_Surface *rotate(magic_api * api, SDL_Surface * canvas, int angle)
{
  SDL_Surface *temp;
  int x, y;
  int a, b;

  if (angle == 180)
    temp = SDL_CreateRGBSurface(SDL_ANYFORMAT, canvas->w, canvas->h, canvas->format->BitsPerPixel,
                                canvas->format->Rmask, canvas->format->Gmask, canvas->format->Bmask,
                                canvas->format->Amask);
  else
    temp = SDL_CreateRGBSurface(SDL_ANYFORMAT, canvas->h, canvas->w, canvas->format->BitsPerPixel,
                                canvas->format->Rmask, canvas->format->Gmask, canvas->format->Bmask,
                                canvas->format->Amask);

  switch (angle)
    {
    case 90:
      for (x = 0; x < canvas->w; x++)
        for (y = 0; y < canvas->h; y++)
          {
            translate_xy(canvas, x, y, &a, &b, 90);
            api->putpixel(temp, a, b, api->getpixel(canvas, x, y));
          }
      break;

    case 180:
      //      printf("%i, %i\n",temp,canvas);
      for (x = 0; x < canvas->w; x++)
        for (y = 0; y < canvas->h; y++)
          {
            translate_xy(canvas, x, y, &a, &b, 180);
            api->putpixel(temp, a, b, api->getpixel(canvas, x, y));
          }
      break;

    case 270:
      for (x = 0; x < canvas->w; x++)
        for (y = 0; y < canvas->h; y++)
          {
            translate_xy(canvas, x, y, &a, &b, 270);
            api->putpixel(temp, a, b, api->getpixel(canvas, x, y));
          }
      break;
    }
  return temp;
}

void translate_coords(SDL_Surface * canvas, int angle)
{
  int a, b;

  switch (angle)
    {
    case 90:
      translate_xy(canvas, right_arm_x, right_arm_y, &a, &b, 90);
      right_arm_x = a;
      right_arm_y = b;
      translate_xy(canvas, left_arm_x, left_arm_y, &a, &b, 90);
      left_arm_x = a;
      left_arm_y = b;

      break;
    case 180:
      right_arm_x = canvas->w - 1 - right_arm_x;
      right_arm_y = canvas->h - 1 - right_arm_y;
      left_arm_x = canvas->w - 1 - left_arm_x;
      left_arm_y = canvas->h - 1 - left_arm_y;
      break;
    case 270:
      translate_xy(canvas, right_arm_x, right_arm_y, &a, &b, 270);
      right_arm_x = a;
      right_arm_y = b;
      translate_xy(canvas, left_arm_x, left_arm_y, &a, &b, 270);
      left_arm_x = a;
      left_arm_y = b;
      break;
    }
}

void translate_xy(SDL_Surface * canvas, int x, int y, int *a, int *b, int rotation)
{
  switch (rotation)
    {
    case 90:
      *a = y;
      *b = canvas->w - 1 - x;
      break;
    case 180:
      *a = canvas->w - 1 - x;
      *b = canvas->h - 1 - y;
      break;
    case 270:
      *a = canvas->h - 1 - y;
      *b = x;
      break;
    }
}

void fold_release(magic_api * api, int which,
                  SDL_Surface * canvas, SDL_Surface * snapshot, int x, int y, SDL_Rect * update_rect)
{
  int a, b;
  SDL_Surface *temp, *temp2;

  x = fold_x;
  y = fold_y;
  fold_ox = fold_oy = 0;
  SDL_BlitSurface(snapshot, 0, canvas, 0);
  switch (corner)
    {
    case 1:
      translate_xy(canvas, x, y, &a, &b, 90);
      translate_coords(canvas, 90);
      temp = rotate(api, canvas, 90);
      fold_draw(api, which, temp, snapshot, a, b, update_rect);
      temp2 = rotate(api, temp, 270);
      SDL_BlitSurface(temp2, 0, canvas, 0);
      SDL_FreeSurface(temp);
      SDL_FreeSurface(temp2);
      break;

    case 2:
      fold_draw(api, which, canvas, snapshot, x, y, update_rect);
      break;

    case 3:
      translate_xy(canvas, x, y, &a, &b, 270);
      translate_coords(canvas, 270);
      temp = rotate(api, canvas, 270);
      fold_draw(api, which, temp, snapshot, a, b, update_rect);
      temp2 = rotate(api, temp, 90);
      SDL_BlitSurface(temp2, 0, canvas, 0);
      SDL_FreeSurface(temp);
      SDL_FreeSurface(temp2);
      break;

    case 4:
      translate_xy(canvas, x, y, &a, &b, 180);
      translate_coords(canvas, 180);
      temp = rotate(api, canvas, 180);
      fold_draw(api, which, temp, snapshot, a, b, update_rect);
      temp2 = rotate(api, temp, 180);
      SDL_BlitSurface(temp2, 0, canvas, 0);
      SDL_FreeSurface(temp);
      SDL_FreeSurface(temp2);
      break;
    }

  update_rect->x = update_rect->y = 0;
  update_rect->w = canvas->w;
  update_rect->h = canvas->h;
  api->playsound(fold_snd, (x * 255) / canvas->w, 255);
}

void fold_shutdown(magic_api * api ATTRIBUTE_UNUSED)
{
  Mix_FreeChunk(fold_snd);
  SDL_FreeSurface(fold_surface_dst);
  SDL_FreeSurface(fold_surface_src);
}

// Interactivity functions

inline Uint8 fold_what_corner(int x, int y, SDL_Surface * canvas)
{
  if (x >= canvas->w / 2)
    {
      if (y >= canvas->h / 2)
        return 4;
      else
        return 1;
    }
  else
    {
      if (y >= canvas->h / 2)
        return 3;
      else
        return 2;
    }
}


static void fold_print_line(void *ptr, int which ATTRIBUTE_UNUSED, SDL_Surface * canvas, SDL_Surface * last,
                            int x, int y)
{
  magic_api *api = (magic_api *) ptr;

  api->putpixel(canvas, x, y, SDL_MapRGB(last->format, 222, 222, 222)); //Middle gray. Color have been set arbitrary.
}

static void fold_print_dark_line(void *ptr, int which ATTRIBUTE_UNUSED, SDL_Surface * canvas,
                                 SDL_Surface * last ATTRIBUTE_UNUSED, int x, int y)
{
  magic_api *api = (magic_api *) ptr;

  api->putpixel(canvas, x, y, SDL_MapRGB(last->format, 90, 90, 90));    //It should not look too black nor too white with shadowed colors.
}

static void fold_erase(void *ptr, int which ATTRIBUTE_UNUSED, SDL_Surface * canvas, SDL_Surface * last ATTRIBUTE_UNUSED,
                       int x, int y)
{
  magic_api *api = (magic_api *) ptr;

  api->putpixel(canvas, x, y, SDL_MapRGB(canvas->format, fold_r, fold_g, fold_b));
}

void fold_click(magic_api * ptr, int which, int mode ATTRIBUTE_UNUSED,
                SDL_Surface * canvas, SDL_Surface * snapshot, int x, int y, SDL_Rect * update_rect)
{
  magic_api *api = (magic_api *) ptr;

  corner = fold_what_corner(x, y, snapshot);

  switch (corner)
    {
    case 1:
      fold_ox = canvas->w - 1;
      fold_oy = 0;
      break;
    case 2:
      fold_ox = fold_oy = 0;
      break;
    case 3:
      fold_ox = 0;
      fold_oy = canvas->h - 1;
      break;
    case 4:
      fold_ox = canvas->w - 1;
      fold_oy = canvas->h - 1;
      break;
    }

  fold_drag(api, which, canvas, snapshot, x, y, x, y, update_rect);
}

void fold_preview(magic_api * api, int which, SDL_Surface * canvas,
                  SDL_Surface * snapshot, int ox ATTRIBUTE_UNUSED, int oy ATTRIBUTE_UNUSED, int x, int y,
                  SDL_Rect * update_rect)
{
  int middle_point_x;
  int middle_point_y;

  fold_x = x;
  fold_y = y;
  SDL_BlitSurface(snapshot, 0, canvas, 0);

  middle_point_x = (fold_ox + x) / 2;
  middle_point_y = (fold_oy + y) / 2;

  switch (corner)
    {
    case 1:                    //Right Upper
      right_arm_x = fold_ox - (fold_ox - middle_point_x) - middle_point_y * middle_point_y / (fold_ox - middle_point_x);
      right_arm_y = fold_oy;

      left_arm_x = fold_ox;
      left_arm_y =
        fold_oy - (fold_oy - middle_point_y) - (fold_ox - middle_point_x) * (fold_ox - middle_point_x) / (fold_oy -
                                                                                                          middle_point_y);
      break;

    case 2:                    //LU
      right_arm_x = fold_ox;
      right_arm_y = middle_point_y + middle_point_x * middle_point_x / middle_point_y;

      left_arm_x = middle_point_x + middle_point_y * middle_point_y / middle_point_x;
      left_arm_y = fold_oy;
      break;

    case 3:                    //LL
      right_arm_x = middle_point_x + (fold_oy - middle_point_y) * (fold_oy - middle_point_y) / middle_point_x;
      right_arm_y = fold_oy;

      left_arm_x = fold_ox;
      left_arm_y =
        fold_oy - (fold_oy - middle_point_y) - (fold_ox - middle_point_x) * (fold_ox - middle_point_x) / (fold_oy -
                                                                                                          middle_point_y);
      break;

    case 4:                    //RL
      right_arm_x = fold_ox;
      right_arm_y =
        fold_oy - (fold_oy - middle_point_y) - (fold_ox - middle_point_x) * (fold_ox - middle_point_x) / (fold_oy -
                                                                                                          middle_point_y);

      left_arm_x =
        fold_ox - (fold_ox - middle_point_x) - (fold_oy - middle_point_y) * (fold_oy - middle_point_y) / (fold_ox -
                                                                                                          middle_point_x);
      left_arm_y = fold_oy;
      break;
    }

  api->line((void *)api, which, canvas, snapshot, x, y, right_arm_x, right_arm_y, 1, fold_print_line);
  api->line((void *)api, which, canvas, snapshot, x, y, left_arm_x, left_arm_y, 1, fold_print_line);
  api->line((void *)api, which, canvas, snapshot, left_arm_x, left_arm_y, right_arm_x, right_arm_y, 1, fold_print_line);

  update_rect->x = update_rect->y = 0;
  update_rect->w = canvas->w;
  update_rect->h = canvas->h;
}

void fold_drag(magic_api * api, int which, SDL_Surface * canvas,
               SDL_Surface * snapshot, int ox, int oy, int x, int y, SDL_Rect * update_rect)
{
  // Avoid division by zero when calculating the preview
  x = clamp(2, x, canvas->w - 2);
  y = clamp(2, y, canvas->h - 2);
  fold_preview(api, which, canvas, snapshot, ox, oy, x, y, update_rect);
}

void fold_switchin(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED,
                   SDL_Surface * canvas ATTRIBUTE_UNUSED)
{
}

void fold_switchout(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED,
                    SDL_Surface * canvas ATTRIBUTE_UNUSED)
{
}

int fold_modes(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
{
  return (MODE_PAINT_WITH_PREVIEW);
}