613 lines
24 KiB
C
613 lines
24 KiB
C
/* MapObject 1.2.0 -- image filter plug-in for PIKA
|
|
*
|
|
* Copyright (C) 1996-98 Tom Bech
|
|
* Copyright (C) 1996-98 Federico Mena Quintero
|
|
*
|
|
* E-mail: tomb@gimp.org (Tom) or quartic@gimp.org (Federico)
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <gtk/gtk.h>
|
|
|
|
#include <libpika/pika.h>
|
|
#include <libpika/pikaui.h>
|
|
|
|
#include "map-object-ui.h"
|
|
#include "map-object-image.h"
|
|
#include "map-object-apply.h"
|
|
#include "map-object-preview.h"
|
|
#include "map-object-main.h"
|
|
|
|
#include "libpika/stdplugins-intl.h"
|
|
|
|
|
|
MapObjectValues mapvals;
|
|
|
|
|
|
typedef struct _Map Map;
|
|
typedef struct _MapClass MapClass;
|
|
|
|
struct _Map
|
|
{
|
|
PikaPlugIn parent_instance;
|
|
};
|
|
|
|
struct _MapClass
|
|
{
|
|
PikaPlugInClass parent_class;
|
|
};
|
|
|
|
|
|
#define MAP_TYPE (map_get_type ())
|
|
#define MAP (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAP_TYPE, Map))
|
|
|
|
GType map_get_type (void) G_GNUC_CONST;
|
|
|
|
static GList * map_query_procedures (PikaPlugIn *plug_in);
|
|
static PikaProcedure * map_create_procedure (PikaPlugIn *plug_in,
|
|
const gchar *name);
|
|
|
|
static PikaValueArray * map_run (PikaProcedure *procedure,
|
|
PikaRunMode run_mode,
|
|
PikaImage *image,
|
|
gint n_drawables,
|
|
PikaDrawable **drawables,
|
|
const PikaValueArray *args,
|
|
gpointer run_data);
|
|
|
|
static void set_default_settings (void);
|
|
static void check_drawables (PikaDrawable *drawable);
|
|
|
|
|
|
G_DEFINE_TYPE (Map, map, PIKA_TYPE_PLUG_IN)
|
|
|
|
PIKA_MAIN (MAP_TYPE)
|
|
DEFINE_STD_SET_I18N
|
|
|
|
|
|
static void
|
|
map_class_init (MapClass *klass)
|
|
{
|
|
PikaPlugInClass *plug_in_class = PIKA_PLUG_IN_CLASS (klass);
|
|
|
|
plug_in_class->query_procedures = map_query_procedures;
|
|
plug_in_class->create_procedure = map_create_procedure;
|
|
plug_in_class->set_i18n = STD_SET_I18N;
|
|
}
|
|
|
|
static void
|
|
map_init (Map *map)
|
|
{
|
|
}
|
|
|
|
static GList *
|
|
map_query_procedures (PikaPlugIn *plug_in)
|
|
{
|
|
return g_list_append (NULL, g_strdup (PLUG_IN_PROC));
|
|
}
|
|
|
|
static PikaProcedure *
|
|
map_create_procedure (PikaPlugIn *plug_in,
|
|
const gchar *name)
|
|
{
|
|
PikaProcedure *procedure = NULL;
|
|
|
|
if (! strcmp (name, PLUG_IN_PROC))
|
|
{
|
|
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_procedure_set_image_types (procedure, "RGB*");
|
|
pika_procedure_set_sensitivity_mask (procedure,
|
|
PIKA_PROCEDURE_SENSITIVE_DRAWABLE);
|
|
|
|
pika_procedure_set_menu_label (procedure, _("Map _Object..."));
|
|
pika_procedure_add_menu_path (procedure, "<Image>/Filters/Map");
|
|
|
|
pika_procedure_set_documentation (procedure,
|
|
_("Map the image to an object "
|
|
"(plane, sphere, box or cylinder)"),
|
|
"No help yet",
|
|
name);
|
|
pika_procedure_set_attribution (procedure,
|
|
"Tom Bech & Federico Mena Quintero",
|
|
"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_DOUBLE (procedure, "viewpoint-x",
|
|
"Viewpoint 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)",
|
|
-G_MAXDOUBLE, G_MAXDOUBLE, 0.5,
|
|
G_PARAM_READWRITE);
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "viewpoint-z",
|
|
"Viewpoint 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,
|
|
G_PARAM_READWRITE);
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "position-y",
|
|
"Position Y",
|
|
"Object position (x,y,z)",
|
|
-G_MAXDOUBLE, G_MAXDOUBLE, 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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
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_RGB (procedure, "light-color",
|
|
"Light 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)",
|
|
-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)",
|
|
-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)",
|
|
-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)",
|
|
-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)",
|
|
-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)",
|
|
-G_MAXDOUBLE, G_MAXDOUBLE, 1.0,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "ambient-intensity",
|
|
"Ambient intensity",
|
|
"Material ambient intensity",
|
|
0, 1, 0.3,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "diffuse-intensity",
|
|
"Diffuse intensity",
|
|
"Material diffuse intensity",
|
|
0, 1, 1.0,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "diffuse-reflectivity",
|
|
"Diffuse reflectivity",
|
|
"Material diffuse reflectivity",
|
|
0, 1, 0.5,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "specular-reflectivity",
|
|
"Specular reflectivity",
|
|
"Material specular reflectivity",
|
|
0, 1, 0.5,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DOUBLE (procedure, "highlight",
|
|
"Highlight",
|
|
"Material highlight (note, it's exponential)",
|
|
0, G_MAXDOUBLE, 27.0,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_BOOLEAN (procedure, "antialiasing",
|
|
"Antialiasing",
|
|
"Apply antialiasing",
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_BOOLEAN (procedure, "tiled",
|
|
"Tiled",
|
|
"Tile source image",
|
|
FALSE,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_BOOLEAN (procedure, "new-image",
|
|
"New image",
|
|
"Create a new image",
|
|
FALSE,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_BOOLEAN (procedure, "transparent-background",
|
|
"Transparent background",
|
|
"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",
|
|
0, G_MAXDOUBLE, 0.25,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DRAWABLE (procedure, "box-front-drawable",
|
|
"Box front drawable",
|
|
"Box front face (set these to NULL if not used)",
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
PIKA_PROC_ARG_DRAWABLE (procedure, "box-back-drawable",
|
|
"Box back drawable",
|
|
"Box back face",
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
PIKA_PROC_ARG_DRAWABLE (procedure, "box-top-drawable",
|
|
"Box top drawable",
|
|
"Box top face",
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
PIKA_PROC_ARG_DRAWABLE (procedure, "box-bottom-drawable",
|
|
"Box bottom drawable",
|
|
"Box bottom face",
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
PIKA_PROC_ARG_DRAWABLE (procedure, "box-left-drawable",
|
|
"Box left drawable",
|
|
"Box left face",
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
PIKA_PROC_ARG_DRAWABLE (procedure, "box-right-drawable",
|
|
"Box right drawable",
|
|
"Box right face",
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
|
|
PIKA_PROC_ARG_DRAWABLE (procedure, "cyl-top-drawable",
|
|
"Cyl top drawable",
|
|
"Cylinder top face (set these to NULL if not used)",
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
PIKA_PROC_ARG_DRAWABLE (procedure, "cyl-bottom-drawable",
|
|
"Cyl bottom drawable",
|
|
"Cylinder bottom face",
|
|
TRUE,
|
|
G_PARAM_READWRITE);
|
|
}
|
|
|
|
return procedure;
|
|
}
|
|
|
|
static void
|
|
set_default_settings (void)
|
|
{
|
|
gint i;
|
|
|
|
pika_vector3_set (&mapvals.viewpoint, 0.5, 0.5, 2.0);
|
|
pika_vector3_set (&mapvals.firstaxis, 1.0, 0.0, 0.0);
|
|
pika_vector3_set (&mapvals.secondaxis, 0.0, 1.0, 0.0);
|
|
pika_vector3_set (&mapvals.normal, 0.0, 0.0, 1.0);
|
|
pika_vector3_set (&mapvals.position, 0.5, 0.5, 0.0);
|
|
pika_vector3_set (&mapvals.lightsource.position, -0.5, -0.5, 2.0);
|
|
pika_vector3_set (&mapvals.lightsource.direction, -1.0, -1.0, 1.0);
|
|
pika_vector3_set (&mapvals.scale, 0.5, 0.5, 0.5);
|
|
|
|
mapvals.maptype = MAP_PLANE;
|
|
|
|
mapvals.pixelthreshold = 0.25;
|
|
mapvals.alpha = 0.0;
|
|
mapvals.beta = 0.0;
|
|
mapvals.gamma = 0.0;
|
|
mapvals.maxdepth = 3.0;
|
|
mapvals.radius = 0.25;
|
|
mapvals.cylinder_radius = 0.25;
|
|
mapvals.cylinder_length = 1.0;
|
|
|
|
mapvals.zoom = 1.0;
|
|
mapvals.lightsource.type = POINT_LIGHT;
|
|
|
|
mapvals.antialiasing = TRUE;
|
|
mapvals.create_new_image = FALSE;
|
|
mapvals.create_new_layer = FALSE;
|
|
mapvals.transparent_background = FALSE;
|
|
mapvals.tiled = FALSE;
|
|
mapvals.livepreview = FALSE;
|
|
mapvals.showgrid = TRUE;
|
|
|
|
mapvals.lightsource.intensity = 1.0;
|
|
pika_rgba_set (&mapvals.lightsource.color, 1.0, 1.0, 1.0, 1.0);
|
|
|
|
mapvals.material.ambient_int = 0.3;
|
|
mapvals.material.diffuse_int = 1.0;
|
|
mapvals.material.diffuse_ref = 0.5;
|
|
mapvals.material.specular_ref = 0.5;
|
|
mapvals.material.highlight = 27.0;
|
|
|
|
for (i = 0; i < 6; i++)
|
|
mapvals.boxmap_id[i] = -1;
|
|
|
|
for (i = 0; i < 2; i++)
|
|
mapvals.cylindermap_id[i] = -1;
|
|
}
|
|
|
|
static void
|
|
check_drawables (PikaDrawable *drawable)
|
|
{
|
|
PikaDrawable *map;
|
|
gint i;
|
|
|
|
/* Check that boxmap images are valid */
|
|
/* ================================== */
|
|
|
|
for (i = 0; i < 6; i++)
|
|
{
|
|
map = pika_drawable_get_by_id (mapvals.boxmap_id[i]);
|
|
|
|
if (! map || pika_drawable_is_gray (map))
|
|
mapvals.boxmap_id[i] = pika_item_get_id (PIKA_ITEM (drawable));
|
|
}
|
|
|
|
/* Check that cylindermap images are valid */
|
|
/* ======================================= */
|
|
|
|
for (i = 0; i < 2; i++)
|
|
{
|
|
map = pika_drawable_get_by_id (mapvals.cylindermap_id[i]);
|
|
|
|
if (! map || pika_drawable_is_gray (map))
|
|
mapvals.cylindermap_id[i] = pika_item_get_id (PIKA_ITEM (drawable));
|
|
}
|
|
}
|
|
|
|
static PikaValueArray *
|
|
map_run (PikaProcedure *procedure,
|
|
PikaRunMode run_mode,
|
|
PikaImage *_image,
|
|
gint n_drawables,
|
|
PikaDrawable **drawables,
|
|
const PikaValueArray *args,
|
|
gpointer run_data)
|
|
{
|
|
PikaDrawable *drawable;
|
|
gint i;
|
|
|
|
gegl_init (NULL, NULL);
|
|
|
|
image = _image;
|
|
|
|
if (n_drawables != 1)
|
|
{
|
|
GError *error = NULL;
|
|
|
|
g_set_error (&error, PIKA_PLUG_IN_ERROR, 0,
|
|
_("Procedure '%s' only works with one drawable."),
|
|
pika_procedure_get_name (procedure));
|
|
|
|
return pika_procedure_new_return_values (procedure,
|
|
PIKA_PDB_CALLING_ERROR,
|
|
error);
|
|
}
|
|
else
|
|
{
|
|
drawable = drawables[0];
|
|
}
|
|
|
|
set_default_settings ();
|
|
|
|
switch (run_mode)
|
|
{
|
|
case PIKA_RUN_INTERACTIVE:
|
|
pika_get_data (PLUG_IN_PROC, &mapvals);
|
|
check_drawables (drawable);
|
|
|
|
if (! main_dialog (drawable))
|
|
{
|
|
return pika_procedure_new_return_values (procedure,
|
|
PIKA_PDB_CANCEL,
|
|
NULL);
|
|
}
|
|
|
|
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))
|
|
{
|
|
return pika_procedure_new_return_values (procedure,
|
|
PIKA_PDB_SUCCESS,
|
|
NULL);
|
|
}
|
|
|
|
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))
|
|
{
|
|
return pika_procedure_new_return_values (procedure,
|
|
PIKA_PDB_SUCCESS,
|
|
NULL);
|
|
}
|
|
|
|
compute_image ();
|
|
break;
|
|
}
|
|
|
|
if (run_mode != PIKA_RUN_NONINTERACTIVE)
|
|
pika_displays_flush ();
|
|
|
|
return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL);
|
|
}
|
