graphics/gimp
graphics/gimp
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp synced 2024-10-19 22:34:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

This time it wiLL WOORRRRKKKKKK !!!!!!!!!!!!!!!!!!!!!

Browse source 
--Sven
This commit is contained in:
Sven Neumann 1999-03-18 01:28:45 +00:00
parent c7878365ab
commit 793d237155
88 changed files with 3590 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
ChangeLog
View file

@ -1,3 +1,13 @@
Thu Mar 18 02:12:26 MET 1999 Sven Neumann <sven@gimp.org>
* configure.in
* plug-ins/Makefile.am
* plug-ins/gap/* (new files)
Added the GAP (GIMP Animation Plugin) created by Wolfgang
Hofer. Eventually we'll think about making this a
seperate package, but now it's here for testing and your
pleasure.
Wed Mar 17 21:46:08 MET 1999 Sven Neumann <sven@gimp.org>
* app/plug-ins/exchange/exchange.c: fixed NON_INTERACTIVE

1
configure.in
View file

@ -719,6 +719,7 @@ plug-ins/flame/Makefile
plug-ins/flarefx/Makefile
plug-ins/fp/Makefile
plug-ins/fractaltrace/Makefile
plug-ins/gap/Makefile
plug-ins/gauss_iir/Makefile
plug-ins/gauss_rle/Makefile
plug-ins/gbr/Makefile

1
plug-ins/Makefile.am
View file

@ -56,6 +56,7 @@ SUBDIRS = \
flarefx \
fp \
fractaltrace \
gap \
gauss_iir \
gauss_rle \
gbr \

18
plug-ins/gap/iter_ALT/README_iter_subdirs Normal file
View file

@ -0,0 +1,18 @@
Subdirectorys for Iterator_ALT Procedure include files.
gen ... Contains the unchanged Generated Code
some of the generated iterators (that did not work)
were moved to Subdirectory gen_deleted
(gen_deleted is not part of the gap release tar-file)
mod ... Contains the Hand-Modified Code
for those Plugins where the generated iter_ALT
Code did not work.
(their Last-Value Buffer structure did not
math the PDB-Paraeter description)
old ... Contains Hand-Modified (or generated) old
Iterators.
(For Plugins that are not part of gimp 1.1.3
but once were part of gimp 1.0 or prior releases)

32
plug-ins/gap/iter_ALT/gen/plug_in_CML_explorer_iter_ALT.inc Normal file
View file

@ -0,0 +1,32 @@
/* ----------------------------------------------------------------------
* p_plug_in_CML_explorer_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_CML_explorer_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_CML_explorer_Vals
{
char * parameter_file_name;
} t_plug_in_CML_explorer_Vals;
t_plug_in_CML_explorer_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_CML_explorer_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_CML_explorer_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_CML_explorer_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_CML_explorer_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_CML_explorer_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_CML_explorer_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_CML_explorer_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
gimp_set_data("plug_in_CML_explorer", &buf, sizeof(buf));
return 0; /* OK */
}

33
plug-ins/gap/iter_ALT/gen/plug_in_alpha2color_iter_ALT.inc Normal file
View file

@ -0,0 +1,33 @@
/* ----------------------------------------------------------------------
* p_plug_in_alpha2color_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_alpha2color_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_alpha2color_Vals
{
t_color Color;
} t_plug_in_alpha2color_Vals;
t_plug_in_alpha2color_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_alpha2color_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_alpha2color_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_alpha2color_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_alpha2color_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_alpha2color_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_alpha2color_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_alpha2color_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_color(&buf.Color, &buf_from->Color, &buf_to->Color, total_steps, current_step);
gimp_set_data("plug_in_alpha2color", &buf, sizeof(buf));
return 0; /* OK */
}

39
plug-ins/gap/iter_ALT/gen/plug_in_blinds_iter_ALT.inc Normal file
View file

@ -0,0 +1,39 @@
/* ----------------------------------------------------------------------
* p_plug_in_blinds_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_blinds_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_blinds_Vals
{
long angle_dsp;
long number_of_segments;
long orientation;
long backgndg_trans;
} t_plug_in_blinds_Vals;
t_plug_in_blinds_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_blinds_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_blinds_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_blinds_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_blinds_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_blinds_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_blinds_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_blinds_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.angle_dsp, buf_from->angle_dsp, buf_to->angle_dsp, total_steps, current_step);
p_delta_long(&buf.number_of_segments, buf_from->number_of_segments, buf_to->number_of_segments, total_steps, current_step);
p_delta_long(&buf.orientation, buf_from->orientation, buf_to->orientation, total_steps, current_step);
p_delta_long(&buf.backgndg_trans, buf_from->backgndg_trans, buf_to->backgndg_trans, total_steps, current_step);
gimp_set_data("plug_in_blinds", &buf, sizeof(buf));
return 0; /* OK */
}

35
plug-ins/gap/iter_ALT/gen/plug_in_borderaverage_iter_ALT.inc Normal file
View file

@ -0,0 +1,35 @@
/* ----------------------------------------------------------------------
* p_plug_in_borderaverage_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_borderaverage_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_borderaverage_Vals
{
long thickness;
long bucket_exponent;
} t_plug_in_borderaverage_Vals;
t_plug_in_borderaverage_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_borderaverage_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_borderaverage_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_borderaverage_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_borderaverage_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_borderaverage_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_borderaverage_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_borderaverage_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.thickness, buf_from->thickness, buf_to->thickness, total_steps, current_step);
p_delta_long(&buf.bucket_exponent, buf_from->bucket_exponent, buf_to->bucket_exponent, total_steps, current_step);
gimp_set_data("plug_in_borderaverage", &buf, sizeof(buf));
return 0; /* OK */
}

53
plug-ins/gap/iter_ALT/gen/plug_in_bump_map_iter_ALT.inc Normal file
View file

@ -0,0 +1,53 @@
/* ----------------------------------------------------------------------
* p_plug_in_bump_map_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_bump_map_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_bump_map_Vals
{
gint32 bumpmap;
gdouble azimuth;
gdouble elevation;
long depth;
long xofs;
long yofs;
long waterlevel;
long ambient;
long compensate;
long invert;
long type;
} t_plug_in_bump_map_Vals;
t_plug_in_bump_map_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_bump_map_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_bump_map_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_bump_map_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_bump_map_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_bump_map_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_bump_map_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_bump_map_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_drawable(&buf.bumpmap, buf_from->bumpmap, buf_to->bumpmap, total_steps, current_step);
p_delta_gdouble(&buf.azimuth, buf_from->azimuth, buf_to->azimuth, total_steps, current_step);
p_delta_gdouble(&buf.elevation, buf_from->elevation, buf_to->elevation, total_steps, current_step);
p_delta_long(&buf.depth, buf_from->depth, buf_to->depth, total_steps, current_step);
p_delta_long(&buf.xofs, buf_from->xofs, buf_to->xofs, total_steps, current_step);
p_delta_long(&buf.yofs, buf_from->yofs, buf_to->yofs, total_steps, current_step);
p_delta_long(&buf.waterlevel, buf_from->waterlevel, buf_to->waterlevel, total_steps, current_step);
p_delta_long(&buf.ambient, buf_from->ambient, buf_to->ambient, total_steps, current_step);
p_delta_long(&buf.compensate, buf_from->compensate, buf_to->compensate, total_steps, current_step);
p_delta_long(&buf.invert, buf_from->invert, buf_to->invert, total_steps, current_step);
p_delta_long(&buf.type, buf_from->type, buf_to->type, total_steps, current_step);
gimp_set_data("plug_in_bump_map", &buf, sizeof(buf));
return 0; /* OK */
}

35
plug-ins/gap/iter_ALT/gen/plug_in_checkerboard_iter_ALT.inc Normal file
View file

@ -0,0 +1,35 @@
/* ----------------------------------------------------------------------
* p_plug_in_checkerboard_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_checkerboard_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_checkerboard_Vals
{
long check_mode;
long check_size;
} t_plug_in_checkerboard_Vals;
t_plug_in_checkerboard_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_checkerboard_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_checkerboard_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_checkerboard_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_checkerboard_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_checkerboard_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_checkerboard_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_checkerboard_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.check_mode, buf_from->check_mode, buf_to->check_mode, total_steps, current_step);
p_delta_long(&buf.check_size, buf_from->check_size, buf_to->check_size, total_steps, current_step);
gimp_set_data("plug_in_checkerboard", &buf, sizeof(buf));
return 0; /* OK */
}

41
plug-ins/gap/iter_ALT/gen/plug_in_color_map_iter_ALT.inc Normal file
View file

@ -0,0 +1,41 @@
/* ----------------------------------------------------------------------
* p_plug_in_color_map_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_color_map_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_color_map_Vals
{
t_color srccolor_1;
t_color srccolor_2;
t_color dstcolor_1;
t_color dstcolor_2;
long map_mode;
} t_plug_in_color_map_Vals;
t_plug_in_color_map_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_color_map_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_color_map_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_color_map_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_color_map_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_color_map_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_color_map_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_color_map_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_color(&buf.srccolor_1, &buf_from->srccolor_1, &buf_to->srccolor_1, total_steps, current_step);
p_delta_color(&buf.srccolor_2, &buf_from->srccolor_2, &buf_to->srccolor_2, total_steps, current_step);
p_delta_color(&buf.dstcolor_1, &buf_from->dstcolor_1, &buf_to->dstcolor_1, total_steps, current_step);
p_delta_color(&buf.dstcolor_2, &buf_from->dstcolor_2, &buf_to->dstcolor_2, total_steps, current_step);
p_delta_long(&buf.map_mode, buf_from->map_mode, buf_to->map_mode, total_steps, current_step);
gimp_set_data("plug_in_color_map", &buf, sizeof(buf));
return 0; /* OK */
}

33
plug-ins/gap/iter_ALT/gen/plug_in_colorify_iter_ALT.inc Normal file
View file

@ -0,0 +1,33 @@
/* ----------------------------------------------------------------------
* p_plug_in_colorify_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_colorify_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_colorify_Vals
{
t_color color;
} t_plug_in_colorify_Vals;
t_plug_in_colorify_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_colorify_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_colorify_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_colorify_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_colorify_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_colorify_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_colorify_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_colorify_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_color(&buf.color, &buf_from->color, &buf_to->color, total_steps, current_step);
gimp_set_data("plug_in_colorify", &buf, sizeof(buf));
return 0; /* OK */
}

31
plug-ins/gap/iter_ALT/gen/plug_in_convmatrix_iter_ALT.inc Normal file
View file

@ -0,0 +1,31 @@
/* ----------------------------------------------------------------------
* p_plug_in_convmatrix_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_convmatrix_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_convmatrix_Vals
{
} t_plug_in_convmatrix_Vals;
t_plug_in_convmatrix_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_convmatrix_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_convmatrix_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_convmatrix_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_convmatrix_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_convmatrix_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_convmatrix_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_convmatrix_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
gimp_set_data("plug_in_convmatrix", &buf, sizeof(buf));
return 0; /* OK */
}

37
plug-ins/gap/iter_ALT/gen/plug_in_cubism_iter_ALT.inc Normal file
View file

@ -0,0 +1,37 @@
/* ----------------------------------------------------------------------
* p_plug_in_cubism_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_cubism_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_cubism_Vals
{
gdouble tile_size;
gdouble tile_saturation;
long bg_color;
} t_plug_in_cubism_Vals;
t_plug_in_cubism_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_cubism_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_cubism_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_cubism_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_cubism_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_cubism_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_cubism_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_cubism_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.tile_size, buf_from->tile_size, buf_to->tile_size, total_steps, current_step);
p_delta_gdouble(&buf.tile_saturation, buf_from->tile_saturation, buf_to->tile_saturation, total_steps, current_step);
p_delta_long(&buf.bg_color, buf_from->bg_color, buf_to->bg_color, total_steps, current_step);
gimp_set_data("plug_in_cubism", &buf, sizeof(buf));
return 0; /* OK */
}

33
plug-ins/gap/iter_ALT/gen/plug_in_destripe_iter_ALT.inc Normal file
View file

@ -0,0 +1,33 @@
/* ----------------------------------------------------------------------
* p_plug_in_destripe_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_destripe_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_destripe_Vals
{
long avg_width;
} t_plug_in_destripe_Vals;
t_plug_in_destripe_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_destripe_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_destripe_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_destripe_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_destripe_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_destripe_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_destripe_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_destripe_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.avg_width, buf_from->avg_width, buf_to->avg_width, total_steps, current_step);
gimp_set_data("plug_in_destripe", &buf, sizeof(buf));
return 0; /* OK */
}

55
plug-ins/gap/iter_ALT/gen/plug_in_diffraction_iter_ALT.inc Normal file
View file

@ -0,0 +1,55 @@
/* ----------------------------------------------------------------------
* p_plug_in_diffraction_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_diffraction_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_diffraction_Vals
{
gdouble lam_r;
gdouble lam_g;
gdouble lam_b;
gdouble contour_r;
gdouble contour_g;
gdouble contour_b;
gdouble edges_r;
gdouble edges_g;
gdouble edges_b;
gdouble brightness;
gdouble scattering;
gdouble polarization;
} t_plug_in_diffraction_Vals;
t_plug_in_diffraction_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_diffraction_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_diffraction_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_diffraction_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_diffraction_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_diffraction_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_diffraction_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_diffraction_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.lam_r, buf_from->lam_r, buf_to->lam_r, total_steps, current_step);
p_delta_gdouble(&buf.lam_g, buf_from->lam_g, buf_to->lam_g, total_steps, current_step);
p_delta_gdouble(&buf.lam_b, buf_from->lam_b, buf_to->lam_b, total_steps, current_step);
p_delta_gdouble(&buf.contour_r, buf_from->contour_r, buf_to->contour_r, total_steps, current_step);
p_delta_gdouble(&buf.contour_g, buf_from->contour_g, buf_to->contour_g, total_steps, current_step);
p_delta_gdouble(&buf.contour_b, buf_from->contour_b, buf_to->contour_b, total_steps, current_step);
p_delta_gdouble(&buf.edges_r, buf_from->edges_r, buf_to->edges_r, total_steps, current_step);
p_delta_gdouble(&buf.edges_g, buf_from->edges_g, buf_to->edges_g, total_steps, current_step);
p_delta_gdouble(&buf.edges_b, buf_from->edges_b, buf_to->edges_b, total_steps, current_step);
p_delta_gdouble(&buf.brightness, buf_from->brightness, buf_to->brightness, total_steps, current_step);
p_delta_gdouble(&buf.scattering, buf_from->scattering, buf_to->scattering, total_steps, current_step);
p_delta_gdouble(&buf.polarization, buf_from->polarization, buf_to->polarization, total_steps, current_step);
gimp_set_data("plug_in_diffraction", &buf, sizeof(buf));
return 0; /* OK */
}

