AlderconeStudio/PIKApp
0
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 1 Wiki Activity

Updated with upstream update

Browse Source
This commit is contained in:
Cassowary
2023-10-30 15:55:30 -07:00
parent 098531073c
commit 3bbdd873ef
584 changed files with 91827 additions and 70362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
plug-ins/map-object/map-object-apply.c
View File

@ -326,3 +326,90 @@ compute_image (void)
pika_image_undo_group_end (new_image);
}
void
copy_from_config (PikaProcedureConfig *config)
{
PikaDrawable *box_front = NULL;
PikaDrawable *box_back = NULL;
PikaDrawable *box_top = NULL;
PikaDrawable *box_bottom = NULL;
PikaDrawable *box_left = NULL;
PikaDrawable *box_right = NULL;
PikaDrawable *cyl_top = NULL;
PikaDrawable *cyl_bottom = NULL;
mapvals.maptype = pika_procedure_config_get_choice_id (config, "map-type");
mapvals.lightsource.type =
pika_procedure_config_get_choice_id (config, "light-type");
g_object_get (config,
"viewpoint-x", &mapvals.viewpoint.x,
"viewpoint-y", &mapvals.viewpoint.y,
"viewpoint-z", &mapvals.viewpoint.z,
"position-x", &mapvals.position.x,
"position-y", &mapvals.position.y,
"position-z", &mapvals.position.z,
"first-axis-x", &mapvals.firstaxis.x,
"first-axis-y", &mapvals.firstaxis.y,
"first-axis-z", &mapvals.firstaxis.z,
"second-axis-x", &mapvals.secondaxis.x,
"second-axis-y", &mapvals.secondaxis.y,
"second-axis-z", &mapvals.secondaxis.z,
"rotation-angle-x", &mapvals.alpha,
"rotation-angle-y", &mapvals.beta,
"rotation-angle-z", &mapvals.gamma,
"light-color", &mapvals.lightsource.color,
"light-position-x", &mapvals.lightsource.position.x,
"light-position-y", &mapvals.lightsource.position.y,
"light-position-z", &mapvals.lightsource.position.z,
"light-direction-x", &mapvals.lightsource.direction.x,
"light-direction-y", &mapvals.lightsource.direction.y,
"light-direction-z", &mapvals.lightsource.direction.z,
"ambient-intensity", &mapvals.material.ambient_int,
"diffuse-intensity", &mapvals.material.diffuse_int,
"diffuse-reflectivity", &mapvals.material.diffuse_ref,
"specular-reflectivity", &mapvals.material.specular_ref,
"highlight", &mapvals.material.highlight,
"antialiasing", &mapvals.antialiasing,
"depth", &mapvals.maxdepth,
"threshold", &mapvals.pixelthreshold,
"tiled", &mapvals.tiled,
"new-image", &mapvals.create_new_image,
"new-layer", &mapvals.create_new_layer,
"transparent-background", &mapvals.transparent_background,
"sphere-radius", &mapvals.radius,
"box-front-drawable", &box_front,
"box-back-drawable", &box_back,
"box-top-drawable", &box_top,
"box-bottom-drawable", &box_bottom,
"box-left-drawable", &box_left,
"box-right-drawable", &box_right,
"x-scale", &mapvals.scale.x,
"y-scale", &mapvals.scale.y,
"z-scale", &mapvals.scale.z,
"cyl-top-drawable", &cyl_top,
"cyl-bottom-drawable", &cyl_bottom,
"cylinder-radius", &mapvals.cylinder_radius,
"cylinder-length", &mapvals.cylinder_length,
NULL);
if (box_front)
mapvals.boxmap_id[0] = pika_item_get_id (PIKA_ITEM (box_front));
if (box_back)
mapvals.boxmap_id[1] = pika_item_get_id (PIKA_ITEM (box_back));
if (box_top)
mapvals.boxmap_id[2] = pika_item_get_id (PIKA_ITEM (box_top));
if (box_bottom)
mapvals.boxmap_id[3] = pika_item_get_id (PIKA_ITEM (box_bottom));
if (box_left)
mapvals.boxmap_id[4] = pika_item_get_id (PIKA_ITEM (box_left));
if (box_right)
mapvals.boxmap_id[5] = pika_item_get_id (PIKA_ITEM (box_right));
if (cyl_top)
mapvals.cylindermap_id[0] = pika_item_get_id (PIKA_ITEM (cyl_top));
if (cyl_bottom)
mapvals.cylindermap_id[0] = pika_item_get_id (PIKA_ITEM (cyl_bottom));
}

