summaryrefslogtreecommitdiffstats
path: root/plug-ins/common/jigsaw.c
diff options
context:
space:
mode:
Diffstat (limited to 'plug-ins/common/jigsaw.c')
-rw-r--r--plug-ins/common/jigsaw.c2563
1 files changed, 2563 insertions, 0 deletions
diff --git a/plug-ins/common/jigsaw.c b/plug-ins/common/jigsaw.c
new file mode 100644
index 0000000..eade3d3
--- /dev/null
+++ b/plug-ins/common/jigsaw.c
@@ -0,0 +1,2563 @@
+/*
+ * jigsaw - a plug-in for GIMP
+ *
+ * Copyright (C) Nigel Wetten
+ *
+ * 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 3 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, see <https://www.gnu.org/licenses/>.
+ *
+ * Contact info: nigel@cs.nwu.edu
+ *
+ * Version: 1.0.0
+ *
+ * Version: 1.0.1
+ *
+ * tim coppefield [timecop@japan.co.jp]
+ *
+ * Added dynamic preview mode.
+ *
+ * Damn, this plugin is the tightest piece of code I ever seen.
+ * I wish all filters in the plugins operated on guchar *buffer
+ * of the entire image :) sweet stuff.
+ *
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "libgimp/stdplugins-intl.h"
+
+
+#define PLUG_IN_PROC "plug-in-jigsaw"
+#define PLUG_IN_BINARY "jigsaw"
+#define PLUG_IN_ROLE "gimp-jigsaw"
+
+
+typedef enum
+{
+ BEZIER_1,
+ BEZIER_2
+} style_t;
+
+typedef enum
+{
+ LEFT,
+ RIGHT,
+ UP,
+ DOWN
+} bump_t;
+
+
+static void query (void);
+static void run (const gchar *name,
+ gint nparams,
+ const GimpParam *param,
+ gint *nreturn_vals,
+ GimpParam **return_vals);
+
+static void jigsaw (guint32 drawable_id,
+ GimpPreview *preview);
+static void jigsaw_preview (gpointer drawable_id,
+ GimpPreview *preview);
+
+static gboolean jigsaw_dialog (guint32 drawable_id);
+
+static void draw_jigsaw (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint height,
+ gint bytes,
+ gboolean preview_mode);
+
+static void draw_vertical_border (guchar *buffer, gint bufsize,
+ gint width, gint height,
+ gint bytes, gint x_offset, gint ytiles,
+ gint blend_lines, gdouble blend_amount);
+static void draw_horizontal_border (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint y_offset, gint xtiles,
+ gint blend_lines, gdouble blend_amount);
+static void draw_vertical_line (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint px[2], gint py[2]);
+static void draw_horizontal_line (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint px[2], gint py[2]);
+static void darken_vertical_line (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint *px, gint *py, gdouble delta);
+static void lighten_vertical_line (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint *px, gint *py, gdouble delta);
+static void darken_horizontal_line (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint *px, gint *py, gdouble delta);
+static void lighten_horizontal_line(guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint *px, gint *py, gdouble delta);
+static void draw_right_bump (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint x_offset, gint curve_start_offset,
+ gint steps);
+static void draw_left_bump (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint x_offset, gint curve_start_offset,
+ gint steps);
+static void draw_up_bump (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint y_offset, gint curve_start_offset,
+ gint steps);
+static void draw_down_bump (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint y_offset, gint curve_start_offset,
+ gint steps);
+static void darken_right_bump (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint x_offset, gint curve_start_offset,
+ gint steps, gdouble delta, gint counter);
+static void lighten_right_bump (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint x_offset, gint curve_start_offset,
+ gint steps, gdouble delta, gint counter);
+static void darken_left_bump (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint x_offset, gint curve_start_offset,
+ gint steps, gdouble delta, gint counter);
+static void lighten_left_bump (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint x_offset, gint curve_start_offset,
+ gint steps, gdouble delta, gint counter);
+static void darken_up_bump (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint y_offset, gint curve_start_offest,
+ gint steps, gdouble delta, gint counter);
+static void lighten_up_bump (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint y_offset, gint curve_start_offset,
+ gint steps, gdouble delta, gint counter);
+static void darken_down_bump (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint y_offset, gint curve_start_offset,
+ gint steps, gdouble delta, gint counter);
+static void lighten_down_bump (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint y_offset, gint curve_start_offset,
+ gint steps, gdouble delta, gint counter);
+static void generate_grid (gint width, gint height, gint xtiles, gint ytiles,
+ gint *x, gint *y);
+static void generate_bezier (gint px[4], gint py[4], gint steps,
+ gint *cachex, gint *cachey);
+static void malloc_cache (void);
+static void free_cache (void);
+static void init_right_bump (gint width, gint height);
+static void init_left_bump (gint width, gint height);
+static void init_up_bump (gint width, gint height);
+static void init_down_bump (gint width, gint height);
+static void draw_bezier_line (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint steps, gint *cx, gint *cy);
+static void darken_bezier_line (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint x_offset, gint y_offset, gint steps,
+ gint *cx, gint *cy, gdouble delta);
+static void lighten_bezier_line (guchar *buffer, gint bufsize,
+ gint width, gint bytes,
+ gint x_offset, gint y_offset, gint steps,
+ gint *cx, gint *cy, gdouble delta);
+static void draw_bezier_vertical_border (guchar *buffer, gint bufsize,
+ gint width, gint height,
+ gint bytes,
+ gint x_offset, gint xtiles,
+ gint ytiles, gint blend_lines,
+ gdouble blend_amount, gint steps);
+static void draw_bezier_horizontal_border (guchar *buffer, gint bufsize,
+ gint width, gint height,
+ gint bytes,
+ gint x_offset, gint xtiles,
+ gint ytiles, gint blend_lines,
+ gdouble blend_amount, gint steps);
+static void check_config (gint width, gint height);
+
+
+
+#define XFACTOR2 0.0833
+#define XFACTOR3 0.2083
+#define XFACTOR4 0.2500
+
+#define XFACTOR5 0.2500
+#define XFACTOR6 0.2083
+#define XFACTOR7 0.0833
+
+#define YFACTOR2 0.1000
+#define YFACTOR3 0.2200
+#define YFACTOR4 0.1000
+
+#define YFACTOR5 0.1000
+#define YFACTOR6 0.4666
+#define YFACTOR7 0.1000
+#define YFACTOR8 0.2000
+
+#define MAX_VALUE 255
+#define MIN_VALUE 0
+#define DELTA 0.15
+
+#define BLACK_R 30
+#define BLACK_G 30
+#define BLACK_B 30
+
+#define WALL_XFACTOR2 0.05
+#define WALL_XFACTOR3 0.05
+#define WALL_YFACTOR2 0.05
+#define WALL_YFACTOR3 0.05
+
+#define WALL_XCONS2 0.2
+#define WALL_XCONS3 0.3
+#define WALL_YCONS2 0.2
+#define WALL_YCONS3 0.3
+
+#define FUDGE 1.2
+
+#define MIN_XTILES 1
+#define MAX_XTILES 20
+#define MIN_YTILES 1
+#define MAX_YTILES 20
+#define MIN_BLEND_LINES 0
+#define MAX_BLEND_LINES 10
+#define MIN_BLEND_AMOUNT 0
+#define MAX_BLEND_AMOUNT 1.0
+
+#define SCALE_WIDTH 200
+
+#define DRAW_POINT(buffer, bufsize, index) \
+ do \
+ { \
+ if ((index) >= 0 && (index) + 2 < (bufsize)) \
+ { \
+ buffer[(index) + 0] = BLACK_R; \
+ buffer[(index) + 1] = BLACK_G; \
+ buffer[(index) + 2] = BLACK_B; \
+ } \
+ } \
+ while (0)
+
+#define DARKEN_POINT(buffer, bufsize, index, delta, temp) \
+ do \
+ { \
+ if ((index) >= 0 && (index) + 2 < (bufsize)) \
+ { \
+ temp = MAX (buffer[(index) + 0] * (1.0 - (delta)), MIN_VALUE); \
+ buffer[(index) + 0] = temp; \
+ temp = MAX (buffer[(index) + 1] * (1.0 - (delta)), MIN_VALUE); \
+ buffer[(index) + 1] = temp; \
+ temp = MAX (buffer[(index) + 2] * (1.0 - (delta)), MIN_VALUE); \
+ buffer[(index) + 2] = temp; \
+ } \
+ } \
+ while (0)
+
+#define LIGHTEN_POINT(buffer, bufsize, index, delta, temp) \
+ do \
+ { \
+ if ((index) >= 0 && (index) + 2 < (bufsize)) \
+ { \
+ temp = MIN (buffer[(index) + 0] * (1.0 + (delta)), MAX_VALUE); \
+ buffer[(index) + 0] = temp; \
+ temp = MIN (buffer[(index) + 1] * (1.0 + (delta)), MAX_VALUE); \
+ buffer[(index) + 1] = temp; \
+ temp = MIN (buffer[(index) + 2] * (1.0 + (delta)), MAX_VALUE); \
+ buffer[(index) + 2] = temp; \
+ } \
+ } \
+ while (0)
+
+
+const GimpPlugInInfo PLUG_IN_INFO =
+{
+ NULL,
+ NULL,
+ query,
+ run
+};
+
+struct config_tag
+{
+ gint x;
+ gint y;
+ style_t style;
+ gint blend_lines;
+ gdouble blend_amount;
+};
+
+
+typedef struct config_tag config_t;
+
+static config_t config =
+{
+ 5,
+ 5,
+ BEZIER_1,
+ 3,
+ 0.5
+};
+
+struct globals_tag
+{
+ gint *cachex1[4];
+ gint *cachex2[4];
+ gint *cachey1[4];
+ gint *cachey2[4];
+ gint steps[4];
+ gint *gridx;
+ gint *gridy;
+ gint **blend_outer_cachex1[4];
+ gint **blend_outer_cachex2[4];
+ gint **blend_outer_cachey1[4];
+ gint **blend_outer_cachey2[4];
+ gint **blend_inner_cachex1[4];
+ gint **blend_inner_cachex2[4];
+ gint **blend_inner_cachey1[4];
+ gint **blend_inner_cachey2[4];
+};
+
+typedef struct globals_tag globals_t;
+
+static globals_t globals;
+
+MAIN ()
+
+static void
+query (void)
+{
+ static const GimpParamDef args[] =
+ {
+ { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
+ { GIMP_PDB_IMAGE, "image", "Input image" },
+ { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
+ { GIMP_PDB_INT32, "x", "Number of tiles across > 0" },
+ { GIMP_PDB_INT32, "y", "Number of tiles down > 0" },
+ { GIMP_PDB_INT32, "style", "The style/shape of the jigsaw puzzle { 0, 1 }" },
+ { GIMP_PDB_INT32, "blend-lines", "Number of lines for shading bevels >= 0" },
+ { GIMP_PDB_FLOAT, "blend-amount", "The power of the light highlights 0 =< 5" }
+ };
+
+ gimp_install_procedure (PLUG_IN_PROC,
+ N_("Add a jigsaw-puzzle pattern to the image"),
+ "Jigsaw puzzle look",
+ "Nigel Wetten",
+ "Nigel Wetten",
+ "May 2000",
+ N_("_Jigsaw..."),
+ "RGB*",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (args), 0,
+ args, NULL);
+
+ gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Render/Pattern");
+}
+
+static void
+run (const gchar *name,
+ gint nparams,
+ const GimpParam *param,
+ gint *nreturn_vals,
+ GimpParam **return_vals)
+{
+ static GimpParam values[1];
+ GimpRunMode run_mode;
+ guint32 drawable_id;
+ GimpPDBStatusType status = GIMP_PDB_SUCCESS;
+
+ INIT_I18N ();
+ gegl_init (NULL, NULL);
+
+ run_mode = param[0].data.d_int32;
+ drawable_id = param[2].data.d_drawable;
+
+ switch (run_mode)
+ {
+ case GIMP_RUN_NONINTERACTIVE:
+ if (nparams == 8)
+ {
+ config.x = param[3].data.d_int32;
+ config.y = param[4].data.d_int32;
+ config.style = param[5].data.d_int32;
+ config.blend_lines = param[6].data.d_int32;
+ config.blend_amount = param[7].data.d_float;
+
+ jigsaw (drawable_id, NULL);
+ }
+ else
+ {
+ status = GIMP_PDB_CALLING_ERROR;
+ }
+ break;
+
+ case GIMP_RUN_INTERACTIVE:
+ gimp_get_data (PLUG_IN_PROC, &config);
+ if (! jigsaw_dialog (drawable_id))
+ {
+ status = GIMP_PDB_CANCEL;
+ break;
+ }
+ gimp_progress_init (_("Assembling jigsaw"));
+
+ jigsaw (drawable_id, NULL);
+ gimp_set_data (PLUG_IN_PROC, &config, sizeof(config_t));
+ gimp_displays_flush ();
+ break;
+
+ case GIMP_RUN_WITH_LAST_VALS:
+ gimp_get_data (PLUG_IN_PROC, &config);
+ jigsaw (drawable_id, NULL);
+ gimp_displays_flush ();
+ } /* switch */
+
+ *nreturn_vals = 1;
+ *return_vals = values;
+ values[0].type = GIMP_PDB_STATUS;
+ values[0].data.d_status = status;
+}
+
+static void
+jigsaw (guint32 drawable_id,
+ GimpPreview *preview)
+{
+ GeglBuffer *gegl_buffer = NULL;
+ const Babl *format = NULL;
+ guchar *buffer;
+ gint width;
+ gint height;
+ gint bytes;
+ gint buffer_size;
+
+ if (preview)
+ {
+ gimp_preview_get_size (preview, &width, &height);
+ buffer = gimp_drawable_get_thumbnail_data (drawable_id,
+ &width, &height, &bytes);
+ buffer_size = bytes * width * height;
+ }
+ else
+ {
+ gegl_buffer = gimp_drawable_get_buffer (drawable_id);
+
+ width = gimp_drawable_width (drawable_id);
+ height = gimp_drawable_height (drawable_id);
+
+ if (gimp_drawable_has_alpha (drawable_id))
+ format = babl_format ("R'G'B'A u8");
+ else
+ format = babl_format ("R'G'B' u8");
+
+ bytes = babl_format_get_bytes_per_pixel (format);
+
+ /* setup image buffer */
+ buffer_size = bytes * width * height;
+ buffer = g_new (guchar, buffer_size);
+
+ gegl_buffer_get (gegl_buffer, GEGL_RECTANGLE (0, 0, width, height), 1.0,
+ format, buffer,
+ GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+ g_object_unref (gegl_buffer);
+ }
+
+ check_config (width, height);
+ globals.steps[LEFT] = globals.steps[RIGHT] = globals.steps[UP]
+ = globals.steps[DOWN] = (config.x < config.y) ?
+ (width / config.x * 2) : (height / config.y * 2);
+
+ malloc_cache ();
+ draw_jigsaw (buffer, buffer_size, width, height, bytes, preview != NULL);
+ free_cache ();
+
+ /* cleanup */
+ if (preview)
+ {
+ gimp_preview_draw_buffer (preview, buffer, width * bytes);
+ }
+ else
+ {
+ gegl_buffer = gimp_drawable_get_shadow_buffer (drawable_id);
+
+ gegl_buffer_set (gegl_buffer, GEGL_RECTANGLE (0, 0, width, height), 0,
+ format, buffer,
+ GEGL_AUTO_ROWSTRIDE);
+ g_object_unref (gegl_buffer);
+
+ gimp_drawable_merge_shadow (drawable_id, TRUE);
+ gimp_drawable_update (drawable_id, 0, 0, width, height);
+ }
+
+ g_free (buffer);
+}
+
+static void
+jigsaw_preview (gpointer drawable_id,
+ GimpPreview *preview)
+{
+ jigsaw (GPOINTER_TO_INT (drawable_id), preview);
+}
+
+static void
+generate_bezier (gint px[4],
+ gint py[4],
+ gint steps,
+ gint *cachex,
+ gint *cachey)
+{
+ gdouble t = 0.0;
+ gdouble sigma = 1.0 / steps;
+ gint i;
+
+ for (i = 0; i < steps; i++)
+ {
+ gdouble t2, t3, x, y, t_1;
+
+ t += sigma;
+ t2 = t * t;
+ t3 = t2 * t;
+ t_1 = 1 - t;
+ x = t_1 * t_1 * t_1 * px[0]
+ + 3 * t * t_1 * t_1 * px[1]
+ + 3 * t2 * t_1 * px[2]
+ + t3 * px[3];
+ y = t_1 * t_1 * t_1 * py[0]
+ + 3 * t * t_1 * t_1 * py[1]
+ + 3 * t2 * t_1 * py[2]
+ + t3 * py[3];
+ cachex[i] = (gint) (x + 0.2);
+ cachey[i] = (gint) (y + 0.2);
+ } /* for */
+}
+
+static void
+draw_jigsaw (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint height,
+ gint bytes,
+ gboolean preview_mode)
+{
+ gint i;
+ gint *x, *y;
+ gint xtiles = config.x;
+ gint ytiles = config.y;
+ gint xlines = xtiles - 1;
+ gint ylines = ytiles - 1;
+ gint blend_lines = config.blend_lines;
+ gdouble blend_amount = config.blend_amount;
+ gint steps = globals.steps[RIGHT];
+ style_t style = config.style;
+ gint progress_total = xlines + ylines - 1;
+
+ g_return_if_fail (buffer != NULL);
+
+ globals.gridx = g_new (gint, xtiles);
+ globals.gridy = g_new (gint, ytiles);
+ x = globals.gridx;
+ y = globals.gridy;
+
+ generate_grid (width, height, xtiles, ytiles, globals.gridx, globals.gridy);
+
+ init_right_bump (width, height);
+ init_left_bump (width, height);
+ init_up_bump (width, height);
+ init_down_bump (width, height);
+
+ if (style == BEZIER_1)
+ {
+ for (i = 0; i < xlines; i++)
+ {
+ draw_vertical_border (buffer, bufsize, width, height, bytes,
+ x[i], ytiles,
+ blend_lines, blend_amount);
+ if (!preview_mode)
+ gimp_progress_update ((gdouble) i / (gdouble) progress_total);
+ }
+ for (i = 0; i < ylines; i++)
+ {
+ draw_horizontal_border (buffer, bufsize, width, bytes, y[i], xtiles,
+ blend_lines, blend_amount);
+ if (!preview_mode)
+ gimp_progress_update ((gdouble) (i + xlines) / (gdouble) progress_total);
+ }
+ }
+ else if (style == BEZIER_2)
+ {
+ for (i = 0; i < xlines; i++)
+ {
+ draw_bezier_vertical_border (buffer, bufsize, width, height, bytes,
+ x[i], xtiles, ytiles, blend_lines,
+ blend_amount, steps);
+ if (!preview_mode)
+ gimp_progress_update ((gdouble) i / (gdouble) progress_total);
+ }
+ for (i = 0; i < ylines; i++)
+ {
+ draw_bezier_horizontal_border (buffer, bufsize, width, height, bytes,
+ y[i], xtiles, ytiles, blend_lines,
+ blend_amount, steps);
+ if (!preview_mode)
+ gimp_progress_update ((gdouble) (i + xlines) / (gdouble) progress_total);
+ }
+ }
+ else
+ {
+ g_printerr ("draw_jigsaw: bad style\n");
+ gimp_quit ();
+ }
+ gimp_progress_update (1.0);
+
+ g_free (globals.gridx);
+ g_free (globals.gridy);
+}
+
+static void
+draw_vertical_border (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint height,
+ gint bytes,
+ gint x_offset,
+ gint ytiles,
+ gint blend_lines,
+ gdouble blend_amount)
+{
+ gint i, j;
+ gint tile_height = height / ytiles;
+ gint tile_height_eighth = tile_height / 8;
+ gint curve_start_offset = 3 * tile_height_eighth;
+ gint curve_end_offset = curve_start_offset + 2 * tile_height_eighth;
+ gint px[2], py[2];
+ gint ly[2], dy[2];
+ gint y_offset = 0;
+ gdouble delta;
+ gdouble sigma = blend_amount / blend_lines;
+ gint right;
+
+ for (i = 0; i < ytiles; i++)
+ {
+ right = g_random_int_range (0, 2);
+
+ /* first straight line from top downwards */
+ px[0] = px[1] = x_offset;
+ py[0] = y_offset; py[1] = y_offset + curve_start_offset - 1;
+ draw_vertical_line (buffer, bufsize, width, bytes, px, py);
+ delta = blend_amount;
+ dy[0] = ly[0] = py[0]; dy[1] = ly[1] = py[1];
+ if (!right)
+ {
+ ly[1] += blend_lines + 2;
+ }
+ for (j = 0; j < blend_lines; j++)
+ {
+ dy[0]++; dy[1]--; ly[0]++; ly[1]--;
+ px[0] = x_offset - j - 1;
+ darken_vertical_line (buffer, bufsize, width, bytes, px, dy, delta);
+ px[0] = x_offset + j + 1;
+ lighten_vertical_line (buffer, bufsize, width, bytes, px, ly, delta);
+ delta -= sigma;
+ }
+
+ /* top half of curve */
+ if (right)
+ {
+ draw_right_bump (buffer, bufsize, width, bytes, x_offset,
+ y_offset + curve_start_offset,
+ globals.steps[RIGHT]);
+ delta = blend_amount;
+ for (j = 0; j < blend_lines; j++)
+ {
+ /* use to be -j -1 */
+ darken_right_bump (buffer, bufsize, width, bytes, x_offset,
+ y_offset + curve_start_offset,
+ globals.steps[RIGHT], delta, j);
+ /* use to be +j + 1 */
+ lighten_right_bump (buffer, bufsize, width, bytes, x_offset,
+ y_offset + curve_start_offset,
+ globals.steps[RIGHT], delta, j);
+ delta -= sigma;
+ }
+ }
+ else
+ {
+ draw_left_bump (buffer, bufsize, width, bytes, x_offset,
+ y_offset + curve_start_offset,
+ globals.steps[LEFT]);
+ delta = blend_amount;
+ for (j = 0; j < blend_lines; j++)
+ {
+ /* use to be -j -1 */
+ darken_left_bump (buffer, bufsize, width, bytes, x_offset,
+ y_offset + curve_start_offset,
+ globals.steps[LEFT], delta, j);
+ /* use to be -j - 1 */
+ lighten_left_bump (buffer, bufsize, width, bytes, x_offset,
+ y_offset + curve_start_offset,
+ globals.steps[LEFT], delta, j);
+ delta -= sigma;
+ }
+ }
+ /* bottom straight line of a tile wall */
+ px[0] = px[1] = x_offset;
+ py[0] = y_offset + curve_end_offset;
+ py[1] = globals.gridy[i];
+ draw_vertical_line (buffer, bufsize, width, bytes, px, py);
+ delta = blend_amount;
+ dy[0] = ly[0] = py[0]; dy[1] = ly[1] = py[1];
+ if (right)
+ {
+ dy[0] -= blend_lines + 2;
+ }
+ for (j = 0; j < blend_lines; j++)
+ {
+ dy[0]++; dy[1]--; ly[0]++; ly[1]--;
+ px[0] = x_offset - j - 1;
+ darken_vertical_line (buffer, bufsize, width, bytes, px, dy, delta);
+ px[0] = x_offset + j + 1;
+ lighten_vertical_line (buffer, bufsize, width, bytes, px, ly, delta);
+ delta -= sigma;
+ }
+
+ y_offset = globals.gridy[i];
+ } /* for */
+}
+
+/* assumes RGB* */
+static void
+draw_horizontal_border (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint y_offset,
+ gint xtiles,
+ gint blend_lines,
+ gdouble blend_amount)
+{
+ gint i, j;
+ gint tile_width = width / xtiles;
+ gint tile_width_eighth = tile_width / 8;
+ gint curve_start_offset = 3 * tile_width_eighth;
+ gint curve_end_offset = curve_start_offset + 2 * tile_width_eighth;
+ gint px[2], py[2];
+ gint dx[2], lx[2];
+ gint x_offset = 0;
+ gdouble delta;
+ gdouble sigma = blend_amount / blend_lines;
+ gint up;
+
+ for (i = 0; i < xtiles; i++)
+ {
+ up = g_random_int_range (0, 2);
+
+ /* first horizontal line across */
+ px[0] = x_offset; px[1] = x_offset + curve_start_offset - 1;
+ py[0] = py[1] = y_offset;
+ draw_horizontal_line (buffer, bufsize, width, bytes, px, py);
+ delta = blend_amount;
+ dx[0] = lx[0] = px[0]; dx[1] = lx[1] = px[1];
+ if (up)
+ {
+ lx[1] += blend_lines + 2;
+ }
+ for (j = 0; j < blend_lines; j++)
+ {
+ dx[0]++; dx[1]--; lx[0]++; lx[1]--;
+ py[0] = y_offset - j - 1;
+ darken_horizontal_line (buffer, bufsize, width, bytes, dx, py,
+ delta);
+ py[0] = y_offset + j + 1;
+ lighten_horizontal_line (buffer, bufsize, width, bytes, lx, py,
+ delta);
+ delta -= sigma;
+ }
+
+ if (up)
+ {
+ draw_up_bump (buffer, bufsize, width, bytes, y_offset,
+ x_offset + curve_start_offset,
+ globals.steps[UP]);
+ delta = blend_amount;
+ for (j = 0; j < blend_lines; j++)
+ {
+ /* use to be -j -1 */
+ darken_up_bump (buffer, bufsize, width, bytes, y_offset,
+ x_offset + curve_start_offset,
+ globals.steps[UP], delta, j);
+ /* use to be +j + 1 */
+ lighten_up_bump (buffer, bufsize, width, bytes, y_offset,
+ x_offset + curve_start_offset,
+ globals.steps[UP], delta, j);
+ delta -= sigma;
+ }
+ }
+ else
+ {
+ draw_down_bump (buffer, bufsize, width, bytes, y_offset,
+ x_offset + curve_start_offset,
+ globals.steps[DOWN]);
+ delta = blend_amount;
+ for (j = 0; j < blend_lines; j++)
+ {
+ /* use to be +j + 1 */
+ darken_down_bump (buffer, bufsize, width, bytes, y_offset,
+ x_offset + curve_start_offset,
+ globals.steps[DOWN], delta, j);
+ /* use to be -j -1 */
+ lighten_down_bump (buffer, bufsize, width, bytes, y_offset,
+ x_offset + curve_start_offset,
+ globals.steps[DOWN], delta, j);
+ delta -= sigma;
+ }
+ }
+ /* right horizontal line of tile */
+ px[0] = x_offset + curve_end_offset;
+ px[1] = globals.gridx[i];
+ py[0] = py[1] = y_offset;
+ draw_horizontal_line (buffer, bufsize, width, bytes, px, py);
+ delta = blend_amount;
+ dx[0] = lx[0] = px[0]; dx[1] = lx[1] = px[1];
+ if (!up)
+ {
+ dx[0] -= blend_lines + 2;
+ }
+ for (j = 0;j < blend_lines; j++)
+ {
+ dx[0]++; dx[1]--; lx[0]++; lx[1]--;
+ py[0] = y_offset - j - 1;
+ darken_horizontal_line (buffer, bufsize, width, bytes, dx, py,
+ delta);
+ py[0] = y_offset + j + 1;
+ lighten_horizontal_line (buffer, bufsize, width, bytes, lx, py,
+ delta);
+ delta -= sigma;
+ }
+ x_offset = globals.gridx[i];
+ } /* for */
+}
+
+/* assumes going top to bottom */
+static void
+draw_vertical_line (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint px[2],
+ gint py[2])
+{
+ gint i;
+ gint rowstride;
+ gint index;
+ gint length;
+
+ rowstride = bytes * width;
+ index = px[0] * bytes + rowstride * py[0];
+ length = py[1] - py[0] + 1;
+
+ for (i = 0; i < length; i++)
+ {
+ DRAW_POINT (buffer, bufsize, index);
+ index += rowstride;
+ }
+}
+
+/* assumes going left to right */
+static void
+draw_horizontal_line (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint px[2],
+ gint py[2])
+{
+ gint i;
+ gint rowstride;
+ gint index;
+ gint length;
+
+ rowstride = bytes * width;
+ index = px[0] * bytes + rowstride * py[0];
+ length = px[1] - px[0] + 1;
+
+ for (i = 0; i < length; i++)
+ {
+ DRAW_POINT (buffer, bufsize, index);
+ index += bytes;
+ }
+}
+
+static void
+draw_right_bump (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint x_offset,
+ gint curve_start_offset,
+ gint steps)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint rowstride;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = globals.cachex1[RIGHT][i] + x_offset;
+ y = globals.cachey1[RIGHT][i] + curve_start_offset;
+ index = y * rowstride + x * bytes;
+ DRAW_POINT (buffer, bufsize, index);
+
+ x = globals.cachex2[RIGHT][i] + x_offset;
+ y = globals.cachey2[RIGHT][i] + curve_start_offset;
+ index = y * rowstride + x * bytes;
+ DRAW_POINT (buffer, bufsize, index);
+ }
+}
+
+static void
+draw_left_bump (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint x_offset,
+ gint curve_start_offset,
+ gint steps)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint rowstride;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = globals.cachex1[LEFT][i] + x_offset;
+ y = globals.cachey1[LEFT][i] + curve_start_offset;
+ index = y * rowstride + x * bytes;
+ DRAW_POINT (buffer, bufsize, index);
+
+ x = globals.cachex2[LEFT][i] + x_offset;
+ y = globals.cachey2[LEFT][i] + curve_start_offset;
+ index = y * rowstride + x * bytes;
+ DRAW_POINT (buffer, bufsize, index);
+ }
+}
+
+static void
+draw_up_bump (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint y_offset,
+ gint curve_start_offset,
+ gint steps)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint rowstride;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = globals.cachex1[UP][i] + curve_start_offset;
+ y = globals.cachey1[UP][i] + y_offset;
+ index = y * rowstride + x * bytes;
+ DRAW_POINT (buffer, bufsize, index);
+
+ x = globals.cachex2[UP][i] + curve_start_offset;
+ y = globals.cachey2[UP][i] + y_offset;
+ index = y * rowstride + x * bytes;
+ DRAW_POINT (buffer, bufsize, index);
+ }
+}
+
+static void
+draw_down_bump (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint y_offset,
+ gint curve_start_offset,
+ gint steps)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint rowstride;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = globals.cachex1[DOWN][i] + curve_start_offset;
+ y = globals.cachey1[DOWN][i] + y_offset;
+ index = y * rowstride + x * bytes;
+ DRAW_POINT (buffer, bufsize, index);
+
+ x = globals.cachex2[DOWN][i] + curve_start_offset;
+ y = globals.cachey2[DOWN][i] + y_offset;
+ index = y * rowstride + x * bytes;
+ DRAW_POINT (buffer, bufsize, index);
+ }
+}
+
+static void
+malloc_cache (void)
+{
+ gint i, j;
+ gint blend_lines = config.blend_lines;
+
+ for (i = 0; i < 4; i++)
+ {
+ gint steps = globals.steps[i];
+
+ globals.cachex1[i] = g_new (gint, steps);
+ globals.cachex2[i] = g_new (gint, steps);
+ globals.cachey1[i] = g_new (gint, steps);
+ globals.cachey2[i] = g_new (gint, steps);
+ globals.blend_outer_cachex1[i] = g_new (gint *, blend_lines);
+ globals.blend_outer_cachex2[i] = g_new (gint *, blend_lines);
+ globals.blend_outer_cachey1[i] = g_new (gint *, blend_lines);
+ globals.blend_outer_cachey2[i] = g_new (gint *, blend_lines);
+ globals.blend_inner_cachex1[i] = g_new (gint *, blend_lines);
+ globals.blend_inner_cachex2[i] = g_new (gint *, blend_lines);
+ globals.blend_inner_cachey1[i] = g_new (gint *, blend_lines);
+ globals.blend_inner_cachey2[i] = g_new (gint *, blend_lines);
+ for (j = 0; j < blend_lines; j++)
+ {
+ globals.blend_outer_cachex1[i][j] = g_new (gint, steps);
+ globals.blend_outer_cachex2[i][j] = g_new (gint, steps);
+ globals.blend_outer_cachey1[i][j] = g_new (gint, steps);
+ globals.blend_outer_cachey2[i][j] = g_new (gint, steps);
+ globals.blend_inner_cachex1[i][j] = g_new (gint, steps);
+ globals.blend_inner_cachex2[i][j] = g_new (gint, steps);
+ globals.blend_inner_cachey1[i][j] = g_new (gint, steps);
+ globals.blend_inner_cachey2[i][j] = g_new (gint, steps);
+ }
+ }
+}
+
+static void
+free_cache (void)
+{
+ gint i, j;
+ gint blend_lines = config.blend_lines;
+
+ for (i = 0; i < 4; i ++)
+ {
+ g_free (globals.cachex1[i]);
+ g_free (globals.cachex2[i]);
+ g_free (globals.cachey1[i]);
+ g_free (globals.cachey2[i]);
+ for (j = 0; j < blend_lines; j++)
+ {
+ g_free (globals.blend_outer_cachex1[i][j]);
+ g_free (globals.blend_outer_cachex2[i][j]);
+ g_free (globals.blend_outer_cachey1[i][j]);
+ g_free (globals.blend_outer_cachey2[i][j]);
+ g_free (globals.blend_inner_cachex1[i][j]);
+ g_free (globals.blend_inner_cachex2[i][j]);
+ g_free (globals.blend_inner_cachey1[i][j]);
+ g_free (globals.blend_inner_cachey2[i][j]);
+ }
+ g_free (globals.blend_outer_cachex1[i]);
+ g_free (globals.blend_outer_cachex2[i]);
+ g_free (globals.blend_outer_cachey1[i]);
+ g_free (globals.blend_outer_cachey2[i]);
+ g_free (globals.blend_inner_cachex1[i]);
+ g_free (globals.blend_inner_cachex2[i]);
+ g_free (globals.blend_inner_cachey1[i]);
+ g_free (globals.blend_inner_cachey2[i]);
+ }
+}
+
+static void
+init_right_bump (gint width,
+ gint height)
+{
+ gint i;
+ gint xtiles = config.x;
+ gint ytiles = config.y;
+ gint steps = globals.steps[RIGHT];
+ gint px[4], py[4];
+ gint x_offset = 0;
+ gint tile_width = width / xtiles;
+ gint tile_height = height/ ytiles;
+ gint tile_height_eighth = tile_height / 8;
+ gint curve_start_offset = 0;
+ gint curve_end_offset = curve_start_offset + 2 * tile_height_eighth;
+ gint blend_lines = config.blend_lines;
+
+ px[0] = x_offset;
+ px[1] = x_offset + XFACTOR2 * tile_width;
+ px[2] = x_offset + XFACTOR3 * tile_width;
+ px[3] = x_offset + XFACTOR4 * tile_width;
+ py[0] = curve_start_offset;
+ py[1] = curve_start_offset + YFACTOR2 * tile_height;
+ py[2] = curve_start_offset - YFACTOR3 * tile_height;
+ py[3] = curve_start_offset + YFACTOR4 * tile_height;
+ generate_bezier(px, py, steps, globals.cachex1[RIGHT],
+ globals.cachey1[RIGHT]);
+ /* outside right bump */
+ for (i = 0; i < blend_lines; i++)
+ {
+ py[0]--; py[1]--; py[2]--; px[3]++;
+ generate_bezier(px, py, steps,
+ globals.blend_outer_cachex1[RIGHT][i],
+ globals.blend_outer_cachey1[RIGHT][i]);
+ }
+ /* inside right bump */
+ py[0] += blend_lines; py[1] += blend_lines; py[2] += blend_lines;
+ px[3] -= blend_lines;
+ for (i = 0; i < blend_lines; i++)
+ {
+ py[0]++; py[1]++; py[2]++; px[3]--;
+ generate_bezier(px, py, steps,
+ globals.blend_inner_cachex1[RIGHT][i],
+ globals.blend_inner_cachey1[RIGHT][i]);
+ }
+
+ /* bottom half of bump */
+ px[0] = x_offset + XFACTOR5 * tile_width;
+ px[1] = x_offset + XFACTOR6 * tile_width;
+ px[2] = x_offset + XFACTOR7 * tile_width;
+ px[3] = x_offset;
+ py[0] = curve_start_offset + YFACTOR5 * tile_height;
+ py[1] = curve_start_offset + YFACTOR6 * tile_height;
+ py[2] = curve_start_offset + YFACTOR7 * tile_height;
+ py[3] = curve_end_offset;
+ generate_bezier(px, py, steps, globals.cachex2[RIGHT],
+ globals.cachey2[RIGHT]);
+ /* outer right bump */
+ for (i = 0; i < blend_lines; i++)
+ {
+ py[1]++; py[2]++; py[3]++; px[0]++;
+ generate_bezier(px, py, steps,
+ globals.blend_outer_cachex2[RIGHT][i],
+ globals.blend_outer_cachey2[RIGHT][i]);
+ }
+ /* inner right bump */
+ py[1] -= blend_lines; py[2] -= blend_lines; py[3] -= blend_lines;
+ px[0] -= blend_lines;
+ for (i = 0; i < blend_lines; i++)
+ {
+ py[1]--; py[2]--; py[3]--; px[0]--;
+ generate_bezier(px, py, steps,
+ globals.blend_inner_cachex2[RIGHT][i],
+ globals.blend_inner_cachey2[RIGHT][i]);
+ }
+}
+
+static void
+init_left_bump (gint width,
+ gint height)
+{
+ gint i;
+ gint xtiles = config.x;
+ gint ytiles = config.y;
+ gint steps = globals.steps[LEFT];
+ gint px[4], py[4];
+ gint x_offset = 0;
+ gint tile_width = width / xtiles;
+ gint tile_height = height / ytiles;
+ gint tile_height_eighth = tile_height / 8;
+ gint curve_start_offset = 0;
+ gint curve_end_offset = curve_start_offset + 2 * tile_height_eighth;
+ gint blend_lines = config.blend_lines;
+
+ px[0] = x_offset;
+ px[1] = x_offset - XFACTOR2 * tile_width;
+ px[2] = x_offset - XFACTOR3 * tile_width;
+ px[3] = x_offset - XFACTOR4 * tile_width;
+ py[0] = curve_start_offset;
+ py[1] = curve_start_offset + YFACTOR2 * tile_height;
+ py[2] = curve_start_offset - YFACTOR3 * tile_height;
+ py[3] = curve_start_offset + YFACTOR4 * tile_height;
+ generate_bezier(px, py, steps, globals.cachex1[LEFT],
+ globals.cachey1[LEFT]);
+ /* outer left bump */
+ for (i = 0; i < blend_lines; i++)
+ {
+ py[0]--; py[1]--; py[2]--; px[3]--;
+ generate_bezier(px, py, steps,
+ globals.blend_outer_cachex1[LEFT][i],
+ globals.blend_outer_cachey1[LEFT][i]);
+ }
+ /* inner left bump */
+ py[0] += blend_lines; py[1] += blend_lines; py[2] += blend_lines;
+ px[3] += blend_lines;
+ for (i = 0; i < blend_lines; i++)
+ {
+ py[0]++; py[1]++; py[2]++; px[3]++;
+ generate_bezier(px, py, steps,
+ globals.blend_inner_cachex1[LEFT][i],
+ globals.blend_inner_cachey1[LEFT][i]);
+ }
+
+ /* bottom half of bump */
+ px[0] = x_offset - XFACTOR5 * tile_width;
+ px[1] = x_offset - XFACTOR6 * tile_width;
+ px[2] = x_offset - XFACTOR7 * tile_width;
+ px[3] = x_offset;
+ py[0] = curve_start_offset + YFACTOR5 * tile_height;
+ py[1] = curve_start_offset + YFACTOR6 * tile_height;
+ py[2] = curve_start_offset + YFACTOR7 * tile_height;
+ py[3] = curve_end_offset;
+ generate_bezier(px, py, steps, globals.cachex2[LEFT],
+ globals.cachey2[LEFT]);
+ /* outer left bump */
+ for (i = 0; i < blend_lines; i++)
+ {
+ py[1]++; py[2]++; py[3]++; px[0]--;
+ generate_bezier(px, py, steps,
+ globals.blend_outer_cachex2[LEFT][i],
+ globals.blend_outer_cachey2[LEFT][i]);
+ }
+ /* inner left bump */
+ py[1] -= blend_lines; py[2] -= blend_lines; py[3] -= blend_lines;
+ px[0] += blend_lines;
+ for (i = 0; i < blend_lines; i++)
+ {
+ py[1]--; py[2]--; py[3]--; px[0]++;
+ generate_bezier(px, py, steps,
+ globals.blend_inner_cachex2[LEFT][i],
+ globals.blend_inner_cachey2[LEFT][i]);
+ }
+}
+
+static void
+init_up_bump (gint width,
+ gint height)
+{
+ gint i;
+ gint xtiles = config.x;
+ gint ytiles = config.y;
+ gint steps = globals.steps[UP];
+ gint px[4], py[4];
+ gint y_offset = 0;
+ gint tile_width = width / xtiles;
+ gint tile_height = height/ ytiles;
+ gint tile_width_eighth = tile_width / 8;
+ gint curve_start_offset = 0;
+ gint curve_end_offset = curve_start_offset + 2 * tile_width_eighth;
+ gint blend_lines = config.blend_lines;
+
+ px[0] = curve_start_offset;
+ px[1] = curve_start_offset + YFACTOR2 * tile_width;
+ px[2] = curve_start_offset - YFACTOR3 * tile_width;
+ px[3] = curve_start_offset + YFACTOR4 * tile_width;
+ py[0] = y_offset;
+ py[1] = y_offset - XFACTOR2 * tile_height;
+ py[2] = y_offset - XFACTOR3 * tile_height;
+ py[3] = y_offset - XFACTOR4 * tile_height;
+ generate_bezier(px, py, steps, globals.cachex1[UP],
+ globals.cachey1[UP]);
+ /* outer up bump */
+ for (i = 0; i < blend_lines; i++)
+ {
+ px[0]--; px[1]--; px[2]--; py[3]--;
+ generate_bezier(px, py, steps,
+ globals.blend_outer_cachex1[UP][i],
+ globals.blend_outer_cachey1[UP][i]);
+ }
+ /* inner up bump */
+ px[0] += blend_lines; px[1] += blend_lines; px[2] += blend_lines;
+ py[3] += blend_lines;
+ for (i = 0; i < blend_lines; i++)
+ {
+ px[0]++; px[1]++; px[2]++; py[3]++;
+ generate_bezier(px, py, steps,
+ globals.blend_inner_cachex1[UP][i],
+ globals.blend_inner_cachey1[UP][i]);
+ }
+
+ /* bottom half of bump */
+ px[0] = curve_start_offset + YFACTOR5 * tile_width;
+ px[1] = curve_start_offset + YFACTOR6 * tile_width;
+ px[2] = curve_start_offset + YFACTOR7 * tile_width;
+ px[3] = curve_end_offset;
+ py[0] = y_offset - XFACTOR5 * tile_height;
+ py[1] = y_offset - XFACTOR6 * tile_height;
+ py[2] = y_offset - XFACTOR7 * tile_height;
+ py[3] = y_offset;
+ generate_bezier(px, py, steps, globals.cachex2[UP],
+ globals.cachey2[UP]);
+ /* outer up bump */
+ for (i = 0; i < blend_lines; i++)
+ {
+ px[1]++; px[2]++; px[3]++; py[0]--;
+ generate_bezier(px, py, steps,
+ globals.blend_outer_cachex2[UP][i],
+ globals.blend_outer_cachey2[UP][i]);
+ }
+ /* inner up bump */
+ px[1] -= blend_lines; px[2] -= blend_lines; px[3] -= blend_lines;
+ py[0] += blend_lines;
+ for (i = 0; i < blend_lines; i++)
+ {
+ px[1]--; px[2]--; px[3]--; py[0]++;
+ generate_bezier(px, py, steps,
+ globals.blend_inner_cachex2[UP][i],
+ globals.blend_inner_cachey2[UP][i]);
+ }
+}
+
+static void
+init_down_bump (gint width,
+ gint height)
+{
+ gint i;
+ gint xtiles = config.x;
+ gint ytiles = config.y;
+ gint steps = globals.steps[DOWN];
+ gint px[4], py[4];
+ gint y_offset = 0;
+ gint tile_width = width / xtiles;
+ gint tile_height = height/ ytiles;
+ gint tile_width_eighth = tile_width / 8;
+ gint curve_start_offset = 0;
+ gint curve_end_offset = curve_start_offset + 2 * tile_width_eighth;
+ gint blend_lines = config.blend_lines;
+
+ px[0] = curve_start_offset;
+ px[1] = curve_start_offset + YFACTOR2 * tile_width;
+ px[2] = curve_start_offset - YFACTOR3 * tile_width;
+ px[3] = curve_start_offset + YFACTOR4 * tile_width;
+ py[0] = y_offset;
+ py[1] = y_offset + XFACTOR2 * tile_height;
+ py[2] = y_offset + XFACTOR3 * tile_height;
+ py[3] = y_offset + XFACTOR4 * tile_height;
+ generate_bezier(px, py, steps, globals.cachex1[DOWN],
+ globals.cachey1[DOWN]);
+ /* outer down bump */
+ for (i = 0; i < blend_lines; i++)
+ {
+ px[0]--; px[1]--; px[2]--; py[3]++;
+ generate_bezier(px, py, steps,
+ globals.blend_outer_cachex1[DOWN][i],
+ globals.blend_outer_cachey1[DOWN][i]);
+ }
+ /* inner down bump */
+ px[0] += blend_lines; px[1] += blend_lines; px[2] += blend_lines;
+ py[3] -= blend_lines;
+ for (i = 0; i < blend_lines; i++)
+ {
+ px[0]++; px[1]++; px[2]++; py[3]--;
+ generate_bezier(px, py, steps,
+ globals.blend_inner_cachex1[DOWN][i],
+ globals.blend_inner_cachey1[DOWN][i]);
+ }
+
+ /* bottom half of bump */
+ px[0] = curve_start_offset + YFACTOR5 * tile_width;
+ px[1] = curve_start_offset + YFACTOR6 * tile_width;
+ px[2] = curve_start_offset + YFACTOR7 * tile_width;
+ px[3] = curve_end_offset;
+ py[0] = y_offset + XFACTOR5 * tile_height;
+ py[1] = y_offset + XFACTOR6 * tile_height;
+ py[2] = y_offset + XFACTOR7 * tile_height;
+ py[3] = y_offset;
+ generate_bezier(px, py, steps, globals.cachex2[DOWN],
+ globals.cachey2[DOWN]);
+ /* outer down bump */
+ for (i = 0; i < blend_lines; i++)
+ {
+ px[1]++; px[2]++; px[3]++; py[0]++;
+ generate_bezier(px, py, steps,
+ globals.blend_outer_cachex2[DOWN][i],
+ globals.blend_outer_cachey2[DOWN][i]);
+ }
+ /* inner down bump */
+ px[1] -= blend_lines; px[2] -= blend_lines; px[3] -= blend_lines;
+ py[0] -= blend_lines;
+ for (i = 0; i < blend_lines; i++)
+ {
+ px[1]--; px[2]--; px[3]--; py[0]--;
+ generate_bezier(px, py, steps,
+ globals.blend_inner_cachex2[DOWN][i],
+ globals.blend_inner_cachey2[DOWN][i]);
+ }
+}
+
+static void
+generate_grid (gint width,
+ gint height,
+ gint xtiles,
+ gint ytiles,
+ gint *x,
+ gint *y)
+{
+ gint i;
+ gint xlines = xtiles - 1;
+ gint ylines = ytiles - 1;
+ gint tile_width = width / xtiles;
+ gint tile_height = height / ytiles;
+ gint tile_width_leftover = width % xtiles;
+ gint tile_height_leftover = height % ytiles;
+ gint x_offset = tile_width;
+ gint y_offset = tile_height;
+ gint carry;
+
+ for (i = 0; i < xlines; i++)
+ {
+ x[i] = x_offset;
+ x_offset += tile_width;
+ }
+ carry = 0;
+ while (tile_width_leftover)
+ {
+ for (i = carry; i < xlines; i++)
+ {
+ x[i] += 1;
+ }
+ tile_width_leftover--;
+ carry++;
+ }
+ x[xlines] = width - 1; /* padding for draw_horizontal_border */
+
+ for (i = 0; i < ytiles; i++)
+ {
+ y[i] = y_offset;
+ y_offset += tile_height;
+ }
+ carry = 0;
+ while (tile_height_leftover)
+ {
+ for (i = carry; i < ylines; i++)
+ {
+ y[i] += 1;
+ }
+ tile_height_leftover--;
+ carry++;
+ }
+ y[ylines] = height - 1; /* padding for draw_vertical_border */
+}
+
+/* assumes RGB* */
+/* assumes py[1] > py[0] and px[0] = px[1] */
+static void
+darken_vertical_line (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint px[2],
+ gint py[2],
+ gdouble delta)
+{
+ gint i;
+ gint rowstride;
+ gint index;
+ gint length;
+ gint temp;
+
+ rowstride = bytes * width;
+ index = px[0] * bytes + py[0] * rowstride;
+ length = py[1] - py[0] + 1;
+
+ for (i = 0; i < length; i++)
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ index += rowstride;
+ }
+}
+
+/* assumes RGB* */
+/* assumes py[1] > py[0] and px[0] = px[1] */
+static void
+lighten_vertical_line (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint px[2],
+ gint py[2],
+ gdouble delta)
+{
+ gint i;
+ gint rowstride;
+ gint index;
+ gint length;
+ gint temp;
+
+ rowstride = bytes * width;
+ index = px[0] * bytes + py[0] * rowstride;
+ length = py[1] - py[0] + 1;
+
+ for (i = 0; i < length; i++)
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ index += rowstride;
+ }
+}
+
+/* assumes RGB* */
+/* assumes px[1] > px[0] and py[0] = py[1] */
+static void
+darken_horizontal_line (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint px[2],
+ gint py[2],
+ gdouble delta)
+{
+ gint i;
+ gint rowstride;
+ gint index;
+ gint length;
+ gint temp;
+
+ rowstride = bytes * width;
+ index = px[0] * bytes + py[0] * rowstride;
+ length = px[1] - px[0] + 1;
+
+ for (i = 0; i < length; i++)
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ index += bytes;
+ }
+}
+
+/* assumes RGB* */
+/* assumes px[1] > px[0] and py[0] = py[1] */
+static void
+lighten_horizontal_line (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint px[2],
+ gint py[2],
+ gdouble delta)
+{
+ gint i;
+ gint rowstride;
+ gint index;
+ gint length;
+ gint temp;
+
+ rowstride = bytes * width;
+ index = px[0] * bytes + py[0] * rowstride;
+ length = px[1] - px[0] + 1;
+
+ for (i = 0; i < length; i++)
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ index += bytes;
+ }
+}
+
+static void
+darken_right_bump (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint x_offset,
+ gint curve_start_offset,
+ gint steps,
+ gdouble delta,
+ gint counter)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint last_index1 = -1;
+ gint last_index2 = -1;
+ gint rowstride;
+ gint temp;
+ gint j = counter;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = x_offset
+ + globals.blend_inner_cachex1[RIGHT][j][i];
+ y = curve_start_offset
+ + globals.blend_inner_cachey1[RIGHT][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index1)
+ {
+ if (i < steps / 1.3)
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ else
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ last_index1 = index;
+ }
+
+ x = x_offset
+ + globals.blend_inner_cachex2[RIGHT][j][i];
+ y = curve_start_offset
+ + globals.blend_inner_cachey2[RIGHT][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index2)
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ last_index2 = index;
+ }
+ }
+}
+
+static void
+lighten_right_bump (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint x_offset,
+ gint curve_start_offset,
+ gint steps,
+ gdouble delta,
+ gint counter)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint last_index1 = -1;
+ gint last_index2 = -1;
+ gint rowstride;
+ gint temp;
+ gint j = counter;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = x_offset
+ + globals.blend_outer_cachex1[RIGHT][j][i];
+ y = curve_start_offset
+ + globals.blend_outer_cachey1[RIGHT][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index1)
+ {
+ if (i < steps / 1.3)
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ else
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ last_index1 = index;
+ }
+
+ x = x_offset
+ + globals.blend_outer_cachex2[RIGHT][j][i];
+ y = curve_start_offset
+ + globals.blend_outer_cachey2[RIGHT][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index2)
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ last_index2 = index;
+ }
+ }
+}
+
+static void
+darken_left_bump (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint x_offset,
+ gint curve_start_offset,
+ gint steps,
+ gdouble delta,
+ gint counter)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint last_index1 = -1;
+ gint last_index2 = -1;
+ gint rowstride;
+ gint temp;
+ gint j = counter;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = x_offset
+ + globals.blend_outer_cachex1[LEFT][j][i];
+ y = curve_start_offset
+ + globals.blend_outer_cachey1[LEFT][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index1)
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ last_index1 = index;
+ }
+
+ x = x_offset
+ + globals.blend_outer_cachex2[LEFT][j][i];
+ y = curve_start_offset
+ + globals.blend_outer_cachey2[LEFT][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index2)
+ {
+ if (i < steps / 4)
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ else
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ last_index2 = index;
+ }
+ }
+}
+
+static void
+lighten_left_bump (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint x_offset,
+ gint curve_start_offset,
+ gint steps,
+ gdouble delta,
+ gint counter)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint last_index1 = -1;
+ gint last_index2 = -1;
+ gint rowstride;
+ gint temp;
+ gint j = counter;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = x_offset
+ + globals.blend_inner_cachex1[LEFT][j][i];
+ y = curve_start_offset
+ + globals.blend_inner_cachey1[LEFT][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index1)
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ last_index1 = index;
+ }
+
+ x = x_offset
+ + globals.blend_inner_cachex2[LEFT][j][i];
+ y = curve_start_offset
+ + globals.blend_inner_cachey2[LEFT][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index2)
+ {
+ if (i < steps / 4)
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ else
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ last_index2 = index;
+ }
+ }
+}
+
+static void
+darken_up_bump (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint y_offset,
+ gint curve_start_offset,
+ gint steps,
+ gdouble delta,
+ gint counter)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint last_index1 = -1;
+ gint last_index2 = -1;
+ gint rowstride;
+ gint temp;
+ gint j = counter;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = curve_start_offset
+ + globals.blend_outer_cachex1[UP][j][i];
+ y = y_offset
+ + globals.blend_outer_cachey1[UP][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index1)
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ last_index1 = index;
+ }
+
+ x = curve_start_offset
+ + globals.blend_outer_cachex2[UP][j][i];
+ y = y_offset
+ + globals.blend_outer_cachey2[UP][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index2)
+ {
+ if (i < steps / 4)
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ else
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ last_index2 = index;
+ }
+ }
+}
+
+static void
+lighten_up_bump (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint y_offset,
+ gint curve_start_offset,
+ gint steps,
+ gdouble delta,
+ gint counter)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint last_index1 = -1;
+ gint last_index2 = -1;
+ gint rowstride;
+ gint temp;
+ gint j = counter;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = curve_start_offset
+ + globals.blend_inner_cachex1[UP][j][i];
+ y = y_offset
+ + globals.blend_inner_cachey1[UP][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index1)
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ last_index1 = index;
+ }
+
+ x = curve_start_offset
+ + globals.blend_inner_cachex2[UP][j][i];
+ y = y_offset
+ + globals.blend_inner_cachey2[UP][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index2)
+ {
+ if (i < steps / 4)
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ else
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ last_index2 = index;
+ }
+ }
+}
+
+static void
+darken_down_bump (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint y_offset,
+ gint curve_start_offset,
+ gint steps,
+ gdouble delta,
+ gint counter)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint last_index1 = -1;
+ gint last_index2 = -1;
+ gint rowstride;
+ gint temp;
+ gint j = counter;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = curve_start_offset
+ + globals.blend_inner_cachex1[DOWN][j][i];
+ y = y_offset
+ + globals.blend_inner_cachey1[DOWN][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index1)
+ {
+ if (i < steps / 1.2)
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ else
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ last_index1 = index;
+ }
+
+ x = curve_start_offset
+ + globals.blend_inner_cachex2[DOWN][j][i];
+ y = y_offset
+ + globals.blend_inner_cachey2[DOWN][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index2)
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ last_index2 = index;
+ }
+ }
+}
+
+static void
+lighten_down_bump (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint y_offset,
+ gint curve_start_offset,
+ gint steps,
+ gdouble delta,
+ gint counter)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint last_index1 = -1;
+ gint last_index2 = -1;
+ gint rowstride;
+ gint temp;
+ gint j = counter;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = curve_start_offset
+ + globals.blend_outer_cachex1[DOWN][j][i];
+ y = y_offset
+ + globals.blend_outer_cachey1[DOWN][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index1)
+ {
+ if (i < steps / 1.2)
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ else
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ }
+ last_index1 = index;
+ }
+
+ x = curve_start_offset
+ + globals.blend_outer_cachex2[DOWN][j][i];
+ y = y_offset
+ + globals.blend_outer_cachey2[DOWN][j][i];
+ index = y * rowstride + x * bytes;
+ if (index != last_index2)
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ last_index2 = index;
+ }
+ }
+}
+
+static void
+draw_bezier_line (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint steps,
+ gint *cx,
+ gint *cy)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint rowstride;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = cx[i];
+ y = cy[i];
+ index = y * rowstride + x * bytes;
+ DRAW_POINT (buffer, bufsize, index);
+ }
+}
+
+static void
+darken_bezier_line (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint x_offset,
+ gint y_offset,
+ gint steps,
+ gint *cx,
+ gint *cy,
+ gdouble delta)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint last_index = -1;
+ gint rowstride;
+ gint temp;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = cx[i] + x_offset;
+ y = cy[i] + y_offset;
+ index = y * rowstride + x * bytes;
+ if (index != last_index)
+ {
+ DARKEN_POINT (buffer, bufsize, index, delta, temp);
+ last_index = index;
+ }
+ }
+}
+
+static void
+lighten_bezier_line (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint bytes,
+ gint x_offset,
+ gint y_offset,
+ gint steps,
+ gint *cx,
+ gint *cy,
+ gdouble delta)
+{
+ gint i;
+ gint x, y;
+ gint index;
+ gint last_index = -1;
+ gint rowstride;
+ gint temp;
+
+ rowstride = bytes * width;
+
+ for (i = 0; i < steps; i++)
+ {
+ x = cx[i] + x_offset;
+ y = cy[i] + y_offset;
+ index = y * rowstride + x * bytes;
+ if (index != last_index)
+ {
+ LIGHTEN_POINT (buffer, bufsize, index, delta, temp);
+ last_index = index;
+ }
+ }
+}
+
+static void
+draw_bezier_vertical_border (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint height,
+ gint bytes,
+ gint x_offset,
+ gint xtiles,
+ gint ytiles,
+ gint blend_lines,
+ gdouble blend_amount,
+ gint steps)
+{
+ gint i, j;
+ gint tile_width = width / xtiles;
+ gint tile_height = height / ytiles;
+ gint tile_height_eighth = tile_height / 8;
+ gint curve_start_offset = 3 * tile_height_eighth;
+ gint curve_end_offset = curve_start_offset + 2 * tile_height_eighth;
+ gint px[4], py[4];
+ gint y_offset = 0;
+ gdouble delta;
+ gdouble sigma = blend_amount / blend_lines;
+ gint right;
+ gint *cachex, *cachey;
+
+ cachex = g_new (gint, steps);
+ cachey = g_new (gint, steps);
+
+ for (i = 0; i < ytiles; i++)
+ {
+ right = g_random_int_range (0, 2);
+
+ px[0] = px[3] = x_offset;
+ px[1] = x_offset + WALL_XFACTOR2 * tile_width * FUDGE;
+ px[2] = x_offset + WALL_XFACTOR3 * tile_width * FUDGE;
+ py[0] = y_offset;
+ py[1] = y_offset + WALL_YCONS2 * tile_height;
+ py[2] = y_offset + WALL_YCONS3 * tile_height;
+ py[3] = y_offset + curve_start_offset;
+
+ if (right)
+ {
+ px[1] = x_offset - WALL_XFACTOR2 * tile_width;
+ px[2] = x_offset - WALL_XFACTOR3 * tile_width;
+ }
+ generate_bezier (px, py, steps, cachex, cachey);
+ draw_bezier_line (buffer, bufsize, width, bytes, steps, cachex, cachey);
+ delta = blend_amount;
+ for (j = 0; j < blend_lines; j++)
+ {
+ px[0] = -j - 1;
+ darken_bezier_line (buffer, bufsize, width, bytes, px[0], 0,
+ steps, cachex, cachey, delta);
+ px[0] = j + 1;
+ lighten_bezier_line (buffer, bufsize, width, bytes, px[0], 0,
+ steps, cachex, cachey, delta);
+ delta -= sigma;
+ }
+ if (right)
+ {
+ draw_right_bump (buffer, bufsize, width, bytes, x_offset,
+ y_offset + curve_start_offset,
+ globals.steps[RIGHT]);
+ delta = blend_amount;
+ for (j = 0; j < blend_lines; j++)
+ {
+ /* use to be -j -1 */
+ darken_right_bump (buffer, bufsize, width, bytes, x_offset,
+ y_offset + curve_start_offset,
+ globals.steps[RIGHT], delta, j);
+ /* use to be +j + 1 */
+ lighten_right_bump (buffer, bufsize, width, bytes, x_offset,
+ y_offset + curve_start_offset,
+ globals.steps[RIGHT], delta, j);
+ delta -= sigma;
+ }
+ }
+ else
+ {
+ draw_left_bump (buffer, bufsize, width, bytes, x_offset,
+ y_offset + curve_start_offset,
+ globals.steps[LEFT]);
+ delta = blend_amount;
+ for (j = 0; j < blend_lines; j++)
+ {
+ /* use to be -j -1 */
+ darken_left_bump (buffer, bufsize, width, bytes, x_offset,
+ y_offset + curve_start_offset,
+ globals.steps[LEFT], delta, j);
+ /* use to be -j - 1 */
+ lighten_left_bump (buffer, bufsize, width, bytes, x_offset,
+ y_offset + curve_start_offset,
+ globals.steps[LEFT], delta, j);
+ delta -= sigma;
+ }
+ }
+ px[0] = px[3] = x_offset;
+ px[1] = x_offset + WALL_XFACTOR2 * tile_width * FUDGE;
+ px[2] = x_offset + WALL_XFACTOR3 * tile_width * FUDGE;
+ py[0] = y_offset + curve_end_offset;
+ py[1] = y_offset + curve_end_offset + WALL_YCONS2 * tile_height;
+ py[2] = y_offset + curve_end_offset + WALL_YCONS3 * tile_height;
+ py[3] = globals.gridy[i];
+ if (right)
+ {
+ px[1] = x_offset - WALL_XFACTOR2 * tile_width;
+ px[2] = x_offset - WALL_XFACTOR3 * tile_width;
+ }
+ generate_bezier (px, py, steps, cachex, cachey);
+ draw_bezier_line (buffer, bufsize, width, bytes, steps, cachex, cachey);
+ delta = blend_amount;
+ for (j = 0; j < blend_lines; j++)
+ {
+ px[0] = -j - 1;
+ darken_bezier_line (buffer, bufsize, width, bytes, px[0], 0,
+ steps, cachex, cachey, delta);
+ px[0] = j + 1;
+ lighten_bezier_line (buffer, bufsize, width, bytes, px[0], 0,
+ steps, cachex, cachey, delta);
+ delta -= sigma;
+ }
+ y_offset = globals.gridy[i];
+ } /* for */
+ g_free(cachex);
+ g_free(cachey);
+}
+
+static void
+draw_bezier_horizontal_border (guchar *buffer,
+ gint bufsize,
+ gint width,
+ gint height,
+ gint bytes,
+ gint y_offset,
+ gint xtiles,
+ gint ytiles,
+ gint blend_lines,
+ gdouble blend_amount,
+ gint steps)
+{
+ gint i, j;
+ gint tile_width = width / xtiles;
+ gint tile_height = height / ytiles;
+ gint tile_width_eighth = tile_width / 8;
+ gint curve_start_offset = 3 * tile_width_eighth;
+ gint curve_end_offset = curve_start_offset + 2 * tile_width_eighth;
+ gint px[4], py[4];
+ gint x_offset = 0;
+ gdouble delta;
+ gdouble sigma = blend_amount / blend_lines;
+ gint up;
+ gint *cachex, *cachey;
+
+ cachex = g_new (gint, steps);
+ cachey = g_new (gint, steps);
+
+ for (i = 0; i < xtiles; i++)
+ {
+ up = g_random_int_range (0, 2);
+
+ px[0] = x_offset;
+ px[1] = x_offset + WALL_XCONS2 * tile_width;
+ px[2] = x_offset + WALL_XCONS3 * tile_width;
+ px[3] = x_offset + curve_start_offset;
+ py[0] = py[3] = y_offset;
+ py[1] = y_offset + WALL_YFACTOR2 * tile_height * FUDGE;
+ py[2] = y_offset + WALL_YFACTOR3 * tile_height * FUDGE;
+ if (!up)
+ {
+ py[1] = y_offset - WALL_YFACTOR2 * tile_height;
+ py[2] = y_offset - WALL_YFACTOR3 * tile_height;
+ }
+ generate_bezier (px, py, steps, cachex, cachey);
+ draw_bezier_line (buffer, bufsize, width, bytes, steps, cachex, cachey);
+ delta = blend_amount;
+ for (j = 0; j < blend_lines; j++)
+ {
+ py[0] = -j - 1;
+ darken_bezier_line (buffer, bufsize, width, bytes, 0, py[0],
+ steps, cachex, cachey, delta);
+ py[0] = j + 1;
+ lighten_bezier_line (buffer, bufsize, width, bytes, 0, py[0],
+ steps, cachex, cachey, delta);
+ delta -= sigma;
+ }
+ /* bumps */
+ if (up)
+ {
+ draw_up_bump (buffer, bufsize, width, bytes, y_offset,
+ x_offset + curve_start_offset,
+ globals.steps[UP]);
+ delta = blend_amount;
+ for (j = 0; j < blend_lines; j++)
+ {
+ /* use to be -j -1 */
+ darken_up_bump (buffer, bufsize, width, bytes, y_offset,
+ x_offset + curve_start_offset,
+ globals.steps[UP], delta, j);
+ /* use to be +j + 1 */
+ lighten_up_bump (buffer, bufsize, width, bytes, y_offset,
+ x_offset + curve_start_offset,
+ globals.steps[UP], delta, j);
+ delta -= sigma;
+ }
+ }
+ else
+ {
+ draw_down_bump (buffer, bufsize, width, bytes, y_offset,
+ x_offset + curve_start_offset,
+ globals.steps[DOWN]);
+ delta = blend_amount;
+ for (j = 0; j < blend_lines; j++)
+ {
+ /* use to be +j + 1 */
+ darken_down_bump (buffer, bufsize, width, bytes, y_offset,
+ x_offset + curve_start_offset,
+ globals.steps[DOWN], delta, j);
+ /* use to be -j -1 */
+ lighten_down_bump (buffer, bufsize, width, bytes, y_offset,
+ x_offset + curve_start_offset,
+ globals.steps[DOWN], delta, j);
+ delta -= sigma;
+ }
+ }
+ /* ending side wall line */
+ px[0] = x_offset + curve_end_offset;
+ px[1] = x_offset + curve_end_offset + WALL_XCONS2 * tile_width;
+ px[2] = x_offset + curve_end_offset + WALL_XCONS3 * tile_width;
+ px[3] = globals.gridx[i];
+ py[0] = py[3] = y_offset;
+ py[1] = y_offset + WALL_YFACTOR2 * tile_height * FUDGE;
+ py[2] = y_offset + WALL_YFACTOR3 * tile_height * FUDGE;
+ if (!up)
+ {
+ py[1] = y_offset - WALL_YFACTOR2 * tile_height;
+ py[2] = y_offset - WALL_YFACTOR3 * tile_height;
+ }
+ generate_bezier (px, py, steps, cachex, cachey);
+ draw_bezier_line (buffer, bufsize, width, bytes, steps, cachex, cachey);
+ delta = blend_amount;
+ for (j = 0; j < blend_lines; j++)
+ {
+ py[0] = -j - 1;
+ darken_bezier_line (buffer, bufsize, width, bytes, 0, py[0],
+ steps, cachex, cachey, delta);
+ py[0] = j + 1;
+ lighten_bezier_line (buffer, bufsize, width, bytes, 0, py[0],
+ steps, cachex, cachey, delta);
+ delta -= sigma;
+ }
+ x_offset = globals.gridx[i];
+ } /* for */
+ g_free(cachex);
+ g_free(cachey);
+}
+
+static void
+check_config (gint width,
+ gint height)
+{
+ gint tile_width, tile_height;
+ gint tile_width_limit, tile_height_limit;
+
+ if (config.x < 1)
+ {
+ config.x = 1;
+ }
+ if (config.y < 1)
+ {
+ config.y = 1;
+ }
+ if (config.blend_amount < 0)
+ {
+ config.blend_amount = 0;
+ }
+ if (config.blend_amount > 5)
+ {
+ config.blend_amount = 5;
+ }
+ tile_width = width / config.x;
+ tile_height = height / config.y;
+ tile_width_limit = 0.4 * tile_width;
+ tile_height_limit = 0.4 * tile_height;
+ if ((config.blend_lines > tile_width_limit)
+ || (config.blend_lines > tile_height_limit))
+ {
+ config.blend_lines = MIN(tile_width_limit, tile_height_limit);
+ }
+}
+
+/********************************************************
+ GUI
+********************************************************/
+
+static gboolean
+jigsaw_dialog (guint32 drawable_id)
+{
+ GtkWidget *dialog;
+ GtkWidget *main_vbox;
+ GtkWidget *preview;
+ GtkSizeGroup *group;
+ GtkWidget *frame;
+ GtkWidget *rbutton1;
+ GtkWidget *rbutton2;
+ GtkWidget *table;
+ GtkObject *adj;
+ gboolean run;
+
+ gimp_ui_init (PLUG_IN_BINARY, TRUE);
+
+ dialog = gimp_dialog_new (_("Jigsaw"), PLUG_IN_ROLE,
+ NULL, 0,
+ gimp_standard_help_func, PLUG_IN_PROC,
+
+ _("_Cancel"), GTK_RESPONSE_CANCEL,
+ _("_OK"), GTK_RESPONSE_OK,
+
+ NULL);
+
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+ GTK_RESPONSE_OK,
+ GTK_RESPONSE_CANCEL,
+ -1);
+
+ gimp_window_set_transient (GTK_WINDOW (dialog));
+
+ main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
+ gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
+ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+ main_vbox, TRUE, TRUE, 0);
+ gtk_widget_show (main_vbox);
+
+ preview = gimp_aspect_preview_new_from_drawable_id (drawable_id);
+ gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0);
+ gtk_widget_show (preview);
+
+ g_signal_connect_swapped (preview, "invalidated",
+ G_CALLBACK (jigsaw_preview),
+ GINT_TO_POINTER (drawable_id));
+
+ frame = gimp_frame_new (_("Number of Tiles"));
+ gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
+
+ table = gtk_table_new (2, 3, FALSE);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+ gtk_container_add (GTK_CONTAINER (frame), table);
+
+ group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+ /* xtiles */
+ adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
+ _("_Horizontal:"), SCALE_WIDTH, 0,
+ config.x, MIN_XTILES, MAX_XTILES, 1.0, 4.0, 0,
+ TRUE, 0, 0,
+ _("Number of pieces going across"), NULL);
+
+ gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
+ g_object_unref (group);
+
+ g_signal_connect (adj, "value-changed",
+ G_CALLBACK (gimp_int_adjustment_update),
+ &config.x);
+ g_signal_connect_swapped (adj, "value-changed",
+ G_CALLBACK (gimp_preview_invalidate),
+ preview);
+
+ /* ytiles */
+ adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
+ _("_Vertical:"), SCALE_WIDTH, 0,
+ config.y, MIN_YTILES, MAX_YTILES, 1.0, 4.0, 0,
+ TRUE, 0, 0,
+ _("Number of pieces going down"), NULL);
+
+ gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
+
+ g_signal_connect (adj, "value-changed",
+ G_CALLBACK (gimp_int_adjustment_update),
+ &config.y);
+ g_signal_connect_swapped (adj, "value-changed",
+ G_CALLBACK (gimp_preview_invalidate),
+ preview);
+
+ gtk_widget_show (table);
+ gtk_widget_show (frame);
+
+ frame = gimp_frame_new (_("Bevel Edges"));
+ gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
+
+ table = gtk_table_new (2, 3, FALSE);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+ gtk_container_add (GTK_CONTAINER (frame), table);
+
+ /* number of blending lines */
+ adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
+ _("_Bevel width:"), SCALE_WIDTH, 4,
+ config.blend_lines,
+ MIN_BLEND_LINES, MAX_BLEND_LINES, 1.0, 2.0, 0,
+ TRUE, 0, 0,
+ _("Degree of slope of each piece's edge"), NULL);
+
+ gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
+
+ g_signal_connect (adj, "value-changed",
+ G_CALLBACK (gimp_int_adjustment_update),
+ &config.blend_lines);
+ g_signal_connect_swapped (adj, "value-changed",
+ G_CALLBACK (gimp_preview_invalidate),
+ preview);
+
+ /* blending amount */
+ adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
+ _("H_ighlight:"), SCALE_WIDTH, 4,
+ config.blend_amount,
+ MIN_BLEND_AMOUNT, MAX_BLEND_AMOUNT, 0.05, 0.1, 2,
+ TRUE, 0, 0,
+ _("The amount of highlighting on the edges "
+ "of each piece"), NULL);
+
+ gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
+
+ g_signal_connect (adj, "value-changed",
+ G_CALLBACK (gimp_double_adjustment_update),
+ &config.blend_amount);
+ g_signal_connect_swapped (adj, "value-changed",
+ G_CALLBACK (gimp_preview_invalidate),
+ preview);
+
+ gtk_widget_show (table);
+ gtk_widget_show (frame);
+
+ /* frame for primitive radio buttons */
+
+ frame = gimp_int_radio_group_new (TRUE, _("Jigsaw Style"),
+ G_CALLBACK (gimp_radio_button_update),
+ &config.style, config.style,
+
+ _("_Square"), BEZIER_1, &rbutton1,
+ _("C_urved"), BEZIER_2, &rbutton2,
+
+ NULL);
+
+ gimp_help_set_help_data (rbutton1, _("Each piece has straight sides"), NULL);
+ gimp_help_set_help_data (rbutton2, _("Each piece has curved sides"), NULL);
+ g_signal_connect_swapped (rbutton1, "toggled",
+ G_CALLBACK (gimp_preview_invalidate),
+ preview);
+ g_signal_connect_swapped (rbutton2, "toggled",
+ G_CALLBACK (gimp_preview_invalidate),
+ preview);
+
+ gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
+ gtk_widget_show (frame);
+
+ gtk_widget_show (dialog);
+
+ run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
+
+ gtk_widget_destroy (dialog);
+
+ return run;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-22 09:38:40 +0000