45
plug-ins/gap/iter_ALT/gen/plug_in_displace_iter_ALT.inc Normal file
View file

@ -0,0 +1,45 @@
/* ----------------------------------------------------------------------
* p_plug_in_displace_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_displace_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_displace_Vals
{
gdouble amount_x;
gdouble amount_y;
long do_x;
long do_y;
gint32 displace_map_x;
gint32 displace_map_y;
long displace_type;
} t_plug_in_displace_Vals;
t_plug_in_displace_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_displace_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_displace_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_displace_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_displace_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_displace_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_displace_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_displace_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.amount_x, buf_from->amount_x, buf_to->amount_x, total_steps, current_step);
p_delta_gdouble(&buf.amount_y, buf_from->amount_y, buf_to->amount_y, total_steps, current_step);
p_delta_long(&buf.do_x, buf_from->do_x, buf_to->do_x, total_steps, current_step);
p_delta_long(&buf.do_y, buf_from->do_y, buf_to->do_y, total_steps, current_step);
p_delta_drawable(&buf.displace_map_x, buf_from->displace_map_x, buf_to->displace_map_x, total_steps, current_step);
p_delta_drawable(&buf.displace_map_y, buf_from->displace_map_y, buf_to->displace_map_y, total_steps, current_step);
p_delta_long(&buf.displace_type, buf_from->displace_type, buf_to->displace_type, total_steps, current_step);
gimp_set_data("plug_in_displace", &buf, sizeof(buf));
return 0; /* OK */
}

35
plug-ins/gap/iter_ALT/gen/plug_in_edge_iter_ALT.inc Normal file
View file

@ -0,0 +1,35 @@
/* ----------------------------------------------------------------------
* p_plug_in_edge_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_edge_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_edge_Vals
{
gdouble amount;
long wrapmode;
} t_plug_in_edge_Vals;
t_plug_in_edge_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_edge_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_edge_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_edge_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_edge_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_edge_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_edge_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_edge_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.amount, buf_from->amount, buf_to->amount, total_steps, current_step);
p_delta_long(&buf.wrapmode, buf_from->wrapmode, buf_to->wrapmode, total_steps, current_step);
gimp_set_data("plug_in_edge", &buf, sizeof(buf));
return 0; /* OK */
}

35
plug-ins/gap/iter_ALT/gen/plug_in_engrave_iter_ALT.inc Normal file
View file

@ -0,0 +1,35 @@
/* ----------------------------------------------------------------------
* p_plug_in_engrave_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_engrave_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_engrave_Vals
{
long height;
long limit;
} t_plug_in_engrave_Vals;
t_plug_in_engrave_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_engrave_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_engrave_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_engrave_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_engrave_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_engrave_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_engrave_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_engrave_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.height, buf_from->height, buf_to->height, total_steps, current_step);
p_delta_long(&buf.limit, buf_from->limit, buf_to->limit, total_steps, current_step);
gimp_set_data("plug_in_engrave", &buf, sizeof(buf));
return 0; /* OK */
}

31
plug-ins/gap/iter_ALT/gen/plug_in_flame_iter_ALT.inc Normal file
View file

@ -0,0 +1,31 @@
/* ----------------------------------------------------------------------
* p_plug_in_flame_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_flame_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_flame_Vals
{
} t_plug_in_flame_Vals;
t_plug_in_flame_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_flame_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_flame_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_flame_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_flame_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_flame_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_flame_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_flame_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
gimp_set_data("plug_in_flame", &buf, sizeof(buf));
return 0; /* OK */
}

35
plug-ins/gap/iter_ALT/gen/plug_in_flarefx_iter_ALT.inc Normal file
View file

@ -0,0 +1,35 @@
/* ----------------------------------------------------------------------
* p_plug_in_flarefx_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_flarefx_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_flarefx_Vals
{
long posx;
long posy;
} t_plug_in_flarefx_Vals;
t_plug_in_flarefx_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_flarefx_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_flarefx_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_flarefx_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_flarefx_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_flarefx_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_flarefx_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_flarefx_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.posx, buf_from->posx, buf_to->posx, total_steps, current_step);
p_delta_long(&buf.posy, buf_from->posy, buf_to->posy, total_steps, current_step);
gimp_set_data("plug_in_flarefx", &buf, sizeof(buf));
return 0; /* OK */
}

43
plug-ins/gap/iter_ALT/gen/plug_in_fractal_trace_iter_ALT.inc Normal file
View file

@ -0,0 +1,43 @@
/* ----------------------------------------------------------------------
* p_plug_in_fractal_trace_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_fractal_trace_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_fractal_trace_Vals
{
gdouble xmin;
gdouble xmax;
gdouble ymin;
gdouble ymax;
long depth;
long outside_type;
} t_plug_in_fractal_trace_Vals;
t_plug_in_fractal_trace_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_fractal_trace_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_fractal_trace_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_fractal_trace_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_fractal_trace_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_fractal_trace_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_fractal_trace_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_fractal_trace_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.xmin, buf_from->xmin, buf_to->xmin, total_steps, current_step);
p_delta_gdouble(&buf.xmax, buf_from->xmax, buf_to->xmax, total_steps, current_step);
p_delta_gdouble(&buf.ymin, buf_from->ymin, buf_to->ymin, total_steps, current_step);
p_delta_gdouble(&buf.ymax, buf_from->ymax, buf_to->ymax, total_steps, current_step);
p_delta_long(&buf.depth, buf_from->depth, buf_to->depth, total_steps, current_step);
p_delta_long(&buf.outside_type, buf_from->outside_type, buf_to->outside_type, total_steps, current_step);
gimp_set_data("plug_in_fractal_trace", &buf, sizeof(buf));
return 0; /* OK */
}

37
plug-ins/gap/iter_ALT/gen/plug_in_gauss_iir_iter_ALT.inc Normal file
View file

@ -0,0 +1,37 @@
/* ----------------------------------------------------------------------
* p_plug_in_gauss_iir_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_gauss_iir_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_gauss_iir_Vals
{
gdouble radius;
long horizontal;
long vertical;
} t_plug_in_gauss_iir_Vals;
t_plug_in_gauss_iir_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_gauss_iir_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_gauss_iir_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_gauss_iir_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_gauss_iir_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_gauss_iir_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_gauss_iir_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_gauss_iir_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.radius, buf_from->radius, buf_to->radius, total_steps, current_step);
p_delta_long(&buf.horizontal, buf_from->horizontal, buf_to->horizontal, total_steps, current_step);
p_delta_long(&buf.vertical, buf_from->vertical, buf_to->vertical, total_steps, current_step);
gimp_set_data("plug_in_gauss_iir", &buf, sizeof(buf));
return 0; /* OK */
}

37
plug-ins/gap/iter_ALT/gen/plug_in_gauss_rle_iter_ALT.inc Normal file
View file

@ -0,0 +1,37 @@
/* ----------------------------------------------------------------------
* p_plug_in_gauss_rle_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_gauss_rle_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_gauss_rle_Vals
{
gdouble radius;
long horizontal;
long vertical;
} t_plug_in_gauss_rle_Vals;
t_plug_in_gauss_rle_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_gauss_rle_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_gauss_rle_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_gauss_rle_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_gauss_rle_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_gauss_rle_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_gauss_rle_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_gauss_rle_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.radius, buf_from->radius, buf_to->radius, total_steps, current_step);
p_delta_long(&buf.horizontal, buf_from->horizontal, buf_to->horizontal, total_steps, current_step);
p_delta_long(&buf.vertical, buf_from->vertical, buf_to->vertical, total_steps, current_step);
gimp_set_data("plug_in_gauss_rle", &buf, sizeof(buf));
return 0; /* OK */
}

33
plug-ins/gap/iter_ALT/gen/plug_in_gfig_iter_ALT.inc Normal file
View file

@ -0,0 +1,33 @@
/* ----------------------------------------------------------------------
* p_plug_in_gfig_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_gfig_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_gfig_Vals
{
long dummy;
} t_plug_in_gfig_Vals;
t_plug_in_gfig_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_gfig_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_gfig_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_gfig_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_gfig_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_gfig_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_gfig_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_gfig_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.dummy, buf_from->dummy, buf_to->dummy, total_steps, current_step);
gimp_set_data("plug_in_gfig", &buf, sizeof(buf));
return 0; /* OK */
}

35
plug-ins/gap/iter_ALT/gen/plug_in_glasstile_iter_ALT.inc Normal file
View file

@ -0,0 +1,35 @@
/* ----------------------------------------------------------------------
* p_plug_in_glasstile_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_glasstile_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_glasstile_Vals
{
long tilex;
long tiley;
} t_plug_in_glasstile_Vals;
t_plug_in_glasstile_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_glasstile_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_glasstile_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_glasstile_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_glasstile_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_glasstile_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_glasstile_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_glasstile_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.tilex, buf_from->tilex, buf_to->tilex, total_steps, current_step);
p_delta_long(&buf.tiley, buf_from->tiley, buf_to->tiley, total_steps, current_step);
gimp_set_data("plug_in_glasstile", &buf, sizeof(buf));
return 0; /* OK */
}

39
plug-ins/gap/iter_ALT/gen/plug_in_grid_iter_ALT.inc Normal file
View file

@ -0,0 +1,39 @@
/* ----------------------------------------------------------------------
* p_plug_in_grid_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_grid_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_grid_Vals
{
long width;
long height;
long x_offset;
long y_offset;
} t_plug_in_grid_Vals;
t_plug_in_grid_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_grid_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_grid_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_grid_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_grid_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_grid_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_grid_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_grid_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.width, buf_from->width, buf_to->width, total_steps, current_step);
p_delta_long(&buf.height, buf_from->height, buf_to->height, total_steps, current_step);
p_delta_long(&buf.x_offset, buf_from->x_offset, buf_to->x_offset, total_steps, current_step);
p_delta_long(&buf.y_offset, buf_from->y_offset, buf_to->y_offset, total_steps, current_step);
gimp_set_data("plug_in_grid", &buf, sizeof(buf));
return 0; /* OK */
}

41
plug-ins/gap/iter_ALT/gen/plug_in_jigsaw_iter_ALT.inc Normal file
View file

@ -0,0 +1,41 @@
/* ----------------------------------------------------------------------
* p_plug_in_jigsaw_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_jigsaw_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_jigsaw_Vals
{
long x;
long y;
long style;
long blend_lines;
gdouble blend_amount;
} t_plug_in_jigsaw_Vals;
t_plug_in_jigsaw_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_jigsaw_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_jigsaw_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_jigsaw_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_jigsaw_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_jigsaw_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_jigsaw_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_jigsaw_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.x, buf_from->x, buf_to->x, total_steps, current_step);
p_delta_long(&buf.y, buf_from->y, buf_to->y, total_steps, current_step);
p_delta_long(&buf.style, buf_from->style, buf_to->style, total_steps, current_step);
p_delta_long(&buf.blend_lines, buf_from->blend_lines, buf_to->blend_lines, total_steps, current_step);
p_delta_gdouble(&buf.blend_amount, buf_from->blend_amount, buf_to->blend_amount, total_steps, current_step);
gimp_set_data("plug_in_jigsaw", &buf, sizeof(buf));
return 0; /* OK */
}

31
plug-ins/gap/iter_ALT/gen/plug_in_make_seamless_iter_ALT.inc Normal file
View file

@ -0,0 +1,31 @@
/* ----------------------------------------------------------------------
* p_plug_in_make_seamless_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_make_seamless_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_make_seamless_Vals
{
} t_plug_in_make_seamless_Vals;
t_plug_in_make_seamless_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_make_seamless_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_make_seamless_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_make_seamless_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_make_seamless_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_make_seamless_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_make_seamless_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_make_seamless_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
gimp_set_data("plug_in_make_seamless", &buf, sizeof(buf));
return 0; /* OK */
}

37
plug-ins/gap/iter_ALT/gen/plug_in_mblur_iter_ALT.inc Normal file
View file

@ -0,0 +1,37 @@
/* ----------------------------------------------------------------------
* p_plug_in_mblur_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_mblur_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_mblur_Vals
{
long type;
long length;
long angle;
} t_plug_in_mblur_Vals;
t_plug_in_mblur_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_mblur_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_mblur_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_mblur_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_mblur_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_mblur_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_mblur_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_mblur_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.type, buf_from->type, buf_to->type, total_steps, current_step);
p_delta_long(&buf.length, buf_from->length, buf_to->length, total_steps, current_step);
p_delta_long(&buf.angle, buf_from->angle, buf_to->angle, total_steps, current_step);
gimp_set_data("plug_in_mblur", &buf, sizeof(buf));
return 0; /* OK */
}

53
plug-ins/gap/iter_ALT/gen/plug_in_mosaic_iter_ALT.inc Normal file
View file