5
plug-ins/map-object/map-object-apply.h
View File

@ -4,7 +4,8 @@
extern gdouble imat[4][4];
extern gfloat rotmat[16];
void init_compute (void);
void compute_image (void);
void init_compute (void);
void compute_image (void);
void copy_from_config (PikaProcedureConfig *config);
#endif /* __MAPOBJECT_APPLY_H__ */

13
plug-ins/map-object/map-object-image.c
View File

@ -311,12 +311,19 @@ get_cylinder_image_color (gint image,
/****************************************/
gint
image_setup (PikaDrawable *drawable,
gint interactive)
image_setup (PikaDrawable *drawable,
gint interactive,
PikaProcedureConfig *config)
{
gboolean transparent_background;
input_drawable = drawable;
output_drawable = drawable;
g_object_get (config,
"transparent_background", &transparent_background,
NULL);
if (! pika_drawable_mask_intersect (drawable, &border_x, &border_y,
&border_w, &border_h))
return FALSE;
@ -328,7 +335,7 @@ image_setup (PikaDrawable *drawable,
maxcounter = (glong) width * (glong) height;
if (mapvals.transparent_background == TRUE)
if (transparent_background == TRUE)
{
pika_rgba_set (&background, 0.0, 0.0, 0.0, 0.0);
}

4
plug-ins/map-object/map-object-image.h
View File

@ -31,7 +31,9 @@ extern gint border_x1, border_y1, border_x2, border_y2;
/* ============================ */
extern gint image_setup (PikaDrawable *drawable,
gint interactive);
gint interactive,
PikaProcedureConfig
*config);
extern glong in_xy_to_index (gint x,
gint y);
extern glong out_xy_to_index (gint x,

367
plug-ins/map-object/map-object-main.c
View File

@ -53,7 +53,7 @@ struct _MapClass
#define MAP_TYPE (map_get_type ())
#define MAP (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAP_TYPE, Map))
#define MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAP_TYPE, Map))
GType map_get_type (void) G_GNUC_CONST;
@ -66,7 +66,7 @@ static PikaValueArray * map_run (PikaProcedure *procedure,
PikaImage *image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data);
static void set_default_settings (void);
@ -111,8 +111,8 @@ map_create_procedure (PikaPlugIn *plug_in,
PikaRGB white = { 1.0, 1.0, 1.0, 1.0 };
procedure = pika_image_procedure_new (plug_in, name,
PIKA_PDB_PROC_TYPE_PLUGIN,
map_run, NULL, NULL);
PIKA_PDB_PROC_TYPE_PLUGIN,
map_run, NULL, NULL);
pika_procedure_set_image_types (procedure, "RGB*");
pika_procedure_set_sensitivity_mask (procedure,
@ -131,261 +131,298 @@ map_create_procedure (PikaPlugIn *plug_in,
"Tom Bech & Federico Mena Quintero",
"Version 1.2.0, July 16 1998");
PIKA_PROC_ARG_INT (procedure, "map-type",
"Map type",
"Type of mapping (0=plane, 1=sphere, 2=box, "
"3=cylinder)",
0, 2, MAP_PLANE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_CHOICE (procedure, "map-type",
_("Map _to"),
_("Type of mapping"),
pika_choice_new_with_values ("map-plane", MAP_PLANE, _("Plane"), NULL,
"map-sphere", MAP_SPHERE, _("Sphere"), NULL,
"map-box", MAP_BOX, _("Box"), NULL,
"map-cylinder", MAP_CYLINDER, _("Cylinder"), NULL,
NULL),
"map-plane",
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "viewpoint-x",
"Viewpoint X",
"Position of viewpoint (x,y,z)",
_("X"),
_("Position of viewpoint (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "viewpoint-y",
"Viewpoint Y",
"Position of viewpoint (x,y,z)",
_("Y"),
_("Position of viewpoint (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "viewpoint-z",
"Viewpoint Z",
"Position of viewpoint (x,y,z)",
_("Z"),
_("Position of viewpoint (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 2.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "position-x",
"Position X",
"Object position (x,y,z)",
-G_MAXDOUBLE, G_MAXDOUBLE, 0.5,
_("Position X"),
_("Object position (x,y,z)"),
-1.0, 2.0, 0.5,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "position-y",
"Position Y",
"Object position (x,y,z)",
-G_MAXDOUBLE, G_MAXDOUBLE, 0.5,
_("Position Y"),
_("Object position (x,y,z)"),
-1.0, 2.0, 0.5,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "position-z",
"Position Z",
"Object position (x,y,z)",
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
_("Position Z"),
_("Object position (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "first-axis-x",
"First axis X",
"First axis of object (x,y,z)",
-G_MAXDOUBLE, G_MAXDOUBLE, 1.0,
_("X"),
_("First axis of object (x,y,z)"),
-1.0, 2.0, 1.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "first-axis-y",
"First axis y",
"First axis of object (x,y,z)",
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
_("y"),
_("First axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "first-axis-z",
"First axis Z",
"First axis of object (x,y,z)",
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
_("Z"),
_("First axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "second-axis-x",
"Second axis X",
"Second axis of object (x,y,z)",
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
_("X"),
_("Second axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "second-axis-y",
"Second axis Y",
"Second axis of object (x,y,z)",
-G_MAXDOUBLE, G_MAXDOUBLE, 1.0,
_("Y"),
_("Second axis of object (x,y,z)"),
-1.0, 2.0, 1.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "second-axis-z",
"Second axis Z",
"Second axis of object (x,y,z)",
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
_("Z"),
_("Second axis of object (x,y,z)"),
-1.0, 2.0, 0.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "rotation-angle-x",
"Rotation angle X",
"Rotation about X axis in degrees",
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
_("Angle X"),
_("Rotation about X axis in degrees"),
-180, 180, 0.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "rotation-angle-y",
"Rotation angle Y",
"Rotation about Y axis in degrees",
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
_("Angle Y"),
_("Rotation about Y axis in degrees"),
-180, 180, 0.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "rotation-angle-z",
"Rotation angle Z",
"Rotation about Z axis in degrees",
-G_MAXDOUBLE, G_MAXDOUBLE, 0.0,
_("Angle Z"),
_("Rotation about Z axis in degrees"),
-180, 180, 0.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_INT (procedure, "light-type",
"Light type",
"Type of lightsource (0=point, 1=directional, 2=none)",
0, 2, POINT_LIGHT,
G_PARAM_READWRITE);
PIKA_PROC_ARG_CHOICE (procedure, "light-type",
_("Light source type"),
_("Type of lightsource"),
pika_choice_new_with_values ("point-light", POINT_LIGHT, _("Point Light"), NULL,
"directional-light", DIRECTIONAL_LIGHT, _("Directional Light"), NULL,
"no-light", NO_LIGHT, _("No Light"), NULL,
NULL),
"point-light",
G_PARAM_READWRITE);
PIKA_PROC_ARG_RGB (procedure, "light-color",
"Light color",
"Light source color",
_("Light source _color"),
_("Light source color"),
TRUE, &white,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "light-position-x",
"Light position X",
"Light source position (x,y,z)",
_("Light position X"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -0.5,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "light-position-y",
"Light position Y",
"Light source position (x,y,z)",
_("Light position Y"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -0.5,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "light-position-z",
"Light position Z",
"Light source position (x,y,z)",
_("Light position Z"),
_("Light source position (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 2.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "light-direction-x",
"Light direction X",
"Light source direction (x,y,z)",
_("Light direction X"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "light-direction-y",
"Light direction Y",
"Light source direction (x,y,z)",
_("Light direction Y"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, -1.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "light-direction-z",
"Light direction Z",
"Light source direction (x,y,z)",
_("Light direction Z"),
_("Light source direction (x,y,z)"),
-G_MAXDOUBLE, G_MAXDOUBLE, 1.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "ambient-intensity",
"Ambient intensity",
"Material ambient intensity",
_("Ambie_nt"),
_("Material ambient intensity"),
0, 1, 0.3,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "diffuse-intensity",
"Diffuse intensity",
"Material diffuse intensity",
_("D_iffuse"),
_("Material diffuse intensity"),
0, 1, 1.0,
G_PARAM_READWRITE);
/* Reflectivity */
PIKA_PROC_ARG_DOUBLE (procedure, "diffuse-reflectivity",
"Diffuse reflectivity",
"Material diffuse reflectivity",
_("Di_ffuse"),
_("Material diffuse reflectivity"),
0, 1, 0.5,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "specular-reflectivity",
"Specular reflectivity",
"Material specular reflectivity",
_("Spec_ular"),
_("Material specular reflectivity"),
0, 1, 0.5,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "highlight",
"Highlight",
"Material highlight (note, it's exponential)",
_("Highligh_t"),
_("Material highlight "
"(note, it's exponential)"),
0, G_MAXDOUBLE, 27.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_BOOLEAN (procedure, "antialiasing",
"Antialiasing",
"Apply antialiasing",
_("Antialia_sing"),
_("Apply antialiasing"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "depth",
_("_Depth"),
_("Antialiasing quality. Higher is better, "
"but slower"),
1.0, 5.0, 3.0,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "threshold",
_("Thr_eshold"),
_("Stop when pixel differences are smaller than "
"this value"),
0.001, 1000.0, 0.250,
G_PARAM_READWRITE);
PIKA_PROC_ARG_BOOLEAN (procedure, "tiled",
"Tiled",
"Tile source image",
_("_Tile source image"),
_("Tile source image"),
FALSE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_BOOLEAN (procedure, "new-image",
"New image",
"Create a new image",
_("Create _new image"),
_("Create a new image"),
FALSE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_BOOLEAN (procedure, "new-layer",
_("Create ne_w layer"),
_("Create a new layer when applying filter"),
FALSE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_BOOLEAN (procedure, "transparent-background",
"Transparent background",
"Make background transparent",
_("Transparent bac_kground"),
_("Make background transparent"),
FALSE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "radius",
"Radius",
"Sphere/cylinder radius (only used when "
"maptype=1 or 3)",
0, G_MAXDOUBLE, 0.25,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "x-scale",
"X scale",
"Box X size",
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "y-scale",
"Y scale",
"Box Y size",
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "z-scale",
"Z scale",
"Box Z size",
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "cylinder-length",
"Cylinder length",
"Cylinder length",
/* Sphere Options */
PIKA_PROC_ARG_DOUBLE (procedure, "sphere-radius",
_("Radi_us"),
_("Sphere radius"),
0, G_MAXDOUBLE, 0.25,
G_PARAM_READWRITE);
/* Box Options */
PIKA_PROC_ARG_DRAWABLE (procedure, "box-front-drawable",
"Box front drawable",
"Box front face (set these to NULL if not used)",
_("Fro_nt"),
_("Box front face "
"(set this to NULL if not used)"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DRAWABLE (procedure, "box-back-drawable",
"Box back drawable",
"Box back face",
_("B_ack"),
_("Box back face"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DRAWABLE (procedure, "box-top-drawable",
"Box top drawable",
"Box top face",
_("To_p"),
_("Box top face"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DRAWABLE (procedure, "box-bottom-drawable",
"Box bottom drawable",
"Box bottom face",
_("Bo_ttom"),
_("Box bottom face"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DRAWABLE (procedure, "box-left-drawable",
"Box left drawable",
"Box left face",
_("Le_ft"),
_("Box left face"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DRAWABLE (procedure, "box-right-drawable",
"Box right drawable",
"Box right face",
_("Ri_ght"),
_("Box right face"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "x-scale",
_("Scale X"),
_("Box X size"),
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "y-scale",
_("Scale Y"),
_("Box Y size"),
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "z-scale",
_("Scale Z"),
_("Box Z size"),
0, G_MAXDOUBLE, 0.5,
G_PARAM_READWRITE);
/* Cylinder options */
PIKA_PROC_ARG_DRAWABLE (procedure, "cyl-top-drawable",
"Cyl top drawable",
"Cylinder top face (set these to NULL if not used)",
_("_Top"),
_("Cylinder top face "
"(set this to NULL if not used)"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DRAWABLE (procedure, "cyl-bottom-drawable",
"Cyl bottom drawable",
"Cylinder bottom face",
_("_Bottom"),
_("Cylinder bottom face "
"(set this to NULL if not used)"),
TRUE,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "cylinder-radius",
_("Radi_us"),
_("Cylinder radius"),
0, G_MAXDOUBLE, 0.25,
G_PARAM_READWRITE);
PIKA_PROC_ARG_DOUBLE (procedure, "cylinder-length",
_("Cylin_der length"),
_("Cylinder length"),
0, G_MAXDOUBLE, 0.25,
G_PARAM_READWRITE);
}
return procedure;
@ -478,11 +515,10 @@ map_run (PikaProcedure *procedure,
PikaImage *_image,
gint n_drawables,
PikaDrawable **drawables,
const PikaValueArray *args,
PikaProcedureConfig *config,
gpointer run_data)
{
PikaDrawable *drawable;
gint i;
gegl_init (NULL, NULL);
@ -510,97 +546,44 @@ map_run (PikaProcedure *procedure,
switch (run_mode)
{
case PIKA_RUN_INTERACTIVE:
pika_get_data (PLUG_IN_PROC, &mapvals);
check_drawables (drawable);
if (! main_dialog (drawable))
if (! main_dialog (procedure, config, drawable))
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_CANCEL,
NULL);
}
copy_from_config (config);
compute_image ();
pika_set_data (PLUG_IN_PROC, &mapvals, sizeof (MapObjectValues));
break;
case PIKA_RUN_WITH_LAST_VALS:
pika_get_data (PLUG_IN_PROC, &mapvals);
check_drawables (drawable);
if (! image_setup (drawable, FALSE))
if (! image_setup (drawable, FALSE, config))
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
NULL);
}
copy_from_config (config);
compute_image ();
break;
case PIKA_RUN_NONINTERACTIVE:
mapvals.maptype = PIKA_VALUES_GET_INT (args, 0);
mapvals.viewpoint.x = PIKA_VALUES_GET_DOUBLE (args, 1);
mapvals.viewpoint.y = PIKA_VALUES_GET_DOUBLE (args, 2);
mapvals.viewpoint.z = PIKA_VALUES_GET_DOUBLE (args, 3);
mapvals.position.x = PIKA_VALUES_GET_DOUBLE (args, 4);
mapvals.position.y = PIKA_VALUES_GET_DOUBLE (args, 5);
mapvals.position.z = PIKA_VALUES_GET_DOUBLE (args, 6);
mapvals.firstaxis.x = PIKA_VALUES_GET_DOUBLE (args, 7);
mapvals.firstaxis.y = PIKA_VALUES_GET_DOUBLE (args, 8);
mapvals.firstaxis.z = PIKA_VALUES_GET_DOUBLE (args, 9);
mapvals.secondaxis.x = PIKA_VALUES_GET_DOUBLE (args, 10);
mapvals.secondaxis.y = PIKA_VALUES_GET_DOUBLE (args, 11);
mapvals.secondaxis.z = PIKA_VALUES_GET_DOUBLE (args, 12);
mapvals.alpha = PIKA_VALUES_GET_DOUBLE (args, 13);
mapvals.beta = PIKA_VALUES_GET_DOUBLE (args, 14);
mapvals.gamma = PIKA_VALUES_GET_DOUBLE (args, 15);
mapvals.lightsource.type = PIKA_VALUES_GET_INT (args, 16);
PIKA_VALUES_GET_RGB (args, 17, &mapvals.lightsource.color);
mapvals.lightsource.position.x = PIKA_VALUES_GET_DOUBLE (args, 18);
mapvals.lightsource.position.y = PIKA_VALUES_GET_DOUBLE (args, 19);
mapvals.lightsource.position.z = PIKA_VALUES_GET_DOUBLE (args, 20);
mapvals.lightsource.direction.x = PIKA_VALUES_GET_DOUBLE (args, 21);
mapvals.lightsource.direction.y = PIKA_VALUES_GET_DOUBLE (args, 22);
mapvals.lightsource.direction.z = PIKA_VALUES_GET_DOUBLE (args, 23);
mapvals.material.ambient_int = PIKA_VALUES_GET_DOUBLE (args, 24);
mapvals.material.diffuse_int = PIKA_VALUES_GET_DOUBLE (args, 25);
mapvals.material.diffuse_ref = PIKA_VALUES_GET_DOUBLE (args, 26);
mapvals.material.specular_ref = PIKA_VALUES_GET_DOUBLE (args, 27);
mapvals.material.highlight = PIKA_VALUES_GET_DOUBLE (args, 28);
mapvals.antialiasing = PIKA_VALUES_GET_BOOLEAN (args, 29);
mapvals.tiled = PIKA_VALUES_GET_BOOLEAN (args, 30);
mapvals.create_new_image = PIKA_VALUES_GET_BOOLEAN (args, 31);
mapvals.transparent_background = PIKA_VALUES_GET_BOOLEAN (args, 32);
mapvals.radius =
mapvals.cylinder_radius = PIKA_VALUES_GET_DOUBLE (args, 33);
mapvals.scale.x = PIKA_VALUES_GET_DOUBLE (args, 34);
mapvals.scale.y = PIKA_VALUES_GET_DOUBLE (args, 35);
mapvals.scale.z = PIKA_VALUES_GET_DOUBLE (args, 36);
mapvals.cylinder_length = PIKA_VALUES_GET_DOUBLE (args, 37);
for (i = 0; i < 6; i++)
{
mapvals.boxmap_id[i] = PIKA_VALUES_GET_DRAWABLE_ID (args, 38 + i);
}
for (i = 0; i < 2; i++)
{
mapvals.cylindermap_id[i] = PIKA_VALUES_GET_DRAWABLE_ID (args, 44 + i);
}
check_drawables (drawable);
if (! image_setup (drawable, FALSE))
if (! image_setup (drawable, FALSE, config))
{
return pika_procedure_new_return_values (procedure,
PIKA_PDB_SUCCESS,
NULL);
}
copy_from_config (config);
compute_image ();
break;
}

1608
plug-ins/map-object/map-object-ui.c
View File

File diff suppressed because it is too large Load Diff

4
plug-ins/map-object/map-object-ui.h
View File

@ -9,6 +9,8 @@ extern GtkWidget *previewarea;
/* Externally visible functions */
/* ============================ */
gboolean main_dialog (PikaDrawable *drawable);
gboolean main_dialog (PikaProcedure *procedure,
PikaProcedureConfig *config,
PikaDrawable *drawable);
#endif /* __MAPOBJECT_UI_H__ */