@ -0,0 +1,53 @@
/* ----------------------------------------------------------------------
* p_plug_in_mosaic_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_mosaic_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_mosaic_Vals
{
gdouble tile_size;
gdouble tile_height;
gdouble tile_spacing;
gdouble tile_neatness;
gdouble light_dir;
gdouble color_variation;
long antialiasing;
long color_averaging;
long tile_type;
long tile_surface;
long grout_color;
} t_plug_in_mosaic_Vals;
t_plug_in_mosaic_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_mosaic_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_mosaic_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_mosaic_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_mosaic_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_mosaic_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_mosaic_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_mosaic_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.tile_size, buf_from->tile_size, buf_to->tile_size, total_steps, current_step);
p_delta_gdouble(&buf.tile_height, buf_from->tile_height, buf_to->tile_height, total_steps, current_step);
p_delta_gdouble(&buf.tile_spacing, buf_from->tile_spacing, buf_to->tile_spacing, total_steps, current_step);
p_delta_gdouble(&buf.tile_neatness, buf_from->tile_neatness, buf_to->tile_neatness, total_steps, current_step);
p_delta_gdouble(&buf.light_dir, buf_from->light_dir, buf_to->light_dir, total_steps, current_step);
p_delta_gdouble(&buf.color_variation, buf_from->color_variation, buf_to->color_variation, total_steps, current_step);
p_delta_long(&buf.antialiasing, buf_from->antialiasing, buf_to->antialiasing, total_steps, current_step);
p_delta_long(&buf.color_averaging, buf_from->color_averaging, buf_to->color_averaging, total_steps, current_step);
p_delta_long(&buf.tile_type, buf_from->tile_type, buf_to->tile_type, total_steps, current_step);
p_delta_long(&buf.tile_surface, buf_from->tile_surface, buf_to->tile_surface, total_steps, current_step);
p_delta_long(&buf.grout_color, buf_from->grout_color, buf_to->grout_color, total_steps, current_step);
gimp_set_data("plug_in_mosaic", &buf, sizeof(buf));
return 0; /* OK */
}

55
plug-ins/gap/iter_ALT/gen/plug_in_newsprint_iter_ALT.inc Normal file
View file

@ -0,0 +1,55 @@
/* ----------------------------------------------------------------------
* p_plug_in_newsprint_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_newsprint_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_newsprint_Vals
{
long cell_width;
long colourspace;
long k_pullout;
gdouble gry_ang;
long gry_spotfn;
gdouble red_ang;
long red_spotfn;
gdouble grn_ang;
long grn_spotfn;
gdouble blu_ang;
long blu_spotfn;
long oversample;
} t_plug_in_newsprint_Vals;
t_plug_in_newsprint_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_newsprint_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_newsprint_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_newsprint_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_newsprint_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_newsprint_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_newsprint_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_newsprint_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.cell_width, buf_from->cell_width, buf_to->cell_width, total_steps, current_step);
p_delta_long(&buf.colourspace, buf_from->colourspace, buf_to->colourspace, total_steps, current_step);
p_delta_long(&buf.k_pullout, buf_from->k_pullout, buf_to->k_pullout, total_steps, current_step);
p_delta_gdouble(&buf.gry_ang, buf_from->gry_ang, buf_to->gry_ang, total_steps, current_step);
p_delta_long(&buf.gry_spotfn, buf_from->gry_spotfn, buf_to->gry_spotfn, total_steps, current_step);
p_delta_gdouble(&buf.red_ang, buf_from->red_ang, buf_to->red_ang, total_steps, current_step);
p_delta_long(&buf.red_spotfn, buf_from->red_spotfn, buf_to->red_spotfn, total_steps, current_step);
p_delta_gdouble(&buf.grn_ang, buf_from->grn_ang, buf_to->grn_ang, total_steps, current_step);
p_delta_long(&buf.grn_spotfn, buf_from->grn_spotfn, buf_to->grn_spotfn, total_steps, current_step);
p_delta_gdouble(&buf.blu_ang, buf_from->blu_ang, buf_to->blu_ang, total_steps, current_step);
p_delta_long(&buf.blu_spotfn, buf_from->blu_spotfn, buf_to->blu_spotfn, total_steps, current_step);
p_delta_long(&buf.oversample, buf_from->oversample, buf_to->oversample, total_steps, current_step);
gimp_set_data("plug_in_newsprint", &buf, sizeof(buf));
return 0; /* OK */
}

41
plug-ins/gap/iter_ALT/gen/plug_in_noisify_iter_ALT.inc Normal file
View file

@ -0,0 +1,41 @@
/* ----------------------------------------------------------------------
* p_plug_in_noisify_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_noisify_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_noisify_Vals
{
long independent;
gdouble noise_1;
gdouble noise_2;
gdouble noise_3;
gdouble noise_4;
} t_plug_in_noisify_Vals;
t_plug_in_noisify_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_noisify_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_noisify_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_noisify_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_noisify_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_noisify_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_noisify_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_noisify_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.independent, buf_from->independent, buf_to->independent, total_steps, current_step);
p_delta_gdouble(&buf.noise_1, buf_from->noise_1, buf_to->noise_1, total_steps, current_step);
p_delta_gdouble(&buf.noise_2, buf_from->noise_2, buf_to->noise_2, total_steps, current_step);
p_delta_gdouble(&buf.noise_3, buf_from->noise_3, buf_to->noise_3, total_steps, current_step);
p_delta_gdouble(&buf.noise_4, buf_from->noise_4, buf_to->noise_4, total_steps, current_step);
gimp_set_data("plug_in_noisify", &buf, sizeof(buf));
return 0; /* OK */
}

39
plug-ins/gap/iter_ALT/gen/plug_in_paper_tile_iter_ALT.inc Normal file
View file

@ -0,0 +1,39 @@
/* ----------------------------------------------------------------------
* p_plug_in_paper_tile_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_paper_tile_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_paper_tile_Vals
{
long width;
long height;
long slide_length;
long bg_type;
} t_plug_in_paper_tile_Vals;
t_plug_in_paper_tile_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_paper_tile_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_paper_tile_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_paper_tile_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_paper_tile_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_paper_tile_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_paper_tile_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_paper_tile_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.width, buf_from->width, buf_to->width, total_steps, current_step);
p_delta_long(&buf.height, buf_from->height, buf_to->height, total_steps, current_step);
p_delta_long(&buf.slide_length, buf_from->slide_length, buf_to->slide_length, total_steps, current_step);
p_delta_long(&buf.bg_type, buf_from->bg_type, buf_to->bg_type, total_steps, current_step);
gimp_set_data("plug_in_paper_tile", &buf, sizeof(buf));
return 0; /* OK */
}

33
plug-ins/gap/iter_ALT/gen/plug_in_pixelize_iter_ALT.inc Normal file
View file

@ -0,0 +1,33 @@
/* ----------------------------------------------------------------------
* p_plug_in_pixelize_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_pixelize_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_pixelize_Vals
{
long pixelwidth;
} t_plug_in_pixelize_Vals;
t_plug_in_pixelize_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_pixelize_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_pixelize_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_pixelize_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_pixelize_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_pixelize_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_pixelize_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_pixelize_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.pixelwidth, buf_from->pixelwidth, buf_to->pixelwidth, total_steps, current_step);
gimp_set_data("plug_in_pixelize", &buf, sizeof(buf));
return 0; /* OK */
}

39
plug-ins/gap/iter_ALT/gen/plug_in_randomize_hurl_iter_ALT.inc Normal file
View file

@ -0,0 +1,39 @@
/* ----------------------------------------------------------------------
* p_plug_in_randomize_hurl_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_randomize_hurl_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_randomize_hurl_Vals
{
gdouble rndm_pct;
gdouble rndm_rcount;
long seed_type;
long rndm_seed;
} t_plug_in_randomize_hurl_Vals;
t_plug_in_randomize_hurl_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_randomize_hurl_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_randomize_hurl_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_randomize_hurl_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_randomize_hurl_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_randomize_hurl_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_randomize_hurl_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_randomize_hurl_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.rndm_pct, buf_from->rndm_pct, buf_to->rndm_pct, total_steps, current_step);
p_delta_gdouble(&buf.rndm_rcount, buf_from->rndm_rcount, buf_to->rndm_rcount, total_steps, current_step);
p_delta_long(&buf.seed_type, buf_from->seed_type, buf_to->seed_type, total_steps, current_step);
p_delta_long(&buf.rndm_seed, buf_from->rndm_seed, buf_to->rndm_seed, total_steps, current_step);
gimp_set_data("plug_in_randomize_hurl", &buf, sizeof(buf));
return 0; /* OK */
}

39
plug-ins/gap/iter_ALT/gen/plug_in_randomize_pick_iter_ALT.inc Normal file
View file

@ -0,0 +1,39 @@
/* ----------------------------------------------------------------------
* p_plug_in_randomize_pick_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_randomize_pick_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_randomize_pick_Vals
{
gdouble rndm_pct;
gdouble rndm_rcount;
long seed_type;
long rndm_seed;
} t_plug_in_randomize_pick_Vals;
t_plug_in_randomize_pick_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_randomize_pick_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_randomize_pick_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_randomize_pick_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_randomize_pick_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_randomize_pick_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_randomize_pick_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_randomize_pick_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.rndm_pct, buf_from->rndm_pct, buf_to->rndm_pct, total_steps, current_step);
p_delta_gdouble(&buf.rndm_rcount, buf_from->rndm_rcount, buf_to->rndm_rcount, total_steps, current_step);
p_delta_long(&buf.seed_type, buf_from->seed_type, buf_to->seed_type, total_steps, current_step);
p_delta_long(&buf.rndm_seed, buf_from->rndm_seed, buf_to->rndm_seed, total_steps, current_step);
gimp_set_data("plug_in_randomize_pick", &buf, sizeof(buf));
return 0; /* OK */
}

39
plug-ins/gap/iter_ALT/gen/plug_in_randomize_slur_iter_ALT.inc Normal file
View file

@ -0,0 +1,39 @@
/* ----------------------------------------------------------------------
* p_plug_in_randomize_slur_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_randomize_slur_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_randomize_slur_Vals
{
gdouble rndm_pct;
gdouble rndm_rcount;
long seed_type;
long rndm_seed;
} t_plug_in_randomize_slur_Vals;
t_plug_in_randomize_slur_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_randomize_slur_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_randomize_slur_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_randomize_slur_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_randomize_slur_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_randomize_slur_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_randomize_slur_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_randomize_slur_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.rndm_pct, buf_from->rndm_pct, buf_to->rndm_pct, total_steps, current_step);
p_delta_gdouble(&buf.rndm_rcount, buf_from->rndm_rcount, buf_to->rndm_rcount, total_steps, current_step);
p_delta_long(&buf.seed_type, buf_from->seed_type, buf_to->seed_type, total_steps, current_step);
p_delta_long(&buf.rndm_seed, buf_from->rndm_seed, buf_to->rndm_seed, total_steps, current_step);
gimp_set_data("plug_in_randomize_slur", &buf, sizeof(buf));
return 0; /* OK */
}

45
plug-ins/gap/iter_ALT/gen/plug_in_ripple_iter_ALT.inc Normal file
View file

@ -0,0 +1,45 @@
/* ----------------------------------------------------------------------
* p_plug_in_ripple_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_ripple_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_ripple_Vals
{
long period;
long amplitude;
long orientation;
long edges;
long waveform;
long antialias;
long tile;
} t_plug_in_ripple_Vals;
t_plug_in_ripple_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_ripple_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_ripple_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_ripple_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_ripple_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_ripple_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_ripple_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_ripple_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.period, buf_from->period, buf_to->period, total_steps, current_step);
p_delta_long(&buf.amplitude, buf_from->amplitude, buf_to->amplitude, total_steps, current_step);
p_delta_long(&buf.orientation, buf_from->orientation, buf_to->orientation, total_steps, current_step);
p_delta_long(&buf.edges, buf_from->edges, buf_to->edges, total_steps, current_step);
p_delta_long(&buf.waveform, buf_from->waveform, buf_to->waveform, total_steps, current_step);
p_delta_long(&buf.antialias, buf_from->antialias, buf_to->antialias, total_steps, current_step);
p_delta_long(&buf.tile, buf_from->tile, buf_to->tile, total_steps, current_step);
gimp_set_data("plug_in_ripple", &buf, sizeof(buf));
return 0; /* OK */
}

35
plug-ins/gap/iter_ALT/gen/plug_in_rotate_iter_ALT.inc Normal file
View file

@ -0,0 +1,35 @@
/* ----------------------------------------------------------------------
* p_plug_in_rotate_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_rotate_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_rotate_Vals
{
long angle;
long everything;
} t_plug_in_rotate_Vals;
t_plug_in_rotate_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_rotate_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_rotate_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_rotate_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_rotate_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_rotate_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_rotate_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_rotate_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.angle, buf_from->angle, buf_to->angle, total_steps, current_step);
p_delta_long(&buf.everything, buf_from->everything, buf_to->everything, total_steps, current_step);
gimp_set_data("plug_in_rotate", &buf, sizeof(buf));
return 0; /* OK */
}

39
plug-ins/gap/iter_ALT/gen/plug_in_scatter_hsv_iter_ALT.inc Normal file
View file

@ -0,0 +1,39 @@
/* ----------------------------------------------------------------------
* p_plug_in_scatter_hsv_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_scatter_hsv_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_scatter_hsv_Vals
{
long holdness;
long hue_distance;
long saturation_distance;
long value_distance;
} t_plug_in_scatter_hsv_Vals;
t_plug_in_scatter_hsv_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_scatter_hsv_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_scatter_hsv_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_scatter_hsv_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_scatter_hsv_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_scatter_hsv_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_scatter_hsv_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_scatter_hsv_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.holdness, buf_from->holdness, buf_to->holdness, total_steps, current_step);
p_delta_long(&buf.hue_distance, buf_from->hue_distance, buf_to->hue_distance, total_steps, current_step);
p_delta_long(&buf.saturation_distance, buf_from->saturation_distance, buf_to->saturation_distance, total_steps, current_step);
p_delta_long(&buf.value_distance, buf_from->value_distance, buf_to->value_distance, total_steps, current_step);
gimp_set_data("plug_in_scatter_hsv", &buf, sizeof(buf));
return 0; /* OK */
}

33
plug-ins/gap/iter_ALT/gen/plug_in_sharpen_iter_ALT.inc Normal file
View file

@ -0,0 +1,33 @@
/* ----------------------------------------------------------------------
* p_plug_in_sharpen_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_sharpen_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_sharpen_Vals
{
long percent;
} t_plug_in_sharpen_Vals;
t_plug_in_sharpen_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_sharpen_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_sharpen_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_sharpen_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_sharpen_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_sharpen_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_sharpen_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_sharpen_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.percent, buf_from->percent, buf_to->percent, total_steps, current_step);
gimp_set_data("plug_in_sharpen", &buf, sizeof(buf));
return 0; /* OK */
}

35
plug-ins/gap/iter_ALT/gen/plug_in_shift_iter_ALT.inc Normal file
View file

@ -0,0 +1,35 @@
/* ----------------------------------------------------------------------
* p_plug_in_shift_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_shift_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_shift_Vals
{
long shift_amount;
long orientation;
} t_plug_in_shift_Vals;
t_plug_in_shift_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_shift_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_shift_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_shift_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_shift_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_shift_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_shift_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_shift_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.shift_amount, buf_from->shift_amount, buf_to->shift_amount, total_steps, current_step);
p_delta_long(&buf.orientation, buf_from->orientation, buf_to->orientation, total_steps, current_step);
gimp_set_data("plug_in_shift", &buf, sizeof(buf));
return 0; /* OK */
}

35
plug-ins/gap/iter_ALT/gen/plug_in_spread_iter_ALT.inc Normal file
View file

@ -0,0 +1,35 @@
/* ----------------------------------------------------------------------
* p_plug_in_spread_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_spread_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_spread_Vals
{
gdouble spread_amount_x;
gdouble spread_amount_y;
} t_plug_in_spread_Vals;
t_plug_in_spread_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_spread_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_spread_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_spread_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_spread_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_spread_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_spread_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_spread_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.spread_amount_x, buf_from->spread_amount_x, buf_to->spread_amount_x, total_steps, current_step);
p_delta_gdouble(&buf.spread_amount_y, buf_from->spread_amount_y, buf_to->spread_amount_y, total_steps, current_step);
gimp_set_data("plug_in_spread", &buf, sizeof(buf));
return 0; /* OK */
}

37
plug-ins/gap/iter_ALT/gen/plug_in_video_iter_ALT.inc Normal file
View file

@ -0,0 +1,37 @@
/* ----------------------------------------------------------------------
* p_plug_in_video_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_video_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_video_Vals
{
long pattern_number;
long additive;
long rotated;
} t_plug_in_video_Vals;
t_plug_in_video_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_video_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_video_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_video_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_video_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_video_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_video_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_video_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.pattern_number, buf_from->pattern_number, buf_to->pattern_number, total_steps, current_step);
p_delta_long(&buf.additive, buf_from->additive, buf_to->additive, total_steps, current_step);
p_delta_long(&buf.rotated, buf_from->rotated, buf_to->rotated, total_steps, current_step);
gimp_set_data("plug_in_video", &buf, sizeof(buf));
return 0; /* OK */
}

43
plug-ins/gap/iter_ALT/gen/plug_in_vpropagate_iter_ALT.inc Normal file
View file

@ -0,0 +1,43 @@
/* ----------------------------------------------------------------------
* p_plug_in_vpropagate_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_vpropagate_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_vpropagate_Vals
{
long propagate_mode;
long propagating_channel;
gdouble propagating_rate;
long direction_mask;
long lower_limit;
long upper_limit;
} t_plug_in_vpropagate_Vals;
t_plug_in_vpropagate_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_vpropagate_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_vpropagate_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_vpropagate_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_vpropagate_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_vpropagate_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_vpropagate_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_vpropagate_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.propagate_mode, buf_from->propagate_mode, buf_to->propagate_mode, total_steps, current_step);
p_delta_long(&buf.propagating_channel, buf_from->propagating_channel, buf_to->propagating_channel, total_steps, current_step);
p_delta_gdouble(&buf.propagating_rate, buf_from->propagating_rate, buf_to->propagating_rate, total_steps, current_step);
p_delta_long(&buf.direction_mask, buf_from->direction_mask, buf_to->direction_mask, total_steps, current_step);
p_delta_long(&buf.lower_limit, buf_from->lower_limit, buf_to->lower_limit, total_steps, current_step);
p_delta_long(&buf.upper_limit, buf_from->upper_limit, buf_to->upper_limit, total_steps, current_step);
gimp_set_data("plug_in_vpropagate", &buf, sizeof(buf));
return 0; /* OK */
}

41
plug-ins/gap/iter_ALT/gen/plug_in_waves_iter_ALT.inc Normal file
View file

@ -0,0 +1,41 @@
/* ----------------------------------------------------------------------
* p_plug_in_waves_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_waves_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_waves_Vals
{
gdouble amplitude;
gdouble phase;
gdouble wavelength;
long type;
long reflective;
} t_plug_in_waves_Vals;
t_plug_in_waves_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_waves_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_waves_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_waves_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_waves_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_waves_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_waves_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_waves_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.amplitude, buf_from->amplitude, buf_to->amplitude, total_steps, current_step);
p_delta_gdouble(&buf.phase, buf_from->phase, buf_to->phase, total_steps, current_step);
p_delta_gdouble(&buf.wavelength, buf_from->wavelength, buf_to->wavelength, total_steps, current_step);
p_delta_long(&buf.type, buf_from->type, buf_to->type, total_steps, current_step);
p_delta_long(&buf.reflective, buf_from->reflective, buf_to->reflective, total_steps, current_step);
gimp_set_data("plug_in_waves", &buf, sizeof(buf));
return 0; /* OK */
}

37
plug-ins/gap/iter_ALT/gen/plug_in_whirl_pinch_iter_ALT.inc Normal file
View file

@ -0,0 +1,37 @@
/* ----------------------------------------------------------------------
* p_plug_in_whirl_pinch_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_whirl_pinch_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_whirl_pinch_Vals
{
gdouble whirl;
gdouble pinch;
gdouble radius;
} t_plug_in_whirl_pinch_Vals;
t_plug_in_whirl_pinch_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_whirl_pinch_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_whirl_pinch_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_whirl_pinch_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_whirl_pinch_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_whirl_pinch_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_whirl_pinch_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_whirl_pinch_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.whirl, buf_from->whirl, buf_to->whirl, total_steps, current_step);
p_delta_gdouble(&buf.pinch, buf_from->pinch, buf_to->pinch, total_steps, current_step);
p_delta_gdouble(&buf.radius, buf_from->radius, buf_to->radius, total_steps, current_step);
gimp_set_data("plug_in_whirl_pinch", &buf, sizeof(buf));
return 0; /* OK */
}

41
plug-ins/gap/iter_ALT/gen/plug_in_wind_iter_ALT.inc Normal file
View file

@ -0,0 +1,41 @@
/* ----------------------------------------------------------------------
* p_plug_in_wind_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_wind_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_wind_Vals
{
long threshold;
long direction;
long strength;
long alg;
long edge;
} t_plug_in_wind_Vals;
t_plug_in_wind_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_wind_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_wind_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_wind_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_wind_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_wind_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_wind_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_wind_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.threshold, buf_from->threshold, buf_to->threshold, total_steps, current_step);
p_delta_long(&buf.direction, buf_from->direction, buf_to->direction, total_steps, current_step);
p_delta_long(&buf.strength, buf_from->strength, buf_to->strength, total_steps, current_step);
p_delta_long(&buf.alg, buf_from->alg, buf_to->alg, total_steps, current_step);
p_delta_long(&buf.edge, buf_from->edge, buf_to->edge, total_steps, current_step);
gimp_set_data("plug_in_wind", &buf, sizeof(buf));
return 0; /* OK */
}

31
plug-ins/gap/iter_ALT/gen/plug_in_zealouscrop_iter_ALT.inc Normal file
View file

@ -0,0 +1,31 @@
/* ----------------------------------------------------------------------
* p_plug_in_zealouscrop_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_zealouscrop_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_zealouscrop_Vals
{
} t_plug_in_zealouscrop_Vals;
t_plug_in_zealouscrop_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_zealouscrop_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_zealouscrop_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_zealouscrop_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_zealouscrop_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_zealouscrop_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_zealouscrop_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_zealouscrop_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
gimp_set_data("plug_in_zealouscrop", &buf, sizeof(buf));
return 0; /* OK */
}

64
plug-ins/gap/iter_ALT/mod/plug_in_Twist_iter_ALT.inc Normal file
View file

@ -0,0 +1,64 @@
/* ----------------------------------------------------------------------
* p_plug_in_Twist_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_Twist_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_Twist_Vals
{
float a1;
float a2;
float a3;
float a4;
float a5;
float a6;
float a7;
float a8;
gchar lettering01[30];
gchar lettering02[30];
gchar lettering03[30];
gchar lettering04[30];
gchar lettering05[30];
gchar lettering06[30];
gchar lettering07[30];
gchar lettering08[30];
gint use_cutoff;
float r;
float dr;
gint current_function;
} t_plug_in_Twist_Vals;
t_plug_in_Twist_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_Twist_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_Twist_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_Twist_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_Twist_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_Twist_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_Twist_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_Twist_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_float(&buf.a1, buf_from->a1, buf_to->a1, total_steps, current_step);
p_delta_float(&buf.a2, buf_from->a2, buf_to->a2, total_steps, current_step);
p_delta_float(&buf.a3, buf_from->a3, buf_to->a3, total_steps, current_step);
p_delta_float(&buf.a4, buf_from->a4, buf_to->a4, total_steps, current_step);
p_delta_float(&buf.a5, buf_from->a5, buf_to->a5, total_steps, current_step);
p_delta_float(&buf.a6, buf_from->a6, buf_to->a6, total_steps, current_step);
p_delta_float(&buf.a7, buf_from->a7, buf_to->a7, total_steps, current_step);
p_delta_float(&buf.a8, buf_from->a8, buf_to->a8, total_steps, current_step);
p_delta_gint(&buf.use_cutoff, buf_from->use_cutoff, buf_to->use_cutoff, total_steps, current_step);
p_delta_float(&buf.r, buf_from->r, buf_to->r, total_steps, current_step);
p_delta_float(&buf.dr, buf_from->dr, buf_to->dr, total_steps, current_step);
p_delta_gint(&buf.current_function, buf_from->current_function, buf_to->current_function, total_steps, current_step);
gimp_set_data("plug_in_Twist", &buf, sizeof(buf));
return 0; /* OK */
}

43
plug-ins/gap/iter_ALT/mod/plug_in_alienmap_iter_ALT.inc Normal file
View file

@ -0,0 +1,43 @@
/* ----------------------------------------------------------------------
* p_plug_in_alienmap_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_alienmap_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_alienmap_Vals
{
gdouble redstretch;
gdouble greenstretch;
gdouble bluestretch;
gint redmode;
gint greenmode;
gint bluemode;
} t_plug_in_alienmap_Vals;
t_plug_in_alienmap_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_alienmap_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_alienmap_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_alienmap_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_alienmap_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_alienmap_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_alienmap_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_alienmap_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.redstretch, buf_from->redstretch, buf_to->redstretch, total_steps, current_step);
p_delta_gdouble(&buf.greenstretch, buf_from->greenstretch, buf_to->greenstretch, total_steps, current_step);
p_delta_gdouble(&buf.bluestretch, buf_from->bluestretch, buf_to->bluestretch, total_steps, current_step);
p_delta_gint(&buf.redmode, buf_from->redmode, buf_to->redmode, total_steps, current_step);
p_delta_gint(&buf.greenmode, buf_from->greenmode, buf_to->greenmode, total_steps, current_step);
p_delta_gint(&buf.bluemode, buf_from->bluemode, buf_to->bluemode, total_steps, current_step);
gimp_set_data("plug_in_alienmap", &buf, sizeof(buf));
return 0; /* OK */
}

39
plug-ins/gap/iter_ALT/mod/plug_in_applylens_iter_ALT.inc Normal file
View file

@ -0,0 +1,39 @@
/* ----------------------------------------------------------------------
* p_plug_in_applylens_iter_ALT
* ----------------------------------------------------------------------
*/
static gint p_plug_in_applylens_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_applylens_Vals
{
gdouble refraction;
long keep_surroundings;
long set_background;
long set_transparent;
} t_plug_in_applylens_Vals;
t_plug_in_applylens_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_applylens_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_applylens_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_applylens_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_applylens_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_applylens_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_applylens_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_applylens_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.refraction, buf_from->refraction, buf_to->refraction, total_steps, current_step);
p_delta_long(&buf.keep_surroundings, buf_from->keep_surroundings, buf_to->keep_surroundings, total_steps, current_step);
p_delta_long(&buf.set_background, buf_from->set_background, buf_to->set_background, total_steps, current_step);
p_delta_long(&buf.set_transparent, buf_from->set_transparent, buf_to->set_transparent, total_steps, current_step);
gimp_set_data("plug_in_applylens", &buf, sizeof(buf));
return 0; /* OK */
}

39
plug-ins/gap/iter_ALT/mod/plug_in_blur_iter_ALT.inc Normal file
View file

@ -0,0 +1,39 @@
/* ----------------------------------------------------------------------
* p_plug_in_blur_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_blur_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_blur_Vals
{
gdouble blur_pct; /* likelihood of randomization (as %age) */
gdouble blur_rcount; /* repeat count */
gint seed_type; /* seed init. type - current time or user value */
gint blur_seed; /* seed value for rand() function */
} t_plug_in_blur_Vals;
t_plug_in_blur_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_blur_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_blur_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_blur_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_blur_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_blur_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_blur_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_blur_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.blur_pct, buf_from->blur_pct, buf_to->blur_pct, total_steps, current_step);
p_delta_gdouble(&buf.blur_rcount, buf_from->blur_rcount, buf_to->blur_rcount, total_steps, current_step);
p_delta_gint(&buf.seed_type, buf_from->seed_type, buf_to->seed_type, total_steps, current_step);
p_delta_gint(&buf.blur_seed, buf_from->blur_seed, buf_to->blur_seed, total_steps, current_step);
gimp_set_data("plug_in_blur", &buf, sizeof(buf));
return 0; /* OK */
}

49
plug-ins/gap/iter_ALT/mod/plug_in_depth_merge_iter_ALT.inc Normal file
View file

@ -0,0 +1,49 @@
/* ----------------------------------------------------------------------
* p_plug_in_depth_merge_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_depth_merge_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_depth_merge_Vals
{
gint32 result;
gint32 source1;
gint32 source2;
gint32 depthMap1;
gint32 depthMap2;
float overlap;
float offset;
float scale1;
float scale2;
} t_plug_in_depth_merge_Vals;
t_plug_in_depth_merge_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_depth_merge_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_depth_merge_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_depth_merge_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_depth_merge_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_depth_merge_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_depth_merge_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_depth_merge_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_drawable(&buf.result, buf_from->result, buf_to->result, total_steps, current_step);
p_delta_drawable(&buf.source1, buf_from->source1, buf_to->source1, total_steps, current_step);
p_delta_drawable(&buf.source2, buf_from->source2, buf_to->source2, total_steps, current_step);
p_delta_drawable(&buf.depthMap1, buf_from->depthMap1, buf_to->depthMap1, total_steps, current_step);
p_delta_drawable(&buf.depthMap2, buf_from->depthMap2, buf_to->depthMap2, total_steps, current_step);
p_delta_float(&buf.overlap, buf_from->overlap, buf_to->overlap, total_steps, current_step);
p_delta_float(&buf.offset, buf_from->offset, buf_to->offset, total_steps, current_step);
p_delta_float(&buf.scale1, buf_from->scale1, buf_to->scale1, total_steps, current_step);
p_delta_float(&buf.scale2, buf_from->scale2, buf_to->scale2, total_steps, current_step);
gimp_set_data("plug_in_depth_merge", &buf, sizeof(buf));
return 0; /* OK */
}

39
plug-ins/gap/iter_ALT/mod/plug_in_despeckle_iter_ALT.inc Normal file
View file

@ -0,0 +1,39 @@
/* ----------------------------------------------------------------------
* p_plug_in_despeckle_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_despeckle_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_despeckle_Vals
{
gint radius;
gint type; /* not iterated */
gint black;
gint white;
} t_plug_in_despeckle_Vals;
t_plug_in_despeckle_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_despeckle_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_despeckle_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_despeckle_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_despeckle_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_despeckle_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_despeckle_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_despeckle_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gint(&buf.radius, buf_from->radius, buf_to->radius, total_steps, current_step);
/* p_delta_gint(&buf.type, buf_from->type, buf_to->type, total_steps, current_step); */
p_delta_gint(&buf.black, buf_from->black, buf_to->black, total_steps, current_step);
p_delta_gint(&buf.white, buf_from->white, buf_to->white, total_steps, current_step);
gimp_set_data("plug_in_despeckle", &buf, sizeof(buf));
return 0; /* OK */
}

41
plug-ins/gap/iter_ALT/mod/plug_in_emboss_iter_ALT.inc Normal file
View file

@ -0,0 +1,41 @@
/* ----------------------------------------------------------------------
* p_plug_in_emboss_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_emboss_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_emboss_Vals
{
gint32 img;
gint32 drw;
gdouble azimuth;
gdouble elevation;
long depth;
long embossp;
} t_plug_in_emboss_Vals;
t_plug_in_emboss_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_emboss_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_emboss_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_emboss_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_emboss_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_emboss_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_emboss_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_emboss_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.azimuth, buf_from->azimuth, buf_to->azimuth, total_steps, current_step);
p_delta_gdouble(&buf.elevation, buf_from->elevation, buf_to->elevation, total_steps, current_step);
p_delta_long(&buf.depth, buf_from->depth, buf_to->depth, total_steps, current_step);
p_delta_long(&buf.embossp, buf_from->embossp, buf_to->embossp, total_steps, current_step);
gimp_set_data("plug_in_emboss", &buf, sizeof(buf));
return 0; /* OK */
}

53
plug-ins/gap/iter_ALT/mod/plug_in_exchange_iter_ALT.inc Normal file
View file

@ -0,0 +1,53 @@
/* ----------------------------------------------------------------------
* p_plug_in_exchange_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_exchange_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_exchange_Vals
{
guchar fromred;
guchar fromgreen;
guchar fromblue;
guchar tored;
guchar togreen;
guchar toblue;
guchar red_threshold;
guchar green_threshold;
guchar blue_threshold;
gint32 image;
gint32 drawable;
} t_plug_in_exchange_Vals;
t_plug_in_exchange_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_exchange_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_exchange_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_exchange_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_exchange_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_exchange_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_exchange_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_exchange_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_guchar(&buf.fromred, buf_from->fromred, buf_to->fromred, total_steps, current_step);
p_delta_guchar(&buf.fromgreen, buf_from->fromgreen, buf_to->fromgreen, total_steps, current_step);
p_delta_guchar(&buf.fromblue, buf_from->fromblue, buf_to->fromblue, total_steps, current_step);
p_delta_guchar(&buf.tored, buf_from->tored, buf_to->tored, total_steps, current_step);
p_delta_guchar(&buf.togreen, buf_from->togreen, buf_to->togreen, total_steps, current_step);
p_delta_guchar(&buf.toblue, buf_from->toblue, buf_to->toblue, total_steps, current_step);
p_delta_guchar(&buf.red_threshold, buf_from->red_threshold, buf_to->red_threshold, total_steps, current_step);
p_delta_guchar(&buf.green_threshold, buf_from->green_threshold, buf_to->green_threshold, total_steps, current_step);
p_delta_guchar(&buf.blue_threshold, buf_from->blue_threshold, buf_to->blue_threshold, total_steps, current_step);
/* exchange takes FROM colors from foreground when called in mode RUN_WITH_LAST_VALS */
gimp_palette_set_foreground(buf.fromred, buf.fromgreen, buf.fromblue);
gimp_set_data("plug_in_exchange", &buf, sizeof(buf));
return 0; /* OK */
}

101
plug-ins/gap/iter_ALT/mod/plug_in_lighting_iter_ALT.inc Normal file
View file

@ -0,0 +1,101 @@
/* ----------------------------------------------------------------------
* p_plug_in_lighting_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_lighting_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_lighting_Vals
{
gint32 drawable_id;
gint32 bumpdrawable;
gint32 envdrawable;
/* Render variables */
/* ================ */
t_GckVector3 viewpoint;
t_GckVector3 planenormal;
t_LightSettings lightsource;
t_MaterialSettings material;
t_MaterialSettings refmaterial;
gdouble pixel_treshold;
gdouble bumpmax;
gdouble bumpmin;
/* gdouble wave_cx,wave_cy;
gdouble wave_lx,wave_ly;
gdouble wave_amp,wave_ph; */
gint max_depth;
gint bumpmaptype;
/* gint bumptype; */
/* Flags */
/* ===== */
gint antialiasing;
gint create_new_image;
gint transparent_background;
gint tooltips_enabled;
gint bump_mapped;
gint env_mapped;
gint ref_mapped;
gint bumpstretch;
gint previewquality;
/* Misc */
/* ==== */
gdouble preview_zoom_factor;
} t_plug_in_lighting_Vals;
t_plug_in_lighting_Vals buf, buf_from, buf_to;
if(len_struct != sizeof(t_plug_in_lighting_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_lighting_iter stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_lighting_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_lighting_ITER_FROM", &buf_from);
gimp_get_data("plug_in_lighting_ITER_TO", &buf_to);
memcpy(&buf, &buf_from, sizeof(buf));
p_delta_GckVector3(&buf.viewpoint, &buf_from.viewpoint, &buf_to.viewpoint, total_steps, current_step);
p_delta_GckVector3(&buf.planenormal, &buf_from.planenormal, &buf_to.planenormal, total_steps, current_step);
p_delta_LightSettings(&buf.lightsource, &buf_from.lightsource, &buf_to.lightsource, total_steps, current_step);
p_delta_MaterialSettings(&buf.material, &buf_from.material, &buf_to.material, total_steps, current_step);
p_delta_MaterialSettings(&buf.refmaterial, &buf_from.refmaterial, &buf_to.refmaterial, total_steps, current_step);
p_delta_gdouble(&buf.pixel_treshold, buf_from.pixel_treshold, buf_to.pixel_treshold, total_steps, current_step);
p_delta_gdouble(&buf.bumpmax, buf_from.bumpmax, buf_to.bumpmax, total_steps, current_step);
p_delta_gdouble(&buf.bumpmin, buf_from.bumpmin, buf_to.bumpmin, total_steps, current_step);
/*
p_delta_gdouble(&buf.wave_cx, buf_from.wave_cx, buf_to.wave_cx, total_steps, current_step);
p_delta_gdouble(&buf.wave_cy, buf_from.wave_cy, buf_to.wave_cy, total_steps, current_step);
p_delta_gdouble(&buf.wave_lx, buf_from.wave_lx, buf_to.wave_lx, total_steps, current_step);
p_delta_gdouble(&buf.wave_ly, buf_from.wave_ly, buf_to.wave_ly, total_steps, current_step);
*/
p_delta_gint(&buf.max_depth, buf_from.max_depth, buf_to.max_depth, total_steps, current_step);
p_delta_gint(&buf.bumpmaptype, buf_from.bumpmaptype, buf_to.bumpmaptype, total_steps, current_step);
/* p_delta_gint(&buf.bumptype, buf_from.bumptype, buf_to.bumptype, total_steps, current_step);
*/
p_delta_gint(&buf.antialiasing, buf_from.antialiasing, buf_to.antialiasing, total_steps, current_step);
p_delta_gint(&buf.transparent_background, buf_from.transparent_background, buf_to.transparent_background, total_steps, current_step);
p_delta_gint(&buf.bump_mapped, buf_from.bump_mapped, buf_to.bump_mapped, total_steps, current_step);
p_delta_gint(&buf.ref_mapped, buf_from.ref_mapped, buf_to.ref_mapped, total_steps, current_step);
p_delta_gint(&buf.bumpstretch, buf_from.bumpstretch, buf_to.bumpstretch, total_steps, current_step);
p_delta_gint(&buf.previewquality, buf_from.previewquality, buf_to.previewquality, total_steps, current_step);
gimp_set_data("plug_in_lighting", &buf, sizeof(buf));
return 0; /* OK */
}

105
plug-ins/gap/iter_ALT/mod/plug_in_map_object_iter_ALT.inc Normal file
View file

@ -0,0 +1,105 @@
/* ----------------------------------------------------------------------
* p_plug_in_map_object_iter
* ----------------------------------------------------------------------
*/
gint p_plug_in_map_object_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct
{
t_GckVector3 viewpoint;
t_GckVector3 firstaxis;
t_GckVector3 secondaxis;
t_GckVector3 normal;
t_GckVector3 position;
t_GckVector3 scale;
t_LightSettings lightsource;
t_MaterialSettings material;
t_MaterialSettings refmaterial;
t_MapType maptype;
gint antialiasing;
gint create_new_image;
gint transparent_background;
gint tiled;
gint showgrid;
gint tooltips_enabled;
gint showcaps;
glong preview_zoom_factor;
gdouble alpha,beta,gamma;
gdouble maxdepth;
gdouble pixeltreshold;
gdouble radius;
gdouble cylinder_radius;
gdouble cylinder_length;
gint32 boxmap_id[6];
gint32 cylindermap_id[2];
} t_plug_in_map_object_Vals;
t_plug_in_map_object_Vals buf, buf_from, buf_to;
int l_idx;
if(len_struct != sizeof(t_plug_in_map_object_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_map_object_iter stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_map_object_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_map_object_ITER_FROM", &buf_from);
gimp_get_data("plug_in_map_object_ITER_TO", &buf_to);
memcpy(&buf, &buf_from, sizeof(buf));
p_delta_GckVector3(&buf.viewpoint, &buf_from.viewpoint, &buf_to.viewpoint, total_steps, current_step);
p_delta_GckVector3(&buf.firstaxis, &buf_from.firstaxis, &buf_to.firstaxis, total_steps, current_step);
p_delta_GckVector3(&buf.secondaxis, &buf_from.secondaxis, &buf_to.secondaxis, total_steps, current_step);
p_delta_GckVector3(&buf.normal, &buf_from.normal, &buf_to.normal, total_steps, current_step);
p_delta_GckVector3(&buf.position, &buf_from.position, &buf_to.position, total_steps, current_step);
p_delta_GckVector3(&buf.scale, &buf_from.scale, &buf_to.scale, total_steps, current_step);
p_delta_LightSettings(&buf.lightsource, &buf_from.lightsource, &buf_to.lightsource, total_steps, current_step);
p_delta_MaterialSettings(&buf.material, &buf_from.material, &buf_to.material, total_steps, current_step);
p_delta_MaterialSettings(&buf.refmaterial, &buf_from.refmaterial, &buf_to.refmaterial, total_steps, current_step);
/* MapType is not iterated */
p_delta_gdouble(&buf.alpha, buf_from.alpha, buf_to.alpha, total_steps, current_step);
p_delta_gdouble(&buf.beta, buf_from.beta, buf_to.beta, total_steps, current_step);
p_delta_gdouble(&buf.gamma, buf_from.gamma, buf_to.gamma, total_steps, current_step);
p_delta_gdouble(&buf.maxdepth, buf_from.maxdepth, buf_to.maxdepth, total_steps, current_step);
p_delta_gdouble(&buf.pixeltreshold, buf_from.pixeltreshold, buf_to.pixeltreshold, total_steps, current_step);
p_delta_gdouble(&buf.radius, buf_from.radius, buf_to.radius, total_steps, current_step);
/* switches that are not iterated: tlied, showgrid, tooltips_enabled, showcaps */
p_delta_gdouble(&buf.cylinder_radius, buf_from.cylinder_radius, buf_to.cylinder_radius, total_steps, current_step);
p_delta_gdouble(&buf.cylinder_length, buf_from.cylinder_length, buf_to.cylinder_length, total_steps, current_step);
/* animate the used maps (drawing_ids) */
for(l_idx = 0; l_idx < 6; l_idx++)
{
p_delta_drawable(&buf.boxmap_id[l_idx], buf_from.boxmap_id[l_idx], buf_to.boxmap_id[l_idx], total_steps, current_step);
}
for(l_idx = 0; l_idx < 2; l_idx++)
{
p_delta_drawable(&buf.cylindermap_id[l_idx], buf_from.cylindermap_id[l_idx], buf_to.cylindermap_id[l_idx], total_steps, current_step);
}
buf.create_new_image = FALSE;
buf.antialiasing = buf_from.antialiasing;
buf.transparent_background = buf_from.transparent_background;
buf.tiled = buf_from.tiled;
gimp_set_data("plug_in_map_object", &buf, sizeof(buf));
return 0; /* OK */
}

50
plug-ins/gap/iter_ALT/mod/plug_in_maze_iter_ALT.inc Normal file
View file

@ -0,0 +1,50 @@
/* ----------------------------------------------------------------------
* p_plug_in_maze_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_maze_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef enum {
DEPTH_FIRST,
PRIMS_ALGORITHM
} MazeAlgoType;
typedef struct t_plug_in_maze_Vals
{
gint width;
gint height;
guint seed;
gboolean tile;
gint multiple;
gint offset;
MazeAlgoType algorithm;
/* Interface options. */
gboolean timeseed;
} t_plug_in_maze_Vals;
t_plug_in_maze_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_maze_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_maze_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_maze_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_maze_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_maze_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_maze_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_maze_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gint(&buf.width, buf_from->width, buf_to->width, total_steps, current_step);
p_delta_gint(&buf.height, buf_from->height, buf_to->height, total_steps, current_step);
p_delta_gint(&buf.seed, buf_from->seed, buf_to->seed, total_steps, current_step);
p_delta_gint(&buf.multiple, buf_from->multiple, buf_to->multiple, total_steps, current_step);
p_delta_gint(&buf.offset, buf_from->offset, buf_to->offset, total_steps, current_step);
gimp_set_data("plug_in_maze", &buf, sizeof(buf));
return 0; /* OK */
}

39
plug-ins/gap/iter_ALT/mod/plug_in_nlfilt_iter_ALT.inc Normal file
View file

@ -0,0 +1,39 @@
/* ----------------------------------------------------------------------
* p_plug_in_nlfilt_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_nlfilt_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_nlfilt_Vals
{
gint32 img;
gint32 drw;
gdouble alpha;
gdouble radius;
gint filter;
} t_plug_in_nlfilt_Vals;
t_plug_in_nlfilt_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_nlfilt_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_nlfilt_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_nlfilt_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_nlfilt_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_nlfilt_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_nlfilt_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_nlfilt_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.alpha, buf_from->alpha, buf_to->alpha, total_steps, current_step);
p_delta_gdouble(&buf.radius, buf_from->radius, buf_to->radius, total_steps, current_step);
p_delta_gint(&buf.filter, buf_from->filter, buf_to->filter, total_steps, current_step);
gimp_set_data("plug_in_nlfilt", &buf, sizeof(buf));
return 0; /* OK */
}

41
plug-ins/gap/iter_ALT/mod/plug_in_nova_iter_ALT.inc Normal file
View file

@ -0,0 +1,41 @@
/* ----------------------------------------------------------------------
* p_plug_in_nova_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_nova_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_nova_Vals
{
gint xcenter;
gint ycenter;
t_gint_color color;
gint radius;
gint nspoke;
} t_plug_in_nova_Vals;
t_plug_in_nova_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_nova_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_nova_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_nova_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_nova_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_nova_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_nova_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_nova_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gint(&buf.xcenter, buf_from->xcenter, buf_to->xcenter, total_steps, current_step);
p_delta_gint(&buf.ycenter, buf_from->ycenter, buf_to->ycenter, total_steps, current_step);
p_delta_gint_color(&buf.color, &buf_from->color, &buf_to->color, total_steps, current_step);
p_delta_gint(&buf.radius, buf_from->radius, buf_to->radius, total_steps, current_step);
p_delta_gint(&buf.nspoke, buf_from->nspoke, buf_to->nspoke, total_steps, current_step);
gimp_set_data("plug_in_nova", &buf, sizeof(buf));
return 0; /* OK */
}

35
plug-ins/gap/iter_ALT/mod/plug_in_oilify_iter_ALT.inc Normal file
View file

@ -0,0 +1,35 @@
/* ----------------------------------------------------------------------
* p_plug_in_oilify_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_oilify_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_oilify_Vals
{
gdouble mask_size;
gint mode;
} t_plug_in_oilify_Vals;
t_plug_in_oilify_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_oilify_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_oilify_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_oilify_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_oilify_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_oilify_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_oilify_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_oilify_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.mask_size, buf_from->mask_size, buf_to->mask_size, total_steps, current_step);
p_delta_gint(&buf.mode, buf_from->mode, buf_to->mode, total_steps, current_step);
gimp_set_data("plug_in_oilify", &buf, sizeof(buf));
return 0; /* OK */
}

56
plug-ins/gap/iter_ALT/mod/plug_in_pagecurl_iter_ALT.inc Normal file
View file

@ -0,0 +1,56 @@
/* ----------------------------------------------------------------------
* p_plug_in_pagecurl_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_pagecurl_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_pagecurl_Vals
{
gint do_curl_shade;
gint do_curl_gradient;
gint do_curl_warp; /* Not yet supported... */
double do_curl_opacity;
gint do_shade_under;
gint do_upper_left;
gint do_upper_right;
gint do_lower_left;
gint do_lower_right;
gint do_vertical;
gint do_horizontal;
} t_plug_in_pagecurl_Vals;
t_plug_in_pagecurl_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_pagecurl_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_pagecurl_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_pagecurl_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_pagecurl_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_pagecurl_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_pagecurl_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_pagecurl_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gint(&buf.do_curl_shade, buf_from->do_curl_shade, buf_to->do_curl_shade, total_steps, current_step);
p_delta_gint(&buf.do_curl_gradient, buf_from->do_curl_gradient, buf_to->do_curl_gradient, total_steps, current_step);
p_delta_gint(&buf.do_curl_warp, buf_from->do_curl_warp, buf_to->do_curl_warp, total_steps, current_step);
p_delta_gdouble(&buf.do_curl_opacity, buf_from->do_curl_opacity, buf_to->do_curl_opacity, total_steps, current_step);
p_delta_gint(&buf.do_shade_under, buf_from->do_shade_under, buf_to->do_shade_under, total_steps, current_step);
p_delta_gint(&buf.do_upper_left, buf_from->do_upper_left, buf_to->do_upper_left, total_steps, current_step);
p_delta_gint(&buf.do_upper_right, buf_from->do_upper_right, buf_to->do_upper_right, total_steps, current_step);
p_delta_gint(&buf.do_lower_left, buf_from->do_lower_left, buf_to->do_lower_left, total_steps, current_step);
p_delta_gint(&buf.do_lower_right, buf_from->do_lower_right, buf_to->do_lower_right, total_steps, current_step);
p_delta_gint(&buf.do_vertical, buf_from->do_vertical, buf_to->do_vertical, total_steps, current_step);
p_delta_gint(&buf.do_horizontal, buf_from->do_horizontal, buf_to->do_horizontal, total_steps, current_step);
gimp_set_data("plug_in_pagecurl", &buf, sizeof(buf));
return 0; /* OK */
}

36
plug-ins/gap/iter_ALT/mod/plug_in_plasma_iter_ALT.inc Normal file
View file

@ -0,0 +1,36 @@
/* ----------------------------------------------------------------------
* p_plug_in_plasma_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_plasma_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_plasma_Vals
{
long seed;
gdouble turbulence;
gboolean timeseed;
} t_plug_in_plasma_Vals;
t_plug_in_plasma_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_plasma_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_plasma_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_plasma_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_plasma_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_plasma_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_plasma_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_plasma_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.seed, buf_from->seed, buf_to->seed, total_steps, current_step);
p_delta_gdouble(&buf.turbulence, buf_from->turbulence, buf_to->turbulence, total_steps, current_step);
gimp_set_data("plug_in_plasma", &buf, sizeof(buf));
return 0; /* OK */
}

41
plug-ins/gap/iter_ALT/mod/plug_in_polar_coords_iter_ALT.inc Normal file
View file

@ -0,0 +1,41 @@
/* ----------------------------------------------------------------------
* p_plug_in_polar_coords_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_polar_coords_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_polar_coords_Vals
{
gdouble circle;
gdouble angle;
gint backwards;
gint inverse;
gint polrec;
} t_plug_in_polar_coords_Vals;
t_plug_in_polar_coords_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_polar_coords_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_polar_coords_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_polar_coords_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_polar_coords_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_polar_coords_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_polar_coords_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_polar_coords_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.circle, buf_from->circle, buf_to->circle, total_steps, current_step);
p_delta_gdouble(&buf.angle, buf_from->angle, buf_to->angle, total_steps, current_step);
p_delta_gint(&buf.backwards, buf_from->backwards, buf_to->backwards, total_steps, current_step);
p_delta_gint(&buf.inverse, buf_from->inverse, buf_to->inverse, total_steps, current_step);
p_delta_gint(&buf.polrec, buf_from->polrec, buf_to->polrec, total_steps, current_step);
gimp_set_data("plug_in_polar_coords", &buf, sizeof(buf));
return 0; /* OK */
}

52
plug-ins/gap/iter_ALT/mod/plug_in_sample_colorize_iter_ALT.inc Normal file
View file

@ -0,0 +1,52 @@
/* ----------------------------------------------------------------------
* p_plug_in_sample_colorize_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_sample_colorize_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_sample_colorize_Vals
{
gint32 dst_id; /* do not iterate this one !! */
gint32 sample_drawable;
long hold_inten;
long orig_inten;
long rnd_subcolors;
long guess_missing;
long in_low;
long in_high;
gdouble gamma;
long out_low;
long out_high;
} t_plug_in_sample_colorize_Vals;
t_plug_in_sample_colorize_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_sample_colorize_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_sample_colorize_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_sample_colorize_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_sample_colorize_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_sample_colorize_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_sample_colorize_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_sample_colorize_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_drawable(&buf.sample_drawable, buf_from->sample_drawable, buf_to->sample_drawable, total_steps, current_step);
p_delta_long(&buf.hold_inten, buf_from->hold_inten, buf_to->hold_inten, total_steps, current_step);
p_delta_long(&buf.orig_inten, buf_from->orig_inten, buf_to->orig_inten, total_steps, current_step);
p_delta_long(&buf.rnd_subcolors, buf_from->rnd_subcolors, buf_to->rnd_subcolors, total_steps, current_step);
p_delta_long(&buf.guess_missing, buf_from->guess_missing, buf_to->guess_missing, total_steps, current_step);
p_delta_long(&buf.in_low, buf_from->in_low, buf_to->in_low, total_steps, current_step);
p_delta_long(&buf.in_high, buf_from->in_high, buf_to->in_high, total_steps, current_step);
p_delta_gdouble(&buf.gamma, buf_from->gamma, buf_to->gamma, total_steps, current_step);
p_delta_long(&buf.out_low, buf_from->out_low, buf_to->out_low, total_steps, current_step);
p_delta_long(&buf.out_high, buf_from->out_high, buf_to->out_high, total_steps, current_step);
gimp_set_data("plug_in_sample_colorize", &buf, sizeof(buf));
return 0; /* OK */
}

62
plug-ins/gap/iter_ALT/mod/plug_in_sinus_iter_ALT.inc Normal file
View file

@ -0,0 +1,62 @@
/* ----------------------------------------------------------------------
* p_plug_in_sinus_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_sinus_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef gdouble colRGBA[4];
typedef struct t_plug_in_sinus_Vals
{
gdouble xscale;
gdouble yscale;
gdouble complex;
gdouble blend_power;
gint seed;
gint tiling;
gint perturb;
gint colorization;
gint colors;
colRGBA alpha1;
colRGBA alpha2;
} t_plug_in_sinus_Vals;
t_plug_in_sinus_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_sinus_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_sinus_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_sinus_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_sinus_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_sinus_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_sinus_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_sinus_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.xscale, buf_from->xscale, buf_to->xscale, total_steps, current_step);
p_delta_gdouble(&buf.yscale, buf_from->yscale, buf_to->yscale, total_steps, current_step);
p_delta_gdouble(&buf.complex, buf_from->complex, buf_to->complex, total_steps, current_step);
p_delta_gint(&buf.seed, buf_from->seed, buf_to->seed, total_steps, current_step);
p_delta_gint(&buf.tiling, buf_from->tiling, buf_to->tiling, total_steps, current_step);
p_delta_gint(&buf.perturb, buf_from->perturb, buf_to->perturb, total_steps, current_step);
p_delta_gint(&buf.colorization, buf_from->colorization, buf_to->colorization, total_steps, current_step);
p_delta_gint(&buf.colors, buf_from->colors, buf_to->colors, total_steps, current_step);
p_delta_gdouble(&buf.alpha1[0], buf_from->alpha1[0], buf_to->alpha1[0], total_steps, current_step);
p_delta_gdouble(&buf.alpha1[1], buf_from->alpha1[1], buf_to->alpha1[1], total_steps, current_step);
p_delta_gdouble(&buf.alpha1[2], buf_from->alpha1[2], buf_to->alpha1[2], total_steps, current_step);
p_delta_gdouble(&buf.alpha2[0], buf_from->alpha2[0], buf_to->alpha2[0], total_steps, current_step);
p_delta_gdouble(&buf.alpha2[1], buf_from->alpha2[1], buf_to->alpha2[1], total_steps, current_step);
p_delta_gdouble(&buf.alpha2[2], buf_from->alpha2[2], buf_to->alpha2[2], total_steps, current_step);
p_delta_gdouble(&buf.blend_power, buf_from->blend_power, buf_to->blend_power, total_steps, current_step);
gimp_set_data("plug_in_sinus", &buf, sizeof(buf));
return 0; /* OK */
}

45
plug-ins/gap/iter_ALT/mod/plug_in_solid_noise_iter_ALT.inc Normal file
View file

@ -0,0 +1,45 @@
/* ----------------------------------------------------------------------
* p_plug_in_solid_noise_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_solid_noise_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_solid_noise_Vals
{
long tilable;
long turbulent;
long seed;
long detail;
gdouble xsize;
gdouble ysize;
gint timeseed;
} t_plug_in_solid_noise_Vals;
t_plug_in_solid_noise_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_solid_noise_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_solid_noise_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_solid_noise_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_solid_noise_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_solid_noise_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_solid_noise_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_solid_noise_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.tilable, buf_from->tilable, buf_to->tilable, total_steps, current_step);
p_delta_long(&buf.turbulent, buf_from->turbulent, buf_to->turbulent, total_steps, current_step);
p_delta_long(&buf.seed, buf_from->seed, buf_to->seed, total_steps, current_step);
p_delta_long(&buf.detail, buf_from->detail, buf_to->detail, total_steps, current_step);
p_delta_gdouble(&buf.xsize, buf_from->xsize, buf_to->xsize, total_steps, current_step);
p_delta_gdouble(&buf.ysize, buf_from->ysize, buf_to->ysize, total_steps, current_step);
gimp_set_data("plug_in_solid_noise", &buf, sizeof(buf));
return 0; /* OK */
}

41
plug-ins/gap/iter_ALT/mod/plug_in_sparkle_iter_ALT.inc Normal file
View file

@ -0,0 +1,41 @@
/* ----------------------------------------------------------------------
* p_plug_in_sparkle_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_sparkle_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_sparkle_Vals
{
gdouble lum_threshold;
gdouble flare_inten;
gdouble spike_len;
gdouble spike_pts;
gdouble spike_angle;
} t_plug_in_sparkle_Vals;
t_plug_in_sparkle_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_sparkle_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_sparkle_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_sparkle_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_sparkle_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_sparkle_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_sparkle_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_sparkle_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.lum_threshold, buf_from->lum_threshold, buf_to->lum_threshold, total_steps, current_step);
p_delta_gdouble(&buf.flare_inten, buf_from->flare_inten, buf_to->flare_inten, total_steps, current_step);
p_delta_gdouble(&buf.spike_len, buf_from->spike_len, buf_to->spike_len, total_steps, current_step);
p_delta_gdouble(&buf.spike_pts, buf_from->spike_pts, buf_to->spike_pts, total_steps, current_step);
p_delta_gdouble(&buf.spike_angle, buf_from->spike_angle, buf_to->spike_angle, total_steps, current_step);
gimp_set_data("plug_in_sparkle", &buf, sizeof(buf));
return 0; /* OK */
}

33
plug-ins/gap/iter_ALT/old/Colorify_iter_ALT.inc Normal file
View file

@ -0,0 +1,33 @@
/* ----------------------------------------------------------------------
* p_Colorify_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_Colorify_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_Colorify_Vals
{
t_color color;
} t_Colorify_Vals;
t_Colorify_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_Colorify_Vals))
{
fprintf(stderr, "ERROR: p_Colorify_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_Colorify_Vals) );
return -1; /* ERROR */
}
gimp_get_data("Colorify_ITER_FROM", g_plugin_data_from);
gimp_get_data("Colorify_ITER_TO", g_plugin_data_to);
buf_from = (t_Colorify_Vals *)&g_plugin_data_from[0];
buf_to = (t_Colorify_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_color(&buf.color, &buf_from->color, &buf_to->color, total_steps, current_step);
gimp_set_data("Colorify", &buf, sizeof(buf));
return 0; /* OK */
}

43
plug-ins/gap/iter_ALT/old/plug_in_CentralReflection_iter_ALT.inc Normal file
View file

@ -0,0 +1,43 @@
/* ----------------------------------------------------------------------
* p_plug_in_CentralReflection_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_CentralReflection_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_CentralReflection_Vals
{
gdouble circle_radius;
gint keep_surroundings;
gint set_background;
gint set_transparent;
gint use_antialias;
gint flip;
} t_plug_in_CentralReflection_Vals;
t_plug_in_CentralReflection_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_CentralReflection_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_CentralReflection_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_CentralReflection_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_CentralReflection_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_CentralReflection_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_CentralReflection_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_CentralReflection_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.circle_radius, buf_from->circle_radius, buf_to->circle_radius, total_steps, current_step);
p_delta_gint(&buf.keep_surroundings, buf_from->keep_surroundings, buf_to->keep_surroundings, total_steps, current_step);
p_delta_gint(&buf.set_background, buf_from->set_background, buf_to->set_background, total_steps, current_step);
p_delta_gint(&buf.set_transparent, buf_from->set_transparent, buf_to->set_transparent, total_steps, current_step);
p_delta_gint(&buf.use_antialias, buf_from->use_antialias, buf_to->use_antialias, total_steps, current_step);
p_delta_gint(&buf.flip, buf_from->flip, buf_to->flip, total_steps, current_step);
gimp_set_data("plug_in_CentralReflection", &buf, sizeof(buf));
return 0; /* OK */
}

47
plug-ins/gap/iter_ALT/old/plug_in_anamorphose_iter_ALT.inc Normal file
View file

@ -0,0 +1,47 @@
/* ----------------------------------------------------------------------
* p_plug_in_anamorphose_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_anamorphose_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_anamorphose_Vals
{
gdouble cone_radius;
gdouble base_angle;
long keep_surroundings;
long set_background;
long set_transparent;
long use_antialias;
long flip;
long ndouble;
} t_plug_in_anamorphose_Vals;
t_plug_in_anamorphose_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_anamorphose_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_anamorphose_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_anamorphose_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_anamorphose_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_anamorphose_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_anamorphose_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_anamorphose_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.cone_radius, buf_from->cone_radius, buf_to->cone_radius, total_steps, current_step);
p_delta_gdouble(&buf.base_angle, buf_from->base_angle, buf_to->base_angle, total_steps, current_step);
p_delta_long(&buf.keep_surroundings, buf_from->keep_surroundings, buf_to->keep_surroundings, total_steps, current_step);
p_delta_long(&buf.set_background, buf_from->set_background, buf_to->set_background, total_steps, current_step);
p_delta_long(&buf.set_transparent, buf_from->set_transparent, buf_to->set_transparent, total_steps, current_step);
p_delta_long(&buf.use_antialias, buf_from->use_antialias, buf_to->use_antialias, total_steps, current_step);
p_delta_long(&buf.flip, buf_from->flip, buf_to->flip, total_steps, current_step);
p_delta_long(&buf.ndouble, buf_from->ndouble, buf_to->ndouble, total_steps, current_step);
gimp_set_data("plug_in_anamorphose", &buf, sizeof(buf));
return 0; /* OK */
}

33
plug-ins/gap/iter_ALT/old/plug_in_blur2_iter_ALT.inc Normal file
View file

@ -0,0 +1,33 @@
/* ----------------------------------------------------------------------
* p_plug_in_blur2_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_blur2_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_blur2_Vals
{
gdouble mask_size;
} t_plug_in_blur2_Vals;
t_plug_in_blur2_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_blur2_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_blur2_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_blur2_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_blur2_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_blur2_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_blur2_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_blur2_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.mask_size, buf_from->mask_size, buf_to->mask_size, total_steps, current_step);
gimp_set_data("plug_in_blur2", &buf, sizeof(buf));
return 0; /* OK */
}

35
plug-ins/gap/iter_ALT/old/plug_in_encript_iter_ALT.inc Normal file
View file

@ -0,0 +1,35 @@
/* ----------------------------------------------------------------------
* p_plug_in_encript_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_encript_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_encript_Vals
{
gint password;
gint warning;
} t_plug_in_encript_Vals;
t_plug_in_encript_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_encript_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_encript_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_encript_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_encript_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_encript_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_encript_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_encript_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gint(&buf.password, buf_from->password, buf_to->password, total_steps, current_step);
p_delta_gint(&buf.warning, buf_from->warning, buf_to->warning, total_steps, current_step);
gimp_set_data("plug_in_encript", &buf, sizeof(buf));
return 0; /* OK */
}

41
plug-ins/gap/iter_ALT/old/plug_in_figures_iter_ALT.inc Normal file
View file

@ -0,0 +1,41 @@
/* ----------------------------------------------------------------------
* p_plug_in_figures_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_figures_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_figures_Vals
{
gint min_width;
gint max_width;
gint min_height;
gint max_height;
float density;
} t_plug_in_figures_Vals;
t_plug_in_figures_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_figures_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_figures_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_figures_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_figures_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_figures_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_figures_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_figures_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_float(&buf.density, buf_from->density, buf_to->density, total_steps, current_step);
p_delta_gint(&buf.min_width, buf_from->min_width, buf_to->min_width, total_steps, current_step);
p_delta_gint(&buf.max_width, buf_from->max_width, buf_to->max_width, total_steps, current_step);
p_delta_gint(&buf.min_height, buf_from->min_height, buf_to->min_height, total_steps, current_step);
p_delta_gint(&buf.max_height, buf_from->max_height, buf_to->max_height, total_steps, current_step);
gimp_set_data("plug_in_figures", &buf, sizeof(buf));
return 0; /* OK */
}

53
plug-ins/gap/iter_ALT/old/plug_in_gflare_iter_ALT.inc Normal file
View file

@ -0,0 +1,53 @@
/* ----------------------------------------------------------------------
* p_plug_in_gflare_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_gflare_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
#define GFLARE_NAME_MAX 256
typedef struct t_plug_in_gflare_Vals
{
gint xcenter;
gint ycenter;
gdouble radius;
gdouble rotation;
gdouble hue;
gdouble vangle;
gdouble vlength;
gint use_asupsample;
gint asupsample_max_depth;
gdouble asupsample_threshold;
char gflare_name[GFLARE_NAME_MAX];
} t_plug_in_gflare_Vals;
t_plug_in_gflare_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_gflare_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_gflare_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_gflare_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_gflare_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_gflare_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_gflare_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_gflare_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gint(&buf.xcenter, buf_from->xcenter, buf_to->xcenter, total_steps, current_step);
p_delta_gint(&buf.ycenter, buf_from->ycenter, buf_to->ycenter, total_steps, current_step);
p_delta_gdouble(&buf.radius, buf_from->radius, buf_to->radius, total_steps, current_step);
p_delta_gdouble(&buf.rotation, buf_from->rotation, buf_to->rotation, total_steps, current_step);
p_delta_gdouble(&buf.hue, buf_from->hue, buf_to->hue, total_steps, current_step);
p_delta_gdouble(&buf.vangle, buf_from->vangle, buf_to->vangle, total_steps, current_step);
p_delta_gdouble(&buf.vlength, buf_from->vlength, buf_to->vlength, total_steps, current_step);
p_delta_gint(&buf.use_asupsample, buf_from->use_asupsample, buf_to->use_asupsample, total_steps, current_step);
p_delta_gint(&buf.asupsample_max_depth, buf_from->asupsample_max_depth, buf_to->asupsample_max_depth, total_steps, current_step);
p_delta_gdouble(&buf.asupsample_threshold, buf_from->asupsample_threshold, buf_to->asupsample_threshold, total_steps, current_step);
gimp_set_data("plug_in_gflare", &buf, sizeof(buf));
return 0; /* OK */
}

39
plug-ins/gap/iter_ALT/old/plug_in_holes_iter_ALT.inc Normal file
View file

@ -0,0 +1,39 @@
/* ----------------------------------------------------------------------
* p_plug_in_holes_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_holes_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_holes_Vals
{
gdouble density;
long shape;
long size;
long flag;
} t_plug_in_holes_Vals;
t_plug_in_holes_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_holes_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_holes_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_holes_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_holes_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_holes_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_holes_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_holes_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.density, buf_from->density, buf_to->density, total_steps, current_step);
p_delta_long(&buf.shape, buf_from->shape, buf_to->shape, total_steps, current_step);
p_delta_long(&buf.size, buf_from->size, buf_to->size, total_steps, current_step);
p_delta_long(&buf.flag, buf_from->flag, buf_to->flag, total_steps, current_step);
gimp_set_data("plug_in_holes", &buf, sizeof(buf));
return 0; /* OK */
}

59
plug-ins/gap/iter_ALT/old/plug_in_julia_iter_ALT.inc Normal file
View file

@ -0,0 +1,59 @@
/* ----------------------------------------------------------------------
* p_plug_in_julia_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_julia_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_julia_Vals
{
gdouble xmin;
gdouble xmax;
gdouble ymin;
gdouble ymax;
gdouble iter;
gdouble cx;
gdouble cy;
gint colormode;
gdouble redstretch;
gdouble greenstretch;
gdouble bluestretch;
gint redmode;
gint greenmode;
gint bluemode;
} t_plug_in_julia_Vals;
t_plug_in_julia_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_julia_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_julia_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_julia_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_julia_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_julia_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_julia_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_julia_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.xmin, buf_from->xmin, buf_to->xmin, total_steps, current_step);
p_delta_gdouble(&buf.xmax, buf_from->xmax, buf_to->xmax, total_steps, current_step);
p_delta_gdouble(&buf.ymin, buf_from->ymin, buf_to->ymin, total_steps, current_step);
p_delta_gdouble(&buf.ymax, buf_from->ymax, buf_to->ymax, total_steps, current_step);
p_delta_gdouble(&buf.iter, buf_from->iter, buf_to->iter, total_steps, current_step);
p_delta_gdouble(&buf.cx, buf_from->cx, buf_to->cx, total_steps, current_step);
p_delta_gdouble(&buf.cy, buf_from->cy, buf_to->cy, total_steps, current_step);
p_delta_gint(&buf.colormode, buf_from->colormode, buf_to->colormode, total_steps, current_step);
p_delta_gdouble(&buf.redstretch, buf_from->redstretch, buf_to->redstretch, total_steps, current_step);
p_delta_gdouble(&buf.greenstretch, buf_from->greenstretch, buf_to->greenstretch, total_steps, current_step);
p_delta_gdouble(&buf.bluestretch, buf_from->bluestretch, buf_to->bluestretch, total_steps, current_step);
p_delta_gint(&buf.redmode, buf_from->redmode, buf_to->redmode, total_steps, current_step);
p_delta_gint(&buf.greenmode, buf_from->greenmode, buf_to->greenmode, total_steps, current_step);
p_delta_gint(&buf.bluemode, buf_from->bluemode, buf_to->bluemode, total_steps, current_step);
gimp_set_data("plug_in_julia", &buf, sizeof(buf));
return 0; /* OK */
}

33
plug-ins/gap/iter_ALT/old/plug_in_magic_eye_iter_ALT.inc Normal file
View file

@ -0,0 +1,33 @@
/* ----------------------------------------------------------------------
* p_plug_in_magic_eye_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_magic_eye_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_magic_eye_Vals
{
long mapimage;
} t_plug_in_magic_eye_Vals;
t_plug_in_magic_eye_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_magic_eye_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_magic_eye_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_magic_eye_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_magic_eye_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_magic_eye_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_magic_eye_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_magic_eye_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.mapimage, buf_from->mapimage, buf_to->mapimage, total_steps, current_step);
gimp_set_data("plug_in_magic_eye", &buf, sizeof(buf));
return 0; /* OK */
}

55
plug-ins/gap/iter_ALT/old/plug_in_mandelbrot_iter_ALT.inc Normal file
View file

@ -0,0 +1,55 @@
/* ----------------------------------------------------------------------
* p_plug_in_mandelbrot_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_mandelbrot_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_mandelbrot_Vals
{
gdouble xmin;
gdouble xmax;
gdouble ymin;
gdouble ymax;
gdouble iter;
gint colormode;
gdouble redstretch;
gdouble greenstretch;
gdouble bluestretch;
gint redmode;
gint greenmode;
gint bluemode;
} t_plug_in_mandelbrot_Vals;
t_plug_in_mandelbrot_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_mandelbrot_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_mandelbrot_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_mandelbrot_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_mandelbrot_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_mandelbrot_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_mandelbrot_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_mandelbrot_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.xmin, buf_from->xmin, buf_to->xmin, total_steps, current_step);
p_delta_gdouble(&buf.xmax, buf_from->xmax, buf_to->xmax, total_steps, current_step);
p_delta_gdouble(&buf.ymin, buf_from->ymin, buf_to->ymin, total_steps, current_step);
p_delta_gdouble(&buf.ymax, buf_from->ymax, buf_to->ymax, total_steps, current_step);
p_delta_gdouble(&buf.iter, buf_from->iter, buf_to->iter, total_steps, current_step);
p_delta_gint(&buf.colormode, buf_from->colormode, buf_to->colormode, total_steps, current_step);
p_delta_gdouble(&buf.redstretch, buf_from->redstretch, buf_to->redstretch, total_steps, current_step);
p_delta_gdouble(&buf.greenstretch, buf_from->greenstretch, buf_to->greenstretch, total_steps, current_step);
p_delta_gdouble(&buf.bluestretch, buf_from->bluestretch, buf_to->bluestretch, total_steps, current_step);
p_delta_gint(&buf.redmode, buf_from->redmode, buf_to->redmode, total_steps, current_step);
p_delta_gint(&buf.greenmode, buf_from->greenmode, buf_to->greenmode, total_steps, current_step);
p_delta_gint(&buf.bluemode, buf_from->bluemode, buf_to->bluemode, total_steps, current_step);
gimp_set_data("plug_in_mandelbrot", &buf, sizeof(buf));
return 0; /* OK */
}

39
plug-ins/gap/iter_ALT/old/plug_in_randomize_iter_ALT.inc Normal file
View file

@ -0,0 +1,39 @@
/* ----------------------------------------------------------------------
* p_plug_in_randomize_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_randomize_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_randomize_Vals
{
gint rndm_type;
gdouble rndm_pct;
gint seed_type;
gint rndm_seed;
gdouble rndm_rcount;
} t_plug_in_randomize_Vals;
t_plug_in_randomize_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_randomize_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_randomize_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_randomize_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_randomize_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_randomize_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_randomize_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_randomize_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gint(&buf.rndm_type, buf_from->rndm_type, buf_to->rndm_type, total_steps, current_step);
p_delta_gdouble(&buf.rndm_pct, buf_from->rndm_pct, buf_to->rndm_pct, total_steps, current_step);
p_delta_gdouble(&buf.rndm_rcount, buf_from->rndm_rcount, buf_to->rndm_rcount, total_steps, current_step);
gimp_set_data("plug_in_randomize", &buf, sizeof(buf));
return 0; /* OK */
}

50
plug-ins/gap/iter_ALT/old/plug_in_refract_iter_ALT.inc Normal file
View file

@ -0,0 +1,50 @@
/* ----------------------------------------------------------------------
* p_plug_in_refract_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_refract_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_refract_Vals
{
gint32 lens_id;
gint32 refl_id;
long thick;
long refr_dist;
long refl_dist;
gdouble na;
gdouble nb;
long edge;
long newl;
long xofs;
long yofs;
} t_plug_in_refract_Vals;
t_plug_in_refract_Vals buf, buf_from, buf_to;
if(len_struct != sizeof(t_plug_in_refract_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_refract_iter stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_refract_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_refract_ITER_FROM", &buf_from);
gimp_get_data("plug_in_refract_ITER_TO", &buf_to);
memcpy(&buf, &buf_from, sizeof(buf));
p_delta_drawable(&buf.lens_id, buf_from.lens_id, buf_to.lens_id, total_steps, current_step);
p_delta_drawable(&buf.refl_id, buf_from.refl_id, buf_to.refl_id, total_steps, current_step);
p_delta_long(&buf.thick, buf_from.thick, buf_to.thick, total_steps, current_step);
p_delta_long(&buf.refr_dist, buf_from.refr_dist, buf_to.refr_dist, total_steps, current_step);
p_delta_long(&buf.refl_dist, buf_from.refl_dist, buf_to.refl_dist, total_steps, current_step);
p_delta_gdouble(&buf.na, buf_from.na, buf_to.na, total_steps, current_step);
p_delta_gdouble(&buf.nb, buf_from.nb, buf_to.nb, total_steps, current_step);
p_delta_long(&buf.edge, buf_from.edge, buf_to.edge, total_steps, current_step);
p_delta_long(&buf.newl, buf_from.newl, buf_to.newl, total_steps, current_step);
p_delta_long(&buf.xofs, buf_from.xofs, buf_to.xofs, total_steps, current_step);
p_delta_long(&buf.yofs, buf_from.yofs, buf_to.yofs, total_steps, current_step);
gimp_set_data("plug_in_refract", &buf, sizeof(buf));
return 0; /* OK */
}

35
plug-ins/gap/iter_ALT/old/plug_in_struc_iter_ALT.inc Normal file
View file

@ -0,0 +1,35 @@
/* ----------------------------------------------------------------------
* p_plug_in_struc_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_struc_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_struc_Vals
{
long direction;
long depth;
} t_plug_in_struc_Vals;
t_plug_in_struc_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_struc_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_struc_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_struc_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_struc_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_struc_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_struc_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_struc_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.direction, buf_from->direction, buf_to->direction, total_steps, current_step);
p_delta_long(&buf.depth, buf_from->depth, buf_to->depth, total_steps, current_step);
gimp_set_data("plug_in_struc", &buf, sizeof(buf));
return 0; /* OK */
}

33
plug-ins/gap/iter_ALT/old/plug_in_tileit_iter_ALT.inc Normal file
View file

@ -0,0 +1,33 @@
/* ----------------------------------------------------------------------
* p_plug_in_tileit_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_tileit_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_tileit_Vals
{
long number_of_tiles;
} t_plug_in_tileit_Vals;
t_plug_in_tileit_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_tileit_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_tileit_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_tileit_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_tileit_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_tileit_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_tileit_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_tileit_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.number_of_tiles, buf_from->number_of_tiles, buf_to->number_of_tiles, total_steps, current_step);
gimp_set_data("plug_in_tileit", &buf, sizeof(buf));
return 0; /* OK */
}

55
plug-ins/gap/iter_ALT/old/plug_in_universal_filter_iter_ALT.inc Normal file
View file

@ -0,0 +1,55 @@
/* ----------------------------------------------------------------------
* p_plug_in_universal_filter_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_universal_filter_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_universal_filter_Vals
{
long matrix_0_0;
long matrix_0_1;
long matrix_0_2;
long matrix_1_0;
long matrix_1_1;
long matrix_1_2;
long matrix_2_0;
long matrix_2_1;
long matrix_2_2;
long xauto;
long norm;
long bias;
} t_plug_in_universal_filter_Vals;
t_plug_in_universal_filter_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_universal_filter_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_universal_filter_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_universal_filter_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_universal_filter_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_universal_filter_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_universal_filter_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_universal_filter_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_long(&buf.matrix_0_0, buf_from->matrix_0_0, buf_to->matrix_0_0, total_steps, current_step);
p_delta_long(&buf.matrix_0_1, buf_from->matrix_0_1, buf_to->matrix_0_1, total_steps, current_step);
p_delta_long(&buf.matrix_0_2, buf_from->matrix_0_2, buf_to->matrix_0_2, total_steps, current_step);
p_delta_long(&buf.matrix_1_0, buf_from->matrix_1_0, buf_to->matrix_1_0, total_steps, current_step);
p_delta_long(&buf.matrix_1_1, buf_from->matrix_1_1, buf_to->matrix_1_1, total_steps, current_step);
p_delta_long(&buf.matrix_1_2, buf_from->matrix_1_2, buf_to->matrix_1_2, total_steps, current_step);
p_delta_long(&buf.matrix_2_0, buf_from->matrix_2_0, buf_to->matrix_2_0, total_steps, current_step);
p_delta_long(&buf.matrix_2_1, buf_from->matrix_2_1, buf_to->matrix_2_1, total_steps, current_step);
p_delta_long(&buf.matrix_2_2, buf_from->matrix_2_2, buf_to->matrix_2_2, total_steps, current_step);
p_delta_long(&buf.xauto, buf_from->xauto, buf_to->xauto, total_steps, current_step);
p_delta_long(&buf.norm, buf_from->norm, buf_to->norm, total_steps, current_step);
p_delta_long(&buf.bias, buf_from->bias, buf_to->bias, total_steps, current_step);
gimp_set_data("plug_in_universal_filter", &buf, sizeof(buf));
return 0; /* OK */
}

45
plug-ins/gap/iter_ALT/old/plug_in_warp_iter_ALT.inc Normal file
View file

@ -0,0 +1,45 @@
/* ----------------------------------------------------------------------
* p_plug_in_warp_iter_ALT
* ----------------------------------------------------------------------
*/
gint p_plug_in_warp_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{
typedef struct t_plug_in_warp_Vals
{
gdouble amount;
gdouble angle;
gdouble iter;
gdouble dither;
gint warp_map;
gint wrap_type;
gint mag_map;
gint mag_option;
} t_plug_in_warp_Vals;
t_plug_in_warp_Vals buf, *buf_from, *buf_to;
if(len_struct != sizeof(t_plug_in_warp_Vals))
{
fprintf(stderr, "ERROR: p_plug_in_warp_iter_ALT stored Data missmatch in size %d != %d\n",
(int)len_struct, sizeof(t_plug_in_warp_Vals) );
return -1; /* ERROR */
}
gimp_get_data("plug_in_warp_ITER_FROM", g_plugin_data_from);
gimp_get_data("plug_in_warp_ITER_TO", g_plugin_data_to);
buf_from = (t_plug_in_warp_Vals *)&g_plugin_data_from[0];
buf_to = (t_plug_in_warp_Vals *)&g_plugin_data_to[0];
memcpy(&buf, buf_from, sizeof(buf));
p_delta_gdouble(&buf.amount, buf_from->amount, buf_to->amount, total_steps, current_step);
p_delta_gdouble(&buf.angle, buf_from->angle, buf_to->angle, total_steps, current_step);
p_delta_gdouble(&buf.iter, buf_from->iter, buf_to->iter, total_steps, current_step);
p_delta_gdouble(&buf.dither, buf_from->dither, buf_to->dither, total_steps, current_step);
p_delta_gint(&buf.wrap_type, buf_from->wrap_type, buf_to->wrap_type, total_steps, current_step);
p_delta_gint(&buf.mag_option, buf_from->mag_option, buf_to->mag_option, total_steps, current_step);
gimp_set_data("plug_in_warp", &buf, sizeof(buf));
return 0; /* OK */
}