dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

One more 17C3 commit ... 

2000-12-30  Michael Natterer  <mitch@gimp.org>

	One more 17C3 commit ...

	* plug-ins/libgck/gck/gck.h
	* plug-ins/libgck/gck/gckcolor.c: removed unused stuff.

	* plug-ins/Lighting/lighting_apply.c
	* plug-ins/Lighting/lighting_image.[ch]
	* plug-ins/Lighting/lighting_main.c
	* plug-ins/Lighting/lighting_preview.[ch]
	* plug-ins/Lighting/lighting_shade.c
	* plug-ins/Lighting/lighting_ui.c
	* plug-ins/MapObject/mapobject_apply.c
	* plug-ins/MapObject/mapobject_image.[ch]
	* plug-ins/MapObject/mapobject_main.c
	* plug-ins/MapObject/mapobject_preview.c
	* plug-ins/MapObject/mapobject_shade.[ch]
	* plug-ins/MapObject/mapobject_ui.c: cleanups in preparation for
	removal of LibGCK.
This commit is contained in:
Michael Natterer 2000-12-30 00:23:34 +00:00 committed by Michael Natterer
parent 4a0f7c5866
commit 5e18bba988
19 changed files with 1877 additions and 2390 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
ChangeLog
View File

@ -1,3 +1,24 @@
2000-12-30 Michael Natterer <mitch@gimp.org>
One more 17C3 commit ...
* plug-ins/libgck/gck/gck.h
* plug-ins/libgck/gck/gckcolor.c: removed unused stuff.
* plug-ins/Lighting/lighting_apply.c
* plug-ins/Lighting/lighting_image.[ch]
* plug-ins/Lighting/lighting_main.c
* plug-ins/Lighting/lighting_preview.[ch]
* plug-ins/Lighting/lighting_shade.c
* plug-ins/Lighting/lighting_ui.c
* plug-ins/MapObject/mapobject_apply.c
* plug-ins/MapObject/mapobject_image.[ch]
* plug-ins/MapObject/mapobject_main.c
* plug-ins/MapObject/mapobject_preview.c
* plug-ins/MapObject/mapobject_shade.[ch]
* plug-ins/MapObject/mapobject_ui.c: cleanups in preparation for
removal of LibGCK.
2000-12-30 Michael Natterer <mitch@gimp.org>
* app/gimage.[ch]: removed all the

135
plug-ins/Lighting/lighting_apply.c
View File

@ -2,9 +2,9 @@
/* Apply mapping and shading on the whole input image */
/******************************************************/
#include <sys/types.h>
#include "config.h"
#include <gtk/gtk.h>
#include <sys/types.h>
#include <libgimp/gimp.h>
@ -50,119 +50,136 @@ show_progress (gint min,
void
compute_image (void)
{
gint xcount,ycount;
GckRGB color;
glong progress_counter=0;
GimpVector3 p;
gint32 new_image_id=-1,new_layer_id=-1,index;
guchar *row = NULL, obpp;
gint xcount, ycount;
GckRGB color;
glong progress_counter = 0;
GimpVector3 p;
gint32 new_image_id = -1;
gint32 new_layer_id = -1;
gint32 index;
guchar *row = NULL;
guchar obpp;
gint has_alpha;
init_compute();
init_compute ();
if (mapvals.create_new_image==TRUE || (mapvals.transparent_background==TRUE
&& !gimp_drawable_has_alpha(input_drawable->id)))
if (mapvals.create_new_image == TRUE ||
(mapvals.transparent_background == TRUE &&
! gimp_drawable_has_alpha (input_drawable->id)))
{
/* Create a new image */
/* ================== */
new_image_id=gimp_image_new(width,height,GIMP_RGB);
new_image_id = gimp_image_new (width, height, GIMP_RGB);
if (mapvals.transparent_background==TRUE)
if (mapvals.transparent_background == TRUE)
{
/* Add a layer with an alpha channel */
/* ================================= */
new_layer_id=gimp_layer_new(new_image_id,"Background",
width,height,GIMP_RGBA_IMAGE,100.0,GIMP_NORMAL_MODE);
new_layer_id = gimp_layer_new (new_image_id, "Background",
width, height,
GIMP_RGBA_IMAGE,
100.0,
GIMP_NORMAL_MODE);
}
else
{
/* Create a "normal" layer */
/* ======================= */
new_layer_id=gimp_layer_new(new_image_id,"Background",
width,height,GIMP_RGB_IMAGE,100.0,GIMP_NORMAL_MODE);
new_layer_id = gimp_layer_new (new_image_id, "Background",
width, height,
GIMP_RGB_IMAGE,
100.0,
GIMP_NORMAL_MODE);
}
gimp_image_add_layer(new_image_id,new_layer_id,0);
output_drawable=gimp_drawable_get(new_layer_id);
gimp_image_add_layer (new_image_id, new_layer_id, 0);
output_drawable = gimp_drawable_get (new_layer_id);
}
if (mapvals.bump_mapped==TRUE && mapvals.bumpmap_id!=-1)
if (mapvals.bump_mapped == TRUE && mapvals.bumpmap_id != -1)
{
gimp_pixel_rgn_init (&bump_region, gimp_drawable_get(mapvals.bumpmap_id),
0, 0, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&bump_region, gimp_drawable_get (mapvals.bumpmap_id),
0, 0, width, height, FALSE, FALSE);
}
precompute_init(width,height);
if (!mapvals.env_mapped || mapvals.envmap_id==-1)
ray_func = get_ray_color;
precompute_init (width, height);
if (!mapvals.env_mapped || mapvals.envmap_id == -1)
{
ray_func = get_ray_color;
}
else
{
env_width = gimp_drawable_width (mapvals.envmap_id);
env_height = gimp_drawable_height (mapvals.envmap_id);
gimp_pixel_rgn_init (&env_region, gimp_drawable_get(mapvals.envmap_id),
0, 0, env_width, env_height, FALSE, FALSE);
gimp_pixel_rgn_init (&env_region, gimp_drawable_get (mapvals.envmap_id),
0, 0, env_width, env_height, FALSE, FALSE);
ray_func = get_ray_color_ref;
}
gimp_pixel_rgn_init (&dest_region, output_drawable, 0,0, width,height, TRUE,TRUE);
gimp_pixel_rgn_init (&dest_region, output_drawable,
0, 0, width, height, TRUE, TRUE);
obpp=gimp_drawable_bpp(output_drawable->id);
has_alpha=gimp_drawable_has_alpha(output_drawable->id);
obpp = gimp_drawable_bpp (output_drawable->id);
has_alpha = gimp_drawable_has_alpha (output_drawable->id);
row = (guchar *)g_malloc(sizeof(guchar)*(size_t)(obpp)*(size_t)(width));
row = g_new (guchar, obpp * width);
gimp_progress_init("Lighting Effects");
gimp_progress_init ("Lighting Effects");
/* if (mapvals.antialiasing==FALSE)
{ */
for (ycount=0;ycount<height;ycount++)
{
if (mapvals.bump_mapped==TRUE && mapvals.bumpmap_id!=-1)
precompute_normals(0,width,ycount);
index=0;
for (xcount=0;xcount<width;xcount++)
{
p=int_to_pos(xcount,ycount);
color=(*ray_func)(&p);
for (ycount = 0; ycount < height; ycount++)
{
if (mapvals.bump_mapped == TRUE && mapvals.bumpmap_id != -1)
precompute_normals (0, width, ycount);
row[index++]=(guchar)(color.r*255.0);
row[index++]=(guchar)(color.g*255.0);
row[index++]=(guchar)(color.b*255.0);
index = 0;
if (has_alpha)
row[index++]=(guchar)(color.a*255.0);
for (xcount = 0; xcount < width; xcount++)
{
p = int_to_pos (xcount, ycount);
color = (* ray_func) (&p);
if ((progress_counter++ % width)==0)
gimp_progress_update((gdouble)progress_counter/(gdouble)maxcounter);
}
row[index++] = (guchar) (color.r * 255.0);
row[index++] = (guchar) (color.g * 255.0);
row[index++] = (guchar) (color.b * 255.0);
if (has_alpha)
row[index++] = (guchar) (color.a * 255.0);
if ((progress_counter++ % width) == 0)
gimp_progress_update ((gdouble) progress_counter /
(gdouble) maxcounter);
}
gimp_pixel_rgn_set_row (&dest_region, row, 0, ycount, width);
}
gimp_pixel_rgn_set_row(&dest_region,row,0,ycount,width);
}
/* }
else
gck_adaptive_supersample_area(0,0,width-1,height-1,(gint)mapvals.max_depth,
mapvals.pixel_treshold,render,poke,show_progress); */
if (row!=NULL)
g_free(row);
g_free (row);
/* Update image */
/* ============ */
gimp_drawable_flush(output_drawable);
gimp_drawable_merge_shadow(output_drawable->id, TRUE);
gimp_drawable_update(output_drawable->id, 0,0, width,height);
gimp_drawable_flush (output_drawable);
gimp_drawable_merge_shadow (output_drawable->id, TRUE);
gimp_drawable_update (output_drawable->id, 0, 0, width, height);
if (new_image_id!=-1)
{
gimp_display_new(new_image_id);
gimp_displays_flush();
gimp_drawable_detach(output_drawable);
gimp_display_new (new_image_id);
gimp_displays_flush ();
gimp_drawable_detach (output_drawable);
}
}

28
plug-ins/Lighting/lighting_image.c
View File

@ -2,7 +2,7 @@
/* GIMP image manipulation routines. */
/*************************************/
#include <gtk/gtk.h>
#include "config.h"
#include <libgimp/gimp.h>
@ -70,7 +70,9 @@ peek (gint x,
color.a = 1.0;
}
else
color.a = 1.0;
{
color.a = 1.0;
}
return color;
}
@ -189,20 +191,20 @@ void
pos_to_int (gdouble x,
gdouble y,
gint *scr_x,
gint *scr_y)
gint *scr_y)
{
if (width >= height)
{
y -= 0.5 * (1.0 - (gdouble) height / (gdouble) width);
*scr_x = (gint) ((x * (gdouble) width) + 0.5);
*scr_y = (gint) ((y * (gdouble) width) + 0.5);
*scr_x = RINT ((x * (gdouble) width));
*scr_y = RINT ((y * (gdouble) width));
}
else
{
x -= 0.5 * (1.0 - (gdouble) width / (gdouble) height);
*scr_x = (gint) ((x * (gdouble) height) + 0.5);
*scr_y = (gint) ((y *(gdouble) height) + 0.5);
*scr_x = RINT ((x * (gdouble) height));
*scr_y = RINT ((y *(gdouble) height));
}
}
@ -241,8 +243,8 @@ get_image_color (gdouble u,
gint x1, y1, x2, y2;
GckRGB p[4];
x1 = (gint) (u + 0.5);
y1 = (gint) (v + 0.5);
x1 = RINT (u);
y1 = RINT (v);
if (check_bounds (x1, y1) == FALSE)
{
@ -277,8 +279,8 @@ get_map_value (GimpPixelRgn *region,
gint x1, y1, x2, y2;
gdouble p[4];
x1 = (gint) (u + 0.5);
y1 = (gint) (v + 0.5);
x1 = RINT (u);
y1 = RINT (v);
x2 = (x1 + 1);
y2 = (y1 + 1);
@ -340,13 +342,13 @@ image_setup (GimpDrawable *drawable,
/* Get some useful info on the input drawable */
/* ========================================== */
input_drawable = drawable;
input_drawable = drawable;
output_drawable = drawable;
gimp_drawable_mask_bounds (drawable->id,
&border_x1, &border_y1, &border_x2, &border_y2);
width = input_drawable->width;
width = input_drawable->width;
height = input_drawable->height;
gimp_pixel_rgn_init (&source_region, input_drawable,

60
plug-ins/Lighting/lighting_image.h
View File

@ -22,37 +22,37 @@ extern gint border_x1,border_y1,border_x2,border_y2;
extern guchar sinemap[256], spheremap[256], logmap[256];
guchar peek_map (GimpPixelRgn *region,
gint x,
gint y);
GckRGB peek (gint x,
gint y);
GckRGB peek_env_map (gint x,
gint y);
void poke (gint x,
gint y,
GckRGB *color);
gint check_bounds (gint x,
gint y);
GimpVector3 int_to_pos (gint x,
gint y);
GimpVector3 int_to_posf (gdouble x,
gdouble y);
void pos_to_int (gdouble x,
gdouble y,
gint *scr_x,
gint *scr_y);
void pos_to_float (gdouble x,
gdouble y,
gdouble *xf,
gdouble *yf);
GckRGB get_image_color (gdouble u,
gdouble v,
gint *inside);
gint x,
gint y);
GckRGB peek (gint x,
gint y);
GckRGB peek_env_map (gint x,
gint y);
void poke (gint x,
gint y,
GckRGB *color);
gint check_bounds (gint x,
gint y);
GimpVector3 int_to_pos (gint x,
gint y);
GimpVector3 int_to_posf (gdouble x,
gdouble y);
void pos_to_int (gdouble x,
gdouble y,
gint *scr_x,
gint *scr_y);
void pos_to_float (gdouble x,
gdouble y,
gdouble *xf,
gdouble *yf);
GckRGB get_image_color (gdouble u,
gdouble v,
gint *inside);
gdouble get_map_value (GimpPixelRgn *region,
gdouble u,
gdouble v,
gint *inside);
gdouble u,
gdouble v,
gint *inside);
gint image_setup (GimpDrawable *drawable,
gint interactive);
gint interactive);
#endif /* __LIGHTING_IMAGE_H__ */

43
plug-ins/Lighting/lighting_main.c
View File

@ -20,7 +20,7 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <gtk/gtk.h>
#include "config.h"
#include <libgimp/gimp.h>
@ -33,7 +33,6 @@
#include "lighting_shade.h"
#include "lighting_ui.h"
#include "config.h"
#include "libgimp/stdplugins-intl.h"
LightingValues mapvals;
@ -106,9 +105,9 @@ check_drawables (void)
{
if (!gimp_drawable_is_gray (mapvals.bumpmap_id) ||
(gimp_drawable_width (mapvals.drawable_id) !=
gimp_drawable_width(mapvals.bumpmap_id)) ||
gimp_drawable_width (mapvals.bumpmap_id)) ||
(gimp_drawable_height (mapvals.drawable_id) !=
gimp_drawable_height(mapvals.bumpmap_id)))
gimp_drawable_height (mapvals.bumpmap_id)))
{
mapvals.bump_mapped = FALSE;
mapvals.bumpmap_id = -1;
@ -158,8 +157,6 @@ query (void)
};
static gint nargs = sizeof (args) / sizeof (args[0]);
INIT_I18N();
gimp_install_procedure ("plug_in_lighting",
"Apply various lighting effects to an image",
"No help yet",
@ -174,26 +171,26 @@ query (void)
}
static void
run (gchar *name,
gint nparams,
run (gchar *name,
gint nparams,
GimpParam *param,
gint *nreturn_vals,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
GimpRunModeType run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
static GimpParam values[1];
GimpDrawable *drawable;
GimpRunModeType run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32;
if (run_mode == GIMP_RUN_INTERACTIVE)
{
INIT_I18N_UI();
INIT_I18N_UI ();
}
else
{
INIT_I18N();
INIT_I18N ();
}
*nreturn_vals = 1;
@ -214,7 +211,7 @@ run (gchar *name,
/* Get the specified drawable */
/* ========================== */
drawable = gimp_drawable_get (param[2].data.d_drawable);
mapvals.drawable_id = drawable->id;
@ -259,10 +256,10 @@ run (gchar *name,
{
mapvals.bumpmap_id = param[3].data.d_drawable;
mapvals.envmap_id = param[4].data.d_drawable;
mapvals.bump_mapped = (gint)param[5].data.d_int32;
mapvals.env_mapped = (gint)param[6].data.d_int32;
mapvals.bumpmaptype = (gint)param[7].data.d_int32;
mapvals.lightsource.type = (LightType)param[8].data.d_int32;
mapvals.bump_mapped = (gint) param[5].data.d_int32;
mapvals.env_mapped = (gint) param[6].data.d_int32;
mapvals.bumpmaptype = (gint) param[7].data.d_int32;
mapvals.lightsource.type = (LightType) param[8].data.d_int32;
mapvals.lightsource.color.r = param[9].data.d_color.red;
mapvals.lightsource.color.g = param[9].data.d_color.green;
mapvals.lightsource.color.b = param[9].data.d_color.blue;
@ -277,9 +274,9 @@ run (gchar *name,
mapvals.material.diffuse_ref = param[18].data.d_float;
mapvals.material.specular_ref = param[19].data.d_float;
mapvals.material.highlight = param[20].data.d_float;
mapvals.antialiasing = (gint)param[21].data.d_int32;
mapvals.create_new_image = (gint)param[22].data.d_int32;
mapvals.transparent_background = (gint)param[23].data.d_int32;
mapvals.antialiasing = (gint) param[21].data.d_int32;
mapvals.create_new_image = (gint) param[22].data.d_int32;
mapvals.transparent_background = (gint) param[23].data.d_int32;
check_drawables ();
image_setup (drawable, FALSE);

177
plug-ins/Lighting/lighting_preview.c
View File

@ -2,7 +2,7 @@
/* Compute a preview image and preview wireframe */
/*************************************************/
#include <gtk/gtk.h>
#include "config.h"
#include <libgimp/gimp.h>
@ -16,6 +16,7 @@
#include "lighting_preview.h"
gint lightx, lighty;
BackBuffer backbuf= { 0, 0, 0, 0, NULL };
@ -35,24 +36,25 @@ compute_preview (gint startx,
gint w,
gint h)
{
gint xcnt,ycnt,f1,f2;
gdouble imagex,imagey;
gint32 index=0;
GckRGB color,darkcheck,lightcheck,temp;
GimpVector3 pos;
get_ray_func ray_func;
gint xcnt, ycnt, f1, f2;
gdouble imagex, imagey;
gint32 index = 0;
GckRGB color, darkcheck, lightcheck, temp;
GimpVector3 pos;
get_ray_func ray_func;
if (xpostab_size != w)
{
if (xpostab)
{
g_free(xpostab);
g_free (xpostab);
xpostab = NULL;
}
}
if (!xpostab)
{
xpostab = (gdouble *)g_malloc(sizeof(gdouble)*w);
xpostab = g_new (gdouble, w);
xpostab_size = w;
}
@ -60,46 +62,47 @@ compute_preview (gint startx,
{
if (ypostab)
{
g_free(ypostab);
g_free (ypostab);
ypostab = NULL;
}
}
if (!ypostab)
{
ypostab = (gdouble *)g_malloc(sizeof(gdouble)*h);
ypostab = g_new (gdouble, h);
ypostab_size = h;
}
for (xcnt=0;xcnt<w;xcnt++)
xpostab[xcnt]=(gdouble)width*((gdouble)xcnt/(gdouble)w);
for (ycnt=0;ycnt<h;ycnt++)
ypostab[ycnt]=(gdouble)height*((gdouble)ycnt/(gdouble)h);
for (xcnt = 0; xcnt < w; xcnt++)
xpostab[xcnt] = (gdouble) width * ((gdouble) xcnt / (gdouble) w);
for (ycnt = 0; ycnt < h; ycnt++)
ypostab[ycnt] = (gdouble) height * ((gdouble) ycnt / (gdouble) h);
init_compute();
precompute_init(width,height);
gck_rgb_set(&lightcheck,0.75,0.75,0.75);
gck_rgb_set(&darkcheck, 0.50,0.50,0.50);
gck_rgb_set(&color,0.3,0.7,1.0);
if (mapvals.bump_mapped==TRUE && mapvals.bumpmap_id!=-1)
init_compute ();
precompute_init (width, height);
gck_rgb_set (&lightcheck, 0.75, 0.75, 0.75);
gck_rgb_set (&darkcheck, 0.50, 0.50, 0.50);
gck_rgb_set (&color, 0.3, 0.7, 1.0);
if (mapvals.bump_mapped == TRUE && mapvals.bumpmap_id != -1)
{
gimp_pixel_rgn_init (&bump_region, gimp_drawable_get(mapvals.bumpmap_id),
gimp_pixel_rgn_init (&bump_region, gimp_drawable_get (mapvals.bumpmap_id),
0, 0, width, height, FALSE, FALSE);
}
imagey=0;
imagey = 0;
if (mapvals.previewquality)
ray_func = get_ray_color;
else
ray_func = get_ray_color_no_bilinear;
if (mapvals.env_mapped==TRUE && mapvals.envmap_id!=-1)
if (mapvals.env_mapped == TRUE && mapvals.envmap_id != -1)
{
env_width = gimp_drawable_width(mapvals.envmap_id);
env_height = gimp_drawable_height(mapvals.envmap_id);
gimp_pixel_rgn_init (&env_region, gimp_drawable_get(mapvals.envmap_id),
env_width = gimp_drawable_width (mapvals.envmap_id);
env_height = gimp_drawable_height (mapvals.envmap_id);
gimp_pixel_rgn_init (&env_region, gimp_drawable_get (mapvals.envmap_id),
0, 0, env_width, env_height, FALSE, FALSE);
if (mapvals.previewquality)
@ -108,71 +111,81 @@ compute_preview (gint startx,
ray_func = get_ray_color_no_bilinear_ref;
}
for (ycnt=0;ycnt<PREVIEW_HEIGHT;ycnt++)
for (ycnt = 0; ycnt < PREVIEW_HEIGHT; ycnt++)
{
for (xcnt=0;xcnt<PREVIEW_WIDTH;xcnt++)
for (xcnt = 0; xcnt < PREVIEW_WIDTH; xcnt++)
{
if ((ycnt>=starty && ycnt<(starty+h)) &&
(xcnt>=startx && xcnt<(startx+w)))
if ((ycnt >= starty && ycnt < (starty + h)) &&
(xcnt >= startx && xcnt < (startx + w)))
{
imagex=xpostab[xcnt-startx];
imagey=ypostab[ycnt-starty];
pos=int_to_posf(imagex,imagey);
if (mapvals.bump_mapped==TRUE && mapvals.bumpmap_id!=-1 && xcnt==startx)
imagex = xpostab[xcnt - startx];
imagey = ypostab[ycnt - starty];
pos = int_to_posf (imagex, imagey);
if (mapvals.bump_mapped == TRUE &&
mapvals.bumpmap_id != -1 &&
xcnt == startx)
{
pos_to_float(pos.x,pos.y,&imagex,&imagey);
precompute_normals(0,width,(gint)(imagey+0.5));
pos_to_float (pos.x, pos.y, &imagex, &imagey);
precompute_normals (0, width, RINT (imagey));
}
color=(*ray_func)(&pos);
if (color.a<1.0)
color = (* ray_func) (&pos);
if (color.a < 1.0)
{
f1=((xcnt % 32)<16);
f2=((ycnt % 32)<16);
f1=f1^f2;
f1 = ((xcnt % 32) < 16);
f2 = ((ycnt % 32) < 16);
f1 = f1 ^ f2;
if (f1)
{
if (color.a==0.0)
color=lightcheck;
if (color.a == 0.0)
{
color=lightcheck;
}
else
{
gck_rgb_mul(&color,color.a);
temp=lightcheck;
gck_rgb_mul(&temp,1.0-color.a);
gck_rgb_add(&color,&temp);
gck_rgb_mul (&color, color.a);
temp = lightcheck;
gck_rgb_mul (&temp, 1.0 - color.a);
gck_rgb_add (&color, &temp);
}
}
else
{
if (color.a==0.0)
color=darkcheck;
if (color.a == 0.0)
{
color = darkcheck;
}
else
{
gck_rgb_mul(&color,color.a);
temp=darkcheck;
gck_rgb_mul(&temp,1.0-color.a);
gck_rgb_add(&color,&temp);
gck_rgb_mul (&color, color.a);
temp = darkcheck;
gck_rgb_mul (&temp, 1.0 - color.a);
gck_rgb_add (&color, &temp);
}
}
}
preview_rgb_data[index++]=(guchar)(255.0*color.r);
preview_rgb_data[index++]=(guchar)(255.0*color.g);
preview_rgb_data[index++]=(guchar)(255.0*color.b);
preview_rgb_data[index++] = (guchar) (255.0 * color.r);
preview_rgb_data[index++] = (guchar) (255.0 * color.g);
preview_rgb_data[index++] = (guchar) (255.0 * color.b);
imagex++;
}
else
{
preview_rgb_data[index++]=200;
preview_rgb_data[index++]=200;
preview_rgb_data[index++]=200;
preview_rgb_data[index++] = 200;
preview_rgb_data[index++] = 200;
preview_rgb_data[index++] = 200;
}
}
}
gck_rgb_to_gdkimage(visinfo, preview_rgb_data, image, PREVIEW_WIDTH, PREVIEW_HEIGHT);
gck_rgb_to_gdkimage (visinfo,
preview_rgb_data,
image,
PREVIEW_WIDTH, PREVIEW_HEIGHT);
}
/*
@ -409,27 +422,27 @@ compute_preview_rectangle (gint *xp,
{
gdouble x, y, w, h;
if (width>=height)
if (width >= height)
{
w=(PREVIEW_WIDTH-50.0);
h=(gdouble)height*(w/(gdouble)width);
x=(PREVIEW_WIDTH-w)/2.0;
y=(PREVIEW_HEIGHT-h)/2.0;
w = (PREVIEW_WIDTH - 50.0);
h = (gdouble) height * (w / (gdouble) width);
x = (PREVIEW_WIDTH - w) / 2.0;
y = (PREVIEW_HEIGHT - h) / 2.0;
}
else
{
h=(PREVIEW_HEIGHT-50.0);
w=(gdouble)width*(h/(gdouble)height);
x=(PREVIEW_WIDTH-w)/2.0;
y=(PREVIEW_HEIGHT-h)/2.0;
h = (PREVIEW_HEIGHT - 50.0);
w = (gdouble) width * (h / (gdouble) height);
x = (PREVIEW_WIDTH - w) / 2.0;
y = (PREVIEW_HEIGHT - h) / 2.0;
}
*xp=(gint)(x+0.5);
*yp=(gint)(y+0.5);
*wid=(gint)(w+0.5);
*heig=(gint)(h+0.5);
*xp = RINT (x);
*yp = RINT (y);
*wid = RINT (w);
*heig = RINT (h);
}
/******************************************************************/
@ -455,14 +468,14 @@ draw_preview_image (gint recompute)
newcursor = gdk_cursor_new (GDK_WATCH);
gdk_window_set_cursor (previewarea->window, newcursor);
gdk_cursor_destroy (newcursor);
gdk_flush();
gdk_flush ();
compute_preview (startx, starty, pw, ph);
newcursor = gdk_cursor_new (GDK_HAND2);
gdk_window_set_cursor (previewarea->window, newcursor);
gdk_cursor_destroy (newcursor);
gdk_flush();
gdk_flush ();
clear_light_marker ();
}

10
plug-ins/Lighting/lighting_preview.h
View File

@ -18,20 +18,20 @@
#ifndef __LIGHTING_PREVIEW_H__
#define __LIGHTING_PREVIEW_H__
#define PREVIEW_WIDTH 200
#define PREVIEW_WIDTH 200
#define PREVIEW_HEIGHT 200
typedef struct
{
gint x,y,w,h;
gint x, y, w, h;
GdkImage *image;
} BackBuffer;
/* Externally visible variables */
extern gint lightx,lighty;
extern BackBuffer backbuf;
extern gdouble *xpostab,*ypostab;
extern gint lightx, lighty;
extern BackBuffer backbuf;
extern gdouble *xpostab, *ypostab;
/* Externally visible functions */

680
plug-ins/Lighting/lighting_shade.c
View File

@ -2,7 +2,7 @@
/* Shading stuff */
/*****************/
#include <sys/types.h>
#include "config.h"
#include <libgimp/gimp.h>
@ -14,9 +14,9 @@
static GimpVector3 *triangle_normals[2] = { NULL, NULL };
static GimpVector3 *vertex_normals[3] = { NULL, NULL, NULL };
static gdouble *heights[3] = { NULL, NULL, NULL };
static gdouble xstep, ystep;
static guchar *bumprow = NULL;
static gdouble *heights[3] = { NULL, NULL, NULL };
static gdouble xstep, ystep;
static guchar *bumprow = NULL;
static gint pre_w = -1;
static gint pre_h = -1;
@ -34,65 +34,66 @@ phong_shade (GimpVector3 *position,
GckRGB *spec_col,
LightType light_type)
{
GckRGB ambient_color,diffuse_color,specular_color;
gdouble nl,rv,dist;
GimpVector3 l,nn,v,n;
GckRGB ambient_color, diffuse_color, specular_color;
gdouble nl, rv, dist;
GimpVector3 l, nn, v, n;
/* Compute ambient intensity */
/* ========================= */
n=*normal;
ambient_color=*diff_col;
gck_rgb_mul(&ambient_color,mapvals.material.ambient_int);
n = *normal;
ambient_color = *diff_col;
gck_rgb_mul (&ambient_color, mapvals.material.ambient_int);
/* Compute (N*L) term of Phong's equation */
/* ====================================== */
if (light_type==POINT_LIGHT)
gimp_vector3_sub(&l,lightposition,position);
if (light_type == POINT_LIGHT)
gimp_vector3_sub (&l, lightposition, position);
else
l=*lightposition;
dist=gimp_vector3_length(&l);
if (dist!=0.0)
gimp_vector3_mul(&l,1.0/dist);
l = *lightposition;
nl=2.0*gimp_vector3_inner_product(&n,&l);
dist = gimp_vector3_length (&l);
if (nl>=0.0)
if (dist != 0.0)
gimp_vector3_mul (&l, 1.0 / dist);
nl = 2.0 * gimp_vector3_inner_product (&n, &l);
if (nl >= 0.0)
{
/* Compute (R*V)^alpha term of Phong's equation */
/* ============================================ */
gimp_vector3_sub(&v,viewpoint,position);
gimp_vector3_normalize(&v);
gimp_vector3_sub (&v, viewpoint, position);
gimp_vector3_normalize (&v);
gimp_vector3_mul(&n,nl);
gimp_vector3_sub(&nn,&n,&l);
rv=gimp_vector3_inner_product(&nn,&v);
rv=pow(rv,mapvals.material.highlight);
gimp_vector3_mul (&n, nl);
gimp_vector3_sub (&nn, &n, &l);
rv = gimp_vector3_inner_product (&nn, &v);
rv = pow (rv, mapvals.material.highlight);
/* Compute diffuse and specular intensity contribution */
/* =================================================== */
diffuse_color=*diff_col;
gck_rgb_mul(&diffuse_color,mapvals.material.diffuse_ref);
gck_rgb_mul(&diffuse_color,nl);
diffuse_color = *diff_col;
gck_rgb_mul (&diffuse_color, mapvals.material.diffuse_ref);
gck_rgb_mul (&diffuse_color, nl);
specular_color=*spec_col;
gck_rgb_mul(&specular_color,mapvals.material.specular_ref);
gck_rgb_mul(&specular_color,rv);
specular_color = *spec_col;
gck_rgb_mul (&specular_color, mapvals.material.specular_ref);
gck_rgb_mul (&specular_color, rv);
gck_rgb_add(&diffuse_color,&specular_color);
gck_rgb_mul(&diffuse_color,mapvals.material.diffuse_int);
gck_rgb_clamp(&diffuse_color);
gck_rgb_add (&diffuse_color, &specular_color);
gck_rgb_mul (&diffuse_color, mapvals.material.diffuse_int);
gck_rgb_clamp (&diffuse_color);
gck_rgb_add(&ambient_color,&diffuse_color);
gck_rgb_add (&ambient_color, &diffuse_color);
}
gck_rgb_clamp(&ambient_color);
return(ambient_color);
gck_rgb_clamp (&ambient_color);
return ambient_color;
}
/*
@ -186,52 +187,52 @@ precompute_init (gint w,
{
gint n;
xstep=1.0/(gdouble)width;
ystep=1.0/(gdouble)height;
xstep = 1.0 / (gdouble) width;
ystep = 1.0 / (gdouble) height;
pre_w=w;
pre_h=h;
for (n=0;n<3;n++)
pre_w = w;
pre_h = h;
for (n = 0; n < 3; n++)
{
if (vertex_normals[n]!=NULL)
g_free(vertex_normals[n]);
if (heights[n]!=NULL)
g_free(heights[n]);
heights[n]=(gdouble *)g_malloc(sizeof(gdouble)*(size_t)w);
vertex_normals[n]=(GimpVector3 *)g_malloc(sizeof(GimpVector3)*(size_t)w);
if (vertex_normals[n] != NULL)
g_free (vertex_normals[n]);
if (heights[n] != NULL)
g_free (heights[n]);
heights[n] = g_new (gdouble, w);
vertex_normals[n] = g_new (GimpVector3, w);
}
for (n=0;n<2;n++)
if (triangle_normals[n]!=NULL)
g_free(triangle_normals[n]);
for (n = 0; n < 2; n++)
if (triangle_normals[n] != NULL)
g_free (triangle_normals[n]);
if (bumprow!=NULL)
if (bumprow != NULL)
{
g_free(bumprow);
bumprow=NULL;
g_free (bumprow);
bumprow = NULL;
}
bumprow=(guchar *)g_malloc(sizeof(guchar)*(size_t)w);
bumprow = g_new (guchar, w);
triangle_normals[0]=(GimpVector3 *)g_malloc(sizeof(GimpVector3)*(size_t)((w<<1)+2));
triangle_normals[1]=(GimpVector3 *)g_malloc(sizeof(GimpVector3)*(size_t)((w<<1)+2));
for (n=0;n<(w<<1)+1;n++)
triangle_normals[0] = g_new (GimpVector3, (w << 1) + 2);
triangle_normals[1] = g_new (GimpVector3, (w << 1) + 2);
for (n = 0; n < (w << 1) + 1; n++)
{
gimp_vector3_set(&triangle_normals[0][n],0.0,0.0,1.0);
gimp_vector3_set(&triangle_normals[1][n],0.0,0.0,1.0);
gimp_vector3_set (&triangle_normals[0][n], 0.0, 0.0, 1.0);
gimp_vector3_set (&triangle_normals[1][n], 0.0, 0.0, 1.0);
}
for (n=0;n<w;n++)
for (n = 0; n < w; n++)
{
gimp_vector3_set(&vertex_normals[0][n],0.0,0.0,1.0);
gimp_vector3_set(&vertex_normals[1][n],0.0,0.0,1.0);
gimp_vector3_set(&vertex_normals[2][n],0.0,0.0,1.0);
heights[0][n]=0.0;
heights[1][n]=0.0;
heights[2][n]=0.0;
gimp_vector3_set (&vertex_normals[0][n], 0.0, 0.0, 1.0);
gimp_vector3_set (&vertex_normals[1][n], 0.0, 0.0, 1.0);
gimp_vector3_set (&vertex_normals[2][n], 0.0, 0.0, 1.0);
heights[0][n] = 0.0;
heights[1][n] = 0.0;
heights[2][n] = 0.0;
}
}
@ -244,122 +245,133 @@ precompute_normals (gint x1,
gint x2,
gint y)
{
GimpVector3 *tmpv,p1,p2,p3,normal;
gdouble *tmpd;
gint n,i,nv;
guchar *map=NULL;
GimpVector3 *tmpv, p1, p2, p3, normal;
gdouble *tmpd;
gint n, i, nv;
guchar *map = NULL;
/* First, compute the heights */
/* ========================== */
tmpv=triangle_normals[0];
triangle_normals[0]=triangle_normals[1];
triangle_normals[1]=tmpv;
tmpv = triangle_normals[0];
triangle_normals[0] = triangle_normals[1];
triangle_normals[1] = tmpv;
tmpv=vertex_normals[0];
vertex_normals[0]=vertex_normals[1];
vertex_normals[1]=vertex_normals[2];
vertex_normals[2]=tmpv;
tmpd=heights[0];
heights[0]=heights[1];
heights[1]=heights[2];
heights[2]=tmpd;
tmpv = vertex_normals[0];
vertex_normals[0] = vertex_normals[1];
vertex_normals[1] = vertex_normals[2];
vertex_normals[2] = tmpv;
tmpd = heights[0];
heights[0] = heights[1];
heights[1] = heights[2];
heights[2] = tmpd;
/* printf("Get row (%d,%d,%d) to %p\n",x1,y,x2-x1,bumprow); */
gimp_pixel_rgn_get_row(&bump_region,bumprow,x1,y,x2-x1);
gimp_pixel_rgn_get_row (&bump_region, bumprow, x1, y, x2 - x1);
if (mapvals.bumpmaptype>0)
if (mapvals.bumpmaptype > 0)
{
switch (mapvals.bumpmaptype)
{
case 1:
map=logmap;
map = logmap;
break;
case 2:
map=sinemap;
map = sinemap;
break;
default:
map=spheremap;
map = spheremap;
break;
}
for (n=0;n<(x2-x1);n++)
heights[2][n]=(gdouble)mapvals.bumpmax*(gdouble)map[bumprow[n]]/255.0;
for (n = 0; n < (x2 - x1); n++)
heights[2][n] =
(gdouble) mapvals.bumpmax * (gdouble) map[bumprow[n]] / 255.0;
}
else
{
for (n = 0; n < (x2 - x1); n++)
heights[2][n] =
(gdouble) mapvals.bumpmax * (gdouble) bumprow[n] / 255.0;
}
else for (n=0;n<(x2-x1);n++)
heights[2][n]=(gdouble)mapvals.bumpmax*(gdouble)bumprow[n]/255.0;
/* Compute triangle normals */
/* ======================== */
i=0;
for (n=0;n<(x2-x1-1);n++)
i = 0;
for (n = 0; n < (x2 - x1 - 1); n++)
{
p1.x=0.0;
p1.y=ystep;
p1.z=heights[2][n]-heights[1][n];
p2.x=xstep;
p2.y=ystep;
p2.z=heights[2][n+1]-heights[1][n];
p1.x = 0.0;
p1.y = ystep;
p1.z = heights[2][n] - heights[1][n];
p3.x=xstep;
p3.y=0.0;
p3.z=heights[1][n+1]-heights[1][n];
triangle_normals[1][i]=gimp_vector3_cross_product(&p2,&p1);
triangle_normals[1][i+1]=gimp_vector3_cross_product(&p3,&p2);
p2.x = xstep;
p2.y = ystep;
p2.z = heights[2][n+1] - heights[1][n];
gimp_vector3_normalize(&triangle_normals[1][i]);
gimp_vector3_normalize(&triangle_normals[1][i+1]);
i+=2;
p3.x = xstep;
p3.y = 0.0;
p3.z = heights[1][n+1] - heights[1][n];
triangle_normals[1][i] = gimp_vector3_cross_product (&p2, &p1);
triangle_normals[1][i+1] = gimp_vector3_cross_product (&p3, &p2);
gimp_vector3_normalize (&triangle_normals[1][i]);
gimp_vector3_normalize (&triangle_normals[1][i+1]);
i += 2;
}
/* Compute vertex normals */
/* ====================== */
i=0;
gimp_vector3_set(&normal, 0.0,0.0,0.0);
for (n=0;n<(x2-x1-1);n++)
i = 0;
gimp_vector3_set (&normal, 0.0, 0.0, 0.0);
for (n = 0; n < (x2 - x1 - 1); n++)
{
nv=0;
if (n>0)
nv = 0;
if (n > 0)
{
if (y>0)
if (y > 0)
{
gimp_vector3_add(&normal, &normal, &triangle_normals[0][i-1]);
gimp_vector3_add(&normal, &normal, &triangle_normals[0][i-2]);
nv+=2;
gimp_vector3_add (&normal, &normal, &triangle_normals[0][i-1]);
gimp_vector3_add (&normal, &normal, &triangle_normals[0][i-2]);
nv += 2;
}
if (y<pre_h)
if (y < pre_h)
{
gimp_vector3_add(&normal, &normal, &triangle_normals[1][i-1]);
gimp_vector3_add (&normal, &normal, &triangle_normals[1][i-1]);
nv++;
}
}
if (n<pre_w)
if (n <pre_w)
{
if (y>0)
if (y > 0)
{
gimp_vector3_add(&normal, &normal, &triangle_normals[0][i]);
gimp_vector3_add(&normal, &normal, &triangle_normals[0][i+1]);
nv+=2;
gimp_vector3_add (&normal, &normal, &triangle_normals[0][i]);
gimp_vector3_add (&normal, &normal, &triangle_normals[0][i+1]);
nv += 2;
}
if (y<pre_h)
if (y < pre_h)
{
gimp_vector3_add(&normal, &normal, &triangle_normals[1][i]);
gimp_vector3_add(&normal, &normal, &triangle_normals[1][i+1]);
nv+=2;
gimp_vector3_add (&normal, &normal, &triangle_normals[1][i]);
gimp_vector3_add (&normal, &normal, &triangle_normals[1][i+1]);
nv += 2;
}
}
gimp_vector3_mul(&normal, 1.0/(gdouble)nv);
gimp_vector3_normalize(&normal);
vertex_normals[1][n]=normal;
i+=2;
gimp_vector3_mul (&normal, 1.0 / (gdouble) nv);
gimp_vector3_normalize (&normal);
vertex_normals[1][n] = normal;
i += 2;
}
}
@ -372,16 +384,16 @@ compute_reflected_ray (GimpVector3 *normal,
GimpVector3 *view)
{
GimpVector3 ref;
gdouble nl;
gdouble nl;
nl = 2.0 * gimp_vector3_inner_product (normal, view);
nl = 2.0*gimp_vector3_inner_product(normal,view);
ref = *normal;
gimp_vector3_mul(&ref,nl);
gimp_vector3_sub(&ref,&ref,view);
return(ref);
gimp_vector3_mul (&ref, nl);
gimp_vector3_sub (&ref, &ref, view);
return ref;
}
/************************************************************************/
@ -394,34 +406,37 @@ sphere_to_image (GimpVector3 *normal,
gdouble *u,
gdouble *v)
{
static gdouble alpha,fac;
static gdouble alpha, fac;
static GimpVector3 cross_prod;
static GimpVector3 firstaxis = { 1.0, 0.0, 0.0 };
static GimpVector3 secondaxis = { 0.0, 1.0, 0.0 };
static GimpVector3 secondaxis = { 0.0, 1.0, 0.0 };
alpha=acos(-gimp_vector3_inner_product(&secondaxis,normal));
alpha = acos (-gimp_vector3_inner_product (&secondaxis, normal));
*v=alpha/G_PI;
*v = alpha / G_PI;
if (*v==0.0 || *v==1.0) *u=0.0;
if (*v==0.0 || *v==1.0)
{
*u = 0.0;
}
else
{
fac=gimp_vector3_inner_product(&firstaxis,normal)/sin(alpha);
fac = gimp_vector3_inner_product (&firstaxis, normal) / sin (alpha);
/* Make sure that we map to -1.0..1.0 (take care of rounding errors) */
/* ================================================================= */
if (fac>1.0)
fac=1.0;
fac = 1.0;
else if (fac<-1.0)
fac=-1.0;
fac = -1.0;
*u=acos(fac)/(2.0*G_PI);
cross_prod=gimp_vector3_cross_product(&secondaxis,&firstaxis);
if (gimp_vector3_inner_product(&cross_prod,normal)<0.0)
*u=1.0-*u;
*u = acos (fac) / (2.0 * G_PI);
cross_prod = gimp_vector3_cross_product (&secondaxis, &firstaxis);
if (gimp_vector3_inner_product (&cross_prod, normal) < 0.0)
*u = 1.0 - *u;
}
}
@ -432,233 +447,250 @@ sphere_to_image (GimpVector3 *normal,
GckRGB
get_ray_color (GimpVector3 *position)
{
GckRGB color;
gint x,f;
gdouble xf,yf;
GimpVector3 normal,*p;
GckRGB color;
gint x, f;
gdouble xf, yf;
GimpVector3 normal, *p;
pos_to_float(position->x,position->y,&xf,&yf);
pos_to_float (position->x, position->y, &xf, &yf);
x = (gint)(xf+0.5);
x = RINT (xf);
if (mapvals.transparent_background && heights[1][x]==0)
color.a=0.0;
if (mapvals.transparent_background && heights[1][x] == 0)
{
color.a = 0.0;
}
else
{
color=get_image_color(xf,yf,&f);
color = get_image_color (xf, yf, &f);
if (mapvals.lightsource.type==POINT_LIGHT)
p=&mapvals.lightsource.position;
if (mapvals.lightsource.type == POINT_LIGHT)
p = &mapvals.lightsource.position;
else
p=&mapvals.lightsource.direction;
p = &mapvals.lightsource.direction;
if (mapvals.bump_mapped==FALSE || mapvals.bumpmap_id==-1)
color=phong_shade(position,
&mapvals.viewpoint,
&mapvals.planenormal,
p,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
if (mapvals.bump_mapped == FALSE || mapvals.bumpmap_id == -1)
{
color = phong_shade (position,
&mapvals.viewpoint,
&mapvals.planenormal,
p,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
}
else
{
normal=vertex_normals[1][(gint)(xf+0.5)];
color=phong_shade(position,
&mapvals.viewpoint,
&normal,
p,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
normal = vertex_normals[1][(gint) RINT (xf)];
color = phong_shade (position,
&mapvals.viewpoint,
&normal,
p,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
}
}
return(color);
return color;
}
GckRGB
get_ray_color_ref (GimpVector3 *position)
{
GckRGB color,env_color;
gint x,f;
gdouble xf,yf;
GimpVector3 normal,*p,v,r;
GckRGB color, env_color;
gint x, f;
gdouble xf, yf;
GimpVector3 normal, *p, v, r;
pos_to_float(position->x,position->y,&xf,&yf);
pos_to_float (position->x, position->y, &xf, &yf);
x = (gint)(xf+0.5);
x = RINT (xf);
if (mapvals.transparent_background && heights[1][x]==0)
color.a=0.0;
if (mapvals.transparent_background && heights[1][x] == 0)
{
color.a = 0.0;
}
else
{
color=get_image_color(xf,yf,&f);
color = get_image_color (xf, yf, &f);
if (mapvals.lightsource.type==POINT_LIGHT)
p=&mapvals.lightsource.position;
if (mapvals.lightsource.type == POINT_LIGHT)
p = &mapvals.lightsource.position;
else
p=&mapvals.lightsource.direction;
if (mapvals.bump_mapped==FALSE || mapvals.bumpmap_id==-1)
color=phong_shade(position,
&mapvals.viewpoint,
&mapvals.planenormal,
p,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
p = &mapvals.lightsource.direction;
if (mapvals.bump_mapped == FALSE || mapvals.bumpmap_id == -1)
{
color = phong_shade (position,
&mapvals.viewpoint,
&mapvals.planenormal,
p,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
}
else
{
normal=vertex_normals[1][(gint)(xf+0.5)];
gimp_vector3_sub(&v,&mapvals.viewpoint,position);
gimp_vector3_normalize(&v);
r = compute_reflected_ray(&normal,&v);
normal = vertex_normals[1][(gint) RINT (xf)];
gimp_vector3_sub (&v, &mapvals.viewpoint,position);
gimp_vector3_normalize (&v);
r = compute_reflected_ray (&normal, &v);
/* Get color in the direction of r */
/* =============================== */
sphere_to_image(&r,&xf,&yf);
env_color = peek_env_map((gint)(env_width*xf+0.5),(gint)(env_height*yf+0.5));
color=phong_shade(position,
&mapvals.viewpoint,
&normal,
p,
&env_color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
sphere_to_image (&r, &xf, &yf);
env_color = peek_env_map (RINT (env_width * xf),
RINT (env_height * yf));
color = phong_shade (position,
&mapvals.viewpoint,
&normal,
p,
&env_color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
}
}
return(color);
return color;
}
GckRGB
get_ray_color_no_bilinear (GimpVector3 *position)
{
GckRGB color;
gint x;
gdouble xf,yf;
GimpVector3 normal,*p;
GckRGB color;
gint x;
gdouble xf, yf;
GimpVector3 normal, *p;
pos_to_float(position->x,position->y,&xf,&yf);
pos_to_float (position->x, position->y, &xf, &yf);
x = (gint)(xf+0.5);
if (mapvals.transparent_background && heights[1][x]==0)
color.a=0.0;
x = RINT (xf);
if (mapvals.transparent_background && heights[1][x] == 0)
{
color.a = 0.0;
}
else
{
color=peek(x,(gint)(yf+0.5));
if (mapvals.lightsource.type==POINT_LIGHT)
p=&mapvals.lightsource.position;
color = peek (x, RINT (yf));
if (mapvals.lightsource.type == POINT_LIGHT)
p = &mapvals.lightsource.position;
else
p=&mapvals.lightsource.direction;
if (mapvals.bump_mapped==FALSE || mapvals.bumpmap_id==-1)
color=phong_shade(position,
&mapvals.viewpoint,
&mapvals.planenormal,
p,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
p = &mapvals.lightsource.direction;
if (mapvals.bump_mapped == FALSE || mapvals.bumpmap_id == -1)
{
color = phong_shade (position,
&mapvals.viewpoint,
&mapvals.planenormal,
p,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
}
else
{
normal=vertex_normals[1][x];
color=phong_shade(position,
&mapvals.viewpoint,
&normal,
p,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
normal = vertex_normals[1][x];
color = phong_shade (position,
&mapvals.viewpoint,
&normal,
p,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
}
}
return(color);
return color;
}
GckRGB
get_ray_color_no_bilinear_ref (GimpVector3 *position)
{
GckRGB color,env_color;
gint x;
gdouble xf,yf;
GimpVector3 normal,*p,v,r;
GckRGB color, env_color;
gint x;
gdouble xf, yf;
GimpVector3 normal, *p, v, r;
pos_to_float(position->x,position->y,&xf,&yf);
pos_to_float (position->x, position->y, &xf, &yf);
x = (gint)(xf+0.5);
if (mapvals.transparent_background && heights[1][x]==0)
color.a=0.0;
x = RINT (xf);
if (mapvals.transparent_background && heights[1][x] == 0)
{
color.a = 0.0;
}
else
{
color=peek((gint)(xf+0.5),(gint)(yf+0.5));
color = peek (RINT (xf), RINT (yf));
if (mapvals.lightsource.type==POINT_LIGHT)
p=&mapvals.lightsource.position;
if (mapvals.lightsource.type == POINT_LIGHT)
p = &mapvals.lightsource.position;
else
p=&mapvals.lightsource.direction;
if (mapvals.bump_mapped==FALSE || mapvals.bumpmap_id==-1)
p = &mapvals.lightsource.direction;
if (mapvals.bump_mapped == FALSE || mapvals.bumpmap_id == -1)
{
pos_to_float(position->x,position->y,&xf,&yf);
color=peek((gint)(xf+0.5),(gint)(yf+0.5));
gimp_vector3_sub(&v,&mapvals.viewpoint,position);
gimp_vector3_normalize(&v);
r = compute_reflected_ray(&mapvals.planenormal,&v);
pos_to_float (position->x, position->y, &xf, &yf);
color = peek (RINT (xf), RINT (yf));
gimp_vector3_sub (&v, &mapvals.viewpoint, position);
gimp_vector3_normalize (&v);
r = compute_reflected_ray (&mapvals.planenormal, &v);
/* Get color in the direction of r */
/* =============================== */
sphere_to_image(&r,&xf,&yf);
env_color = peek_env_map((gint)(env_width*xf+0.5),(gint)(env_height*yf+0.5));
color=phong_shade(position,
&mapvals.viewpoint,
&mapvals.planenormal,
p,
&env_color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
sphere_to_image (&r, &xf, &yf);
env_color = peek_env_map (RINT (env_width * xf),
RINT (env_height * yf));
color = phong_shade (position,
&mapvals.viewpoint,
&mapvals.planenormal,
p,
&env_color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
}
else
{
normal=vertex_normals[1][(gint)(xf+0.5)];
pos_to_float(position->x,position->y,&xf,&yf);
color=peek((gint)(xf+0.5),(gint)(yf+0.5));
gimp_vector3_sub(&v,&mapvals.viewpoint,position);
gimp_vector3_normalize(&v);
r = compute_reflected_ray(&normal,&v);
normal = vertex_normals[1][(gint) RINT (xf)];
pos_to_float (position->x, position->y, &xf, &yf);
color = peek (RINT (xf), RINT (yf));
gimp_vector3_sub (&v, &mapvals.viewpoint, position);
gimp_vector3_normalize (&v);
r = compute_reflected_ray (&normal, &v);
/* Get color in the direction of r */
/* =============================== */
sphere_to_image(&r,&xf,&yf);
env_color = peek_env_map((gint)(env_width*xf+0.5),(gint)(env_height*yf+0.5));
color=phong_shade(position,
&mapvals.viewpoint,
&normal,
p,
&env_color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
sphere_to_image (&r, &xf, &yf);
env_color = peek_env_map (RINT (env_width * xf),
RINT (env_height * yf));
color = phong_shade (position,
&mapvals.viewpoint,
&normal,
p,
&env_color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
}
}
return(color);
return color;
}

16
plug-ins/Lighting/lighting_ui.c
View File

@ -17,7 +17,7 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <gtk/gtk.h>
#include "config.h"
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
@ -30,7 +30,6 @@
#include "lighting_apply.h"
#include "lighting_preview.h"
#include "config.h"
#include "libgimp/stdplugins-intl.h"
#include "amb1.xpm"
@ -43,10 +42,12 @@
#include "specref2.xpm"
#include "high1.xpm"
#include "high2.xpm"
/*
#include "pixmaps/zoom_in.xpm"
#include "pixmaps/zoom_out.xpm"
*/
extern LightingValues mapvals;
GckVisualInfo *visinfo = NULL;
@ -121,15 +122,16 @@ static GtkWidget *create_environment_page (void);
/* Update entry fields that affect the preview parameters */
/**********************************************************/
static void xyzval_update(GtkEntry *entry)
static void
xyzval_update (GtkEntry *entry)
{
gdouble *valueptr;
gdouble value;
gdouble value;
valueptr=(gdouble *)gtk_object_get_data(GTK_OBJECT(entry),"ValuePtr");
value = atof(gtk_entry_get_text(entry));
valueptr = (gdouble *) gtk_object_get_data (GTK_OBJECT (entry), "ValuePtr");
value = atof (gtk_entry_get_text (entry));
*valueptr=value;
*valueptr = value;
}
#endif

296
plug-ins/MapObject/mapobject_apply.c
View File

@ -2,6 +2,8 @@
/* Apply mapping and shading on the whole input image */
/******************************************************/
#include "config.h"
#include <string.h>
#include <gtk/gtk.h>
@ -21,7 +23,8 @@
gdouble imat[4][4];
gfloat rotmat[16], a[16], b[16];
void init_compute(void)
void
init_compute (void)
{
gint i;
@ -32,20 +35,24 @@ void init_compute(void)
/* Rotate the equator/northpole axis */
/* ================================= */
gimp_vector3_set(&mapvals.firstaxis,0.0,0.0,-1.0);
gimp_vector3_set(&mapvals.secondaxis,0.0,1.0,0.0);
gimp_vector3_rotate(&mapvals.firstaxis,gimp_deg_to_rad(mapvals.alpha),
gimp_deg_to_rad(mapvals.beta),gimp_deg_to_rad(mapvals.gamma));
gimp_vector3_rotate(&mapvals.secondaxis,gimp_deg_to_rad(mapvals.alpha),
gimp_deg_to_rad(mapvals.beta),gimp_deg_to_rad(mapvals.gamma));
gimp_vector3_set (&mapvals.firstaxis, 0.0, 0.0, -1.0);
gimp_vector3_set (&mapvals.secondaxis, 0.0, 1.0, 0.0);
gimp_vector3_rotate (&mapvals.firstaxis,
gimp_deg_to_rad (mapvals.alpha),
gimp_deg_to_rad (mapvals.beta),
gimp_deg_to_rad (mapvals.gamma));
gimp_vector3_rotate (&mapvals.secondaxis,
gimp_deg_to_rad (mapvals.alpha),
gimp_deg_to_rad (mapvals.beta),
gimp_deg_to_rad (mapvals.gamma));
/* Compute the 2D bounding box of the sphere spanned by the axis */
/* ============================================================= */
compute_bounding_box();
get_ray_color=get_ray_color_sphere;
compute_bounding_box ();
get_ray_color = get_ray_color_sphere;
break;
@ -54,133 +61,151 @@ void init_compute(void)
/* Rotate the plane axis */
/* ===================== */
gimp_vector3_set(&mapvals.firstaxis, 1.0,0.0,0.0);
gimp_vector3_set(&mapvals.secondaxis,0.0,1.0,0.0);
gimp_vector3_set(&mapvals.normal,0.0,0.0,1.0);
gimp_vector3_rotate(&mapvals.firstaxis,gimp_deg_to_rad(mapvals.alpha),
gimp_deg_to_rad(mapvals.beta),gimp_deg_to_rad(mapvals.gamma));
gimp_vector3_rotate(&mapvals.secondaxis,gimp_deg_to_rad(mapvals.alpha),
gimp_deg_to_rad(mapvals.beta),gimp_deg_to_rad(mapvals.gamma));
mapvals.normal=gimp_vector3_cross_product(&mapvals.firstaxis,&mapvals.secondaxis);
if (mapvals.normal.z<0.0)
gimp_vector3_mul(&mapvals.normal,-1.0);
gimp_vector3_set (&mapvals.firstaxis, 1.0, 0.0, 0.0);
gimp_vector3_set (&mapvals.secondaxis, 0.0, 1.0, 0.0);
gimp_vector3_set (&mapvals.normal, 0.0, 0.0, 1.0);
gimp_vector3_rotate (&mapvals.firstaxis,
gimp_deg_to_rad (mapvals.alpha),
gimp_deg_to_rad (mapvals.beta),
gimp_deg_to_rad (mapvals.gamma));
gimp_vector3_rotate (&mapvals.secondaxis,
gimp_deg_to_rad (mapvals.alpha),
gimp_deg_to_rad (mapvals.beta),
gimp_deg_to_rad (mapvals.gamma));
mapvals.normal = gimp_vector3_cross_product (&mapvals.firstaxis,
&mapvals.secondaxis);
if (mapvals.normal.z < 0.0)
gimp_vector3_mul (&mapvals.normal, -1.0);
/* Initialize intersection matrix */
/* ============================== */
imat[0][1]=-mapvals.firstaxis.x;
imat[1][1]=-mapvals.firstaxis.y;
imat[2][1]=-mapvals.firstaxis.z;
imat[0][2]=-mapvals.secondaxis.x;
imat[1][2]=-mapvals.secondaxis.y;
imat[2][2]=-mapvals.secondaxis.z;
imat[0][3]=mapvals.position.x-mapvals.viewpoint.x;
imat[1][3]=mapvals.position.y-mapvals.viewpoint.y;
imat[2][3]=mapvals.position.z-mapvals.viewpoint.z;
get_ray_color=get_ray_color_plane;
imat[0][1] = -mapvals.firstaxis.x;
imat[1][1] = -mapvals.firstaxis.y;
imat[2][1] = -mapvals.firstaxis.z;
imat[0][2] = -mapvals.secondaxis.x;
imat[1][2] = -mapvals.secondaxis.y;
imat[2][2] = -mapvals.secondaxis.z;
imat[0][3] = mapvals.position.x - mapvals.viewpoint.x;
imat[1][3] = mapvals.position.y - mapvals.viewpoint.y;
imat[2][3] = mapvals.position.z - mapvals.viewpoint.z;
get_ray_color = get_ray_color_plane;
break;
case MAP_BOX:
gimp_vector3_set(&mapvals.firstaxis, 1.0,0.0,0.0);
gimp_vector3_set(&mapvals.secondaxis,0.0,1.0,0.0);
gimp_vector3_set(&mapvals.normal,0.0,0.0,1.0);
get_ray_color = get_ray_color_box;
get_ray_color=get_ray_color_box;
ident_mat(rotmat);
rotatemat(mapvals.alpha, &mapvals.firstaxis, a);
gimp_vector3_set (&mapvals.firstaxis, 1.0, 0.0, 0.0);
gimp_vector3_set (&mapvals.secondaxis, 0.0, 1.0, 0.0);
gimp_vector3_set (&mapvals.normal, 0.0, 0.0, 1.0);
matmul(a,rotmat,b);
ident_mat (rotmat);
memcpy(rotmat, b, sizeof(gfloat)*16);
rotatemat (mapvals.alpha, &mapvals.firstaxis, a);
rotatemat(mapvals.beta, &mapvals.secondaxis, a);
matmul(a,rotmat,b);
matmul (a, rotmat, b);
memcpy(rotmat, b, sizeof(gfloat)*16);
memcpy (rotmat, b, sizeof (gfloat) * 16);
rotatemat(mapvals.gamma, &mapvals.normal, a);
matmul(a,rotmat,b);
rotatemat (mapvals.beta, &mapvals.secondaxis, a);
matmul (a, rotmat, b);
memcpy(rotmat, b, sizeof(gfloat)*16);
memcpy (rotmat, b, sizeof (gfloat) * 16);
rotatemat (mapvals.gamma, &mapvals.normal, a);
matmul (a, rotmat, b);
memcpy (rotmat, b, sizeof (gfloat) * 16);
/* Set up pixel regions for the box face images */
/* ============================================ */
for (i=0;i<6;i++)
for (i = 0; i < 6; i++)
{
box_drawables[i] = gimp_drawable_get (mapvals.boxmap_id[i]);
gimp_pixel_rgn_init (&box_regions[i], box_drawables[i],
box_drawables[i] = gimp_drawable_get (mapvals.boxmap_id[i]);
gimp_pixel_rgn_init (&box_regions[i], box_drawables[i],
0, 0,
box_drawables[i]->width, box_drawables[i]->height,
box_drawables[i]->width,
box_drawables[i]->height,
FALSE, FALSE);
}
break;
case MAP_CYLINDER:
get_ray_color=get_ray_color_cylinder;
get_ray_color = get_ray_color_cylinder;
gimp_vector3_set(&mapvals.firstaxis, 1.0,0.0,0.0);
gimp_vector3_set(&mapvals.secondaxis,0.0,1.0,0.0);
gimp_vector3_set(&mapvals.normal,0.0,0.0,1.0);
gimp_vector3_set (&mapvals.firstaxis, 1.0, 0.0, 0.0);
gimp_vector3_set (&mapvals.secondaxis, 0.0, 1.0, 0.0);
gimp_vector3_set (&mapvals.normal, 0.0, 0.0, 1.0);
ident_mat(rotmat);
rotatemat(mapvals.alpha, &mapvals.firstaxis, a);
ident_mat (rotmat);
matmul(a,rotmat,b);
rotatemat (mapvals.alpha, &mapvals.firstaxis, a);
memcpy(rotmat, b, sizeof(gfloat)*16);
matmul (a, rotmat, b);
rotatemat(mapvals.beta, &mapvals.secondaxis, a);
matmul(a,rotmat,b);
memcpy (rotmat, b, sizeof (gfloat) * 16);
memcpy(rotmat, b, sizeof(gfloat)*16);
rotatemat (mapvals.beta, &mapvals.secondaxis, a);
matmul (a, rotmat, b);
rotatemat(mapvals.gamma, &mapvals.normal, a);
matmul(a,rotmat,b);
memcpy (rotmat, b, sizeof (gfloat) * 16);
memcpy(rotmat, b, sizeof(gfloat)*16);
rotatemat (mapvals.gamma, &mapvals.normal, a);
matmul (a, rotmat, b);
memcpy (rotmat, b, sizeof (gfloat) * 16);
/* Set up pixel regions for the cylinder cap images */
/* ================================================ */
for (i=0;i<2;i++)
for (i = 0; i < 2; i++)
{
cylinder_drawables[i] = gimp_drawable_get (mapvals.cylindermap_id[i]);
gimp_pixel_rgn_init (&cylinder_regions[i], cylinder_drawables[i],
cylinder_drawables[i] =
gimp_drawable_get (mapvals.cylindermap_id[i]);
gimp_pixel_rgn_init (&cylinder_regions[i], cylinder_drawables[i],
0, 0,
cylinder_drawables[i]->width, cylinder_drawables[i]->height,
cylinder_drawables[i]->width,
cylinder_drawables[i]->height,
FALSE, FALSE);
}
break;
}
max_depth=(gint)mapvals.maxdepth;
max_depth = (gint) mapvals.maxdepth;
}
void render(gdouble x,gdouble y,GckRGB *col)
void
render (gdouble x,
gdouble y,
GckRGB *col)
{
GimpVector3 pos;
pos.x=x/(gdouble)width;
pos.y=y/(gdouble)height;
pos.z=0.0;
*col=get_ray_color(&pos);
pos.x = x / (gdouble) width;
pos.y = y / (gdouble) height;
pos.z = 0.0;
*col = get_ray_color (&pos);
}
void show_progress(gint min,gint max,gint curr)
void
show_progress (gint min,
gint max,
gint curr)
{
gimp_progress_update((gdouble)curr/(gdouble)max);
gimp_progress_update ((gdouble) curr / (gdouble) max);
}
/**************************************************/
@ -188,90 +213,111 @@ void show_progress(gint min,gint max,gint curr)
/* and updates or creates a new GIMP image. */
/**************************************************/
void compute_image(void)
void
compute_image (void)
{
gint xcount,ycount;
GckRGB color;
glong progress_counter=0;
GimpVector3 p;
gint32 new_image_id=-1,new_layer_id=-1;
gint xcount, ycount;
GckRGB color;
glong progress_counter = 0;
GimpVector3 p;
gint32 new_image_id = -1;
gint32 new_layer_id = -1;
init_compute();
if (mapvals.create_new_image==TRUE || (mapvals.transparent_background==TRUE
&& input_drawable->bpp!=4))
init_compute ();
if (mapvals.create_new_image == TRUE ||
(mapvals.transparent_background == TRUE &&
input_drawable->bpp != 4))
{
/* Create a new image */
/* ================== */
new_image_id=gimp_image_new(width,height,GIMP_RGB);
new_image_id = gimp_image_new (width, height, GIMP_RGB);
if (mapvals.transparent_background==TRUE)
if (mapvals.transparent_background == TRUE)
{
/* Add a layer with an alpha channel */
/* ================================= */
new_layer_id=gimp_layer_new(new_image_id,"Background",width,height,GIMP_RGBA_IMAGE,100.0,GIMP_NORMAL_MODE);
new_layer_id = gimp_layer_new (new_image_id, "Background",
width, height,
GIMP_RGBA_IMAGE,
100.0,
GIMP_NORMAL_MODE);
}
else
{
/* Create a "normal" layer */
/* ======================= */
new_layer_id=gimp_layer_new(new_image_id,"Background",width,height,GIMP_RGB_IMAGE,100.0,GIMP_NORMAL_MODE);
new_layer_id = gimp_layer_new (new_image_id, "Background",
width, height,
GIMP_RGB_IMAGE,
100.0,
GIMP_NORMAL_MODE);
}
gimp_image_add_layer(new_image_id,new_layer_id,0);
output_drawable=gimp_drawable_get(new_layer_id);
gimp_image_add_layer (new_image_id, new_layer_id, 0);
output_drawable = gimp_drawable_get (new_layer_id);
}
gimp_pixel_rgn_init (&dest_region, output_drawable, 0, 0, width, height, TRUE, TRUE);
gimp_pixel_rgn_init (&dest_region, output_drawable,
0, 0, width, height, TRUE, TRUE);
switch (mapvals.maptype)
{
case MAP_PLANE:
gimp_progress_init("Map to object (plane)");
gimp_progress_init ("Map to object (plane)");
break;
case MAP_SPHERE:
gimp_progress_init("Map to object (sphere)");
gimp_progress_init ("Map to object (sphere)");
break;
case MAP_BOX:
gimp_progress_init("Map to object (box)");
gimp_progress_init ("Map to object (box)");
break;
case MAP_CYLINDER:
gimp_progress_init("Map to object (cylinder)");
gimp_progress_init ("Map to object (cylinder)");
break;
}
if (mapvals.antialiasing==FALSE)
if (mapvals.antialiasing == FALSE)
{
for (ycount=0;ycount<height;ycount++)
for (ycount = 0; ycount < height; ycount++)
{
for (xcount=0;xcount<width;xcount++)
for (xcount = 0; xcount < width; xcount++)
{
p=int_to_pos(xcount,ycount);
color=(*get_ray_color)(&p);
poke(xcount,ycount,&color);
if ((progress_counter++ % width)==0)
gimp_progress_update((gdouble)progress_counter/(gdouble)maxcounter);
p = int_to_pos (xcount, ycount);
color = (* get_ray_color) (&p);
poke (xcount, ycount, &color);
if ((progress_counter++ % width) == 0)
gimp_progress_update ((gdouble) progress_counter /
(gdouble) maxcounter);
}
}
}
else
gck_adaptive_supersample_area(0,0,width-1,height-1,max_depth,mapvals.pixeltreshold,
render,poke,show_progress);
{
gck_adaptive_supersample_area (0, 0,
width - 1, height - 1,
max_depth,
mapvals.pixeltreshold,
render,
poke,
show_progress);
}
/* Update the region */
/* ================= */
gimp_drawable_flush (output_drawable);
gimp_drawable_merge_shadow (output_drawable->id, TRUE);
gimp_drawable_update (output_drawable->id, 0, 0, width,height);
gimp_drawable_update (output_drawable->id, 0, 0, width, height);
if (new_image_id!=-1)
if (new_image_id != -1)
{
gimp_display_new(new_image_id);
gimp_displays_flush();
gimp_display_new (new_image_id);
gimp_displays_flush ();
gimp_drawable_detach (output_drawable);
}
}

275
plug-ins/MapObject/mapobject_image.c
View File

@ -5,6 +5,8 @@
/* mapobject_preview.c and mapobject_apply.c */
/*********************************************************/
#include "config.h"
#include <string.h>
#include <sys/types.h>
@ -19,7 +21,7 @@
#include "mapobject_ui.h"
#include "mapobject_image.h"
GimpDrawable *input_drawable,*output_drawable;
GimpDrawable *input_drawable, *output_drawable;
GimpPixelRgn source_region,dest_region;
GimpDrawable *box_drawables[6];
@ -36,7 +38,7 @@ gint imgtype,width,height,in_channels,out_channels;
GckRGB background;
gdouble oldtreshold;
gint border_x1,border_y1,border_x2,border_y2;
gint border_x1, border_y1, border_x2, border_y2;
/******************/
/* Implementation */
@ -47,25 +49,28 @@ peek (gint x,
gint y)
{
static guchar data[4];
GckRGB color;
gimp_pixel_rgn_get_pixel(&source_region,data,x,y);
gimp_pixel_rgn_get_pixel (&source_region, data, x, y);
color.r=(gdouble)(data[0])/255.0;
color.g=(gdouble)(data[1])/255.0;
color.b=(gdouble)(data[2])/255.0;
color.r = (gdouble) (data[0]) / 255.0;
color.g = (gdouble) (data[1]) / 255.0;
color.b = (gdouble) (data[2]) / 255.0;
if (input_drawable->bpp==4)
if (input_drawable->bpp == 4)
{
if (in_channels==4)
color.a=(gdouble)(data[3])/255.0;
if (in_channels == 4)
color.a = (gdouble) (data[3]) / 255.0;
else
color.a=1.0;
color.a = 1.0;
}
else
color.a=1.0;
{
color.a = 1.0;
}
return(color);
return color;
}
static GckRGB
@ -74,25 +79,28 @@ peek_box_image (gint image,
gint y)
{
static guchar data[4];
GckRGB color;
gimp_pixel_rgn_get_pixel(&box_regions[image],data,x,y);
gimp_pixel_rgn_get_pixel (&box_regions[image], data, x, y);
color.r=(gdouble)(data[0])/255.0;
color.g=(gdouble)(data[1])/255.0;
color.b=(gdouble)(data[2])/255.0;
color.r = (gdouble) (data[0]) / 255.0;
color.g = (gdouble) (data[1]) / 255.0;
color.b = (gdouble) (data[2]) / 255.0;
if (box_drawables[image]->bpp==4)
if (box_drawables[image]->bpp == 4)
{
if (gimp_drawable_has_alpha(box_drawables[image]->id))
color.a=(gdouble)(data[3])/255.0;
if (gimp_drawable_has_alpha (box_drawables[image]->id))
color.a = (gdouble) (data[3]) / 255.0;
else
color.a=1.0;
color.a = 1.0;
}
else
color.a=1.0;
{
color.a = 1.0;
}
return(color);
return color;
}
static GckRGB
@ -101,25 +109,28 @@ peek_cylinder_image (gint image,
gint y)
{
static guchar data[4];
GckRGB color;
gimp_pixel_rgn_get_pixel(&cylinder_regions[image],data,x,y);
gimp_pixel_rgn_get_pixel (&cylinder_regions[image],data, x, y);
color.r=(gdouble)(data[0])/255.0;
color.g=(gdouble)(data[1])/255.0;
color.b=(gdouble)(data[2])/255.0;
color.r = (gdouble) (data[0]) / 255.0;
color.g = (gdouble) (data[1]) / 255.0;
color.b = (gdouble) (data[2]) / 255.0;
if (cylinder_drawables[image]->bpp==4)
if (cylinder_drawables[image]->bpp == 4)
{
if (gimp_drawable_has_alpha(cylinder_drawables[image]->id))
color.a=(gdouble)(data[3])/255.0;
if (gimp_drawable_has_alpha (cylinder_drawables[image]->id))
color.a = (gdouble) (data[3]) / 255.0;
else
color.a=1.0;
color.a = 1.0;
}
else
color.a=1.0;
{
color.a = 1.0;
}
return(color);
return color;
}
void
@ -129,22 +140,22 @@ poke (gint x,
{
static guchar data[4];
data[0]=(guchar)(color->r*255.0);
data[1]=(guchar)(color->g*255.0);
data[2]=(guchar)(color->b*255.0);
data[3]=(guchar)(color->a*255.0);
gimp_pixel_rgn_set_pixel(&dest_region,data,x,y);
data[0] = (guchar) (color->r * 255.0);
data[1] = (guchar) (color->g * 255.0);
data[2] = (guchar) (color->b * 255.0);
data[3] = (guchar) (color->a * 255.0);
gimp_pixel_rgn_set_pixel (&dest_region, data, x, y);
}
gint
checkbounds (gint x,
gint y)
{
if (x<border_x1 || y<border_y1 || x>=border_x2 || y>=border_y2)
return(FALSE);
if (x < border_x1 || y < border_y1 || x >= border_x2 || y >= border_y2)
return FALSE;
else
return(TRUE);
return TRUE;
}
static gint
@ -152,15 +163,15 @@ checkbounds_box_image (gint image,
gint x,
gint y)
{
gint w,h;
gint w, h;
w = box_drawables[image]->width;
h = box_drawables[image]->height;
if (x<0 || y<0 || x>=w || y>=h)
return(FALSE);
if (x < 0 || y < 0 || x >= w || y >= h)
return FALSE ;
else
return(TRUE);
return TRUE ;
}
static gint
@ -168,15 +179,15 @@ checkbounds_cylinder_image (gint image,
gint x,
gint y)
{
gint w,h;
gint w, h;
w = cylinder_drawables[image]->width;
h = cylinder_drawables[image]->height;
if (x<0 || y<0 || x>=w || y>=h)
return(FALSE);
if (x < 0 || y < 0 || x >= w || y >= h)
return FALSE;
else
return(TRUE);
return TRUE;
}
GimpVector3
@ -185,11 +196,11 @@ int_to_pos (gint x,
{
GimpVector3 pos;
pos.x=(gdouble)x/(gdouble)width;
pos.y=(gdouble)y/(gdouble)height;
pos.z=0.0;
pos.x = (gdouble) x / (gdouble) width;
pos.y = (gdouble) y / (gdouble) height;
pos.z = 0.0;
return(pos);
return pos;
}
void
@ -198,8 +209,8 @@ pos_to_int (gdouble x,
gint *scr_x,
gint *scr_y)
{
*scr_x=(gint)((x*(gdouble)width));
*scr_y=(gint)((y*(gdouble)height));
*scr_x = (gint) ((x * (gdouble) width));
*scr_y = (gint) ((y * (gdouble) height));
}
/**********************************************/
@ -214,12 +225,13 @@ get_image_color (gdouble u,
{
gint x1, y1, x2, y2;
GckRGB p[4];
pos_to_int(u,v,&x1,&y1);
if (mapvals.tiled==TRUE)
pos_to_int (u, v, &x1, &y1);
if (mapvals.tiled == TRUE)
{
*inside=TRUE;
*inside = TRUE;
if (x1 < 0) x1 = (width-1) - (-x1 % width);
else x1 = x1 % width;
@ -229,34 +241,39 @@ get_image_color (gdouble u,
x2 = (x1 + 1) % width;
y2 = (y1 + 1) % height;
p[0] = peek(x1, y1);
p[1] = peek(x2, y1);
p[2] = peek(x1, y2);
p[3] = peek(x2, y2);
return(gck_bilinear_rgba(u * width, v * height, p));
p[0] = peek (x1, y1);
p[1] = peek (x2, y1);
p[2] = peek (x1, y2);
p[3] = peek (x2, y2);
return gck_bilinear_rgba (u * width, v * height, p);
}
if (checkbounds(x1,y1)==FALSE)
if (checkbounds (x1, y1) == FALSE)
{
*inside=FALSE;
return(background);
*inside =FALSE;
return background;
}
x2 = (x1 + 1);
y2 = (y1 + 1);
if (checkbounds(x2,y2)==FALSE)
if (checkbounds (x2, y2) == FALSE)
{
*inside=TRUE;
return(peek(x1,y1));
*inside = TRUE;
return peek (x1, y1);
}
*inside=TRUE;
p[0] = peek(x1, y1);
p[1] = peek(x2, y1);
p[2] = peek(x1, y2);
p[3] = peek(x2, y2);
return(gck_bilinear_rgba(u * width, v * height, p));
p[0] = peek (x1, y1);
p[1] = peek (x2, y1);
p[2] = peek (x1, y2);
p[3] = peek (x2, y2);
return gck_bilinear_rgba (u * width, v * height, p);
}
GckRGB
@ -270,24 +287,24 @@ get_box_image_color (gint image,
w = box_drawables[image]->width;
h = box_drawables[image]->height;
x1 = (gint)((u*(gdouble)w));
y1 = (gint)((v*(gdouble)h));
x1 = (gint) ((u * (gdouble) w));
y1 = (gint) ((v * (gdouble) h));
if (checkbounds_box_image(image, x1,y1)==FALSE)
return(background);
if (checkbounds_box_image (image, x1, y1) == FALSE)
return background;
x2 = (x1 + 1);
y2 = (y1 + 1);
if (checkbounds_box_image(image, x2,y2)==FALSE)
return(peek_box_image(image, x1,y1));
if (checkbounds_box_image (image, x2, y2) == FALSE)
return peek_box_image (image, x1,y1);
p[0] = peek_box_image(image, x1, y1);
p[1] = peek_box_image(image, x2, y1);
p[2] = peek_box_image(image, x1, y2);
p[3] = peek_box_image(image, x2, y2);
p[0] = peek_box_image (image, x1, y1);
p[1] = peek_box_image (image, x2, y1);
p[2] = peek_box_image (image, x1, y2);
p[3] = peek_box_image (image, x2, y2);
return(gck_bilinear_rgba(u*w, v*h, p));
return gck_bilinear_rgba (u * w, v * h, p);
}
GckRGB
@ -301,24 +318,24 @@ get_cylinder_image_color (gint image,
w = cylinder_drawables[image]->width;
h = cylinder_drawables[image]->height;
x1 = (gint)((u*(gdouble)w));
y1 = (gint)((v*(gdouble)h));
x1 = (gint) ((u * (gdouble) w));
y1 = (gint) ((v * (gdouble) h));
if (checkbounds_cylinder_image(image, x1,y1)==FALSE)
return(background);
if (checkbounds_cylinder_image (image, x1, y1) == FALSE)
return background;
x2 = (x1 + 1);
y2 = (y1 + 1);
if (checkbounds_cylinder_image(image, x2,y2)==FALSE)
return(peek_cylinder_image(image, x1,y1));
if (checkbounds_cylinder_image (image, x2, y2) == FALSE)
return peek_cylinder_image (image, x1,y1);
p[0] = peek_cylinder_image(image, x1, y1);
p[1] = peek_cylinder_image(image, x2, y1);
p[2] = peek_cylinder_image(image, x1, y2);
p[3] = peek_cylinder_image(image, x2, y2);
p[0] = peek_cylinder_image (image, x1, y1);
p[1] = peek_cylinder_image (image, x2, y1);
p[2] = peek_cylinder_image (image, x1, y2);
p[3] = peek_cylinder_image (image, x2, y2);
return(gck_bilinear_rgba(u*w, v*h, p));
return gck_bilinear_rgba (u * w, v * h, p);
}
/****************************************/
@ -330,72 +347,72 @@ image_setup (GimpDrawable *drawable,
gint interactive)
{
glong numbytes;
guchar r,g,b;
guchar r, g, b;
/* Set the tile cache size */
/* ======================= */
gimp_tile_cache_ntiles ((drawable->width + gimp_tile_width() - 1) /
gimp_tile_width());
gimp_tile_width ());
/* Get some useful info on the input drawable */
/* ========================================== */
input_drawable=drawable;
output_drawable=drawable;
input_drawable = drawable;
output_drawable = drawable;
gimp_drawable_mask_bounds (drawable->id,
&border_x1, &border_y1, &border_x2, &border_y2);
width=input_drawable->width;
height=input_drawable->height;
width = input_drawable->width;
height = input_drawable->height;
gimp_pixel_rgn_init (&source_region, input_drawable,
0, 0, width, height, FALSE, FALSE);
maxcounter=(glong)width*(glong)height;
maxcounter = (glong) width * (glong) height;
if (mapvals.transparent_background==TRUE)
gck_rgba_set(&background,0.0,0.0,0.0,0.0);
if (mapvals.transparent_background == TRUE)
{
gck_rgba_set (&background, 0.0, 0.0, 0.0, 0.0);
}
else
{
gimp_palette_get_background(&r,&g,&b);
background.r=(gdouble)r/255.0;
background.g=(gdouble)g/255.0;
background.b=(gdouble)b/255.0;
background.a=1.0;
gimp_palette_get_background (&r,&g,&b);
background.r = (gdouble) r / 255.0;
background.g = (gdouble) g / 255.0;
background.b = (gdouble) b / 255.0;
background.a = 1.0;
}
/* Assume at least RGB */
/* =================== */
in_channels=3;
if (gimp_drawable_has_alpha(input_drawable->id)==TRUE)
in_channels = 3;
if (gimp_drawable_has_alpha (input_drawable->id) == TRUE)
in_channels++;
if (interactive==TRUE)
if (interactive == TRUE)
{
/* Allocate memory for temp. images */
/* ================================ */
numbytes=PREVIEW_HEIGHT*PREVIEW_WIDTH*3;
image=gdk_image_new(GDK_IMAGE_FASTEST,visinfo->visual,
PREVIEW_WIDTH,PREVIEW_HEIGHT);
if (image==NULL)
return(FALSE);
preview_rgb_data=(guchar *)g_malloc((size_t)numbytes);
if (preview_rgb_data==NULL)
return(FALSE);
memset(preview_rgb_data,0,numbytes);
numbytes = PREVIEW_HEIGHT * PREVIEW_WIDTH * 3;
image = gdk_image_new (GDK_IMAGE_FASTEST,
visinfo->visual,
PREVIEW_WIDTH, PREVIEW_HEIGHT);
if (image == NULL)
return FALSE;
preview_rgb_data = g_new0 (guchar, numbytes);
/* Convert from raw RGB to GdkImage */
/* ================================ */
gck_rgb_to_gdkimage(visinfo,preview_rgb_data,image,
PREVIEW_WIDTH,PREVIEW_HEIGHT);
gck_rgb_to_gdkimage (visinfo, preview_rgb_data, image,
PREVIEW_WIDTH, PREVIEW_HEIGHT);
}
return(TRUE);
return TRUE;
}

58
plug-ins/MapObject/mapobject_image.h
View File

@ -4,7 +4,7 @@
/* Externally visible variables */
/* ============================ */
extern GimpDrawable *input_drawable,*output_drawable;
extern GimpDrawable *input_drawable, *output_drawable;
extern GimpPixelRgn source_region,dest_region;
extern GimpDrawable *box_drawables[6];
@ -28,34 +28,34 @@ extern GimpTile *current_in_tile, *current_out_tile;
/* Externally visible functions */
/* ============================ */
extern gint image_setup (GimpDrawable *drawable,
gint interactive);
extern glong in_xy_to_index (gint x,
gint y);
extern glong out_xy_to_index (gint x,
gint y);
extern gint checkbounds (gint x,
gint y);
extern GckRGB peek (gint x,
gint y);
extern void poke (gint x,
gint y,
GckRGB *color);
extern GimpVector3 int_to_pos (gint x,
gint y);
extern void pos_to_int (gdouble x,
gdouble y,
gint *scr_x,
gint *scr_y);
extern gint image_setup (GimpDrawable *drawable,
gint interactive);
extern glong in_xy_to_index (gint x,
gint y);
extern glong out_xy_to_index (gint x,
gint y);
extern gint checkbounds (gint x,
gint y);
extern GckRGB peek (gint x,
gint y);
extern void poke (gint x,
gint y,
GckRGB *color);
extern GimpVector3 int_to_pos (gint x,
gint y);
extern void pos_to_int (gdouble x,
gdouble y,
gint *scr_x,
gint *scr_y);
extern GckRGB get_image_color (gdouble u,
gdouble v,
gint *inside);
extern GckRGB get_box_image_color (gint image,
gdouble u,
gdouble v);
extern GckRGB get_cylinder_image_color (gint image,
gdouble u,
gdouble v);
extern GckRGB get_image_color (gdouble u,
gdouble v,
gint *inside);
extern GckRGB get_box_image_color (gint image,
gdouble u,
gdouble v);
extern GckRGB get_cylinder_image_color (gint image,
gdouble u,
gdouble v);
#endif /* __MAPOBJECT_IMAGE_H__ */

37
plug-ins/MapObject/mapobject_main.c
View File

@ -20,6 +20,8 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gtk/gtk.h>
#include <gck/gck.h>
@ -34,7 +36,6 @@
#include "mapobject_preview.h"
#include "mapobject_main.h"
#include "config.h"
#include "libgimp/stdplugins-intl.h"
@ -194,8 +195,6 @@ query (void)
};
static gint nargs = sizeof (args) / sizeof (args[0]);
INIT_I18N();
gimp_install_procedure ("plug_in_map_object",
"Maps a picture to a object (plane, sphere, box or cylinder)",
"No help yet",
@ -210,27 +209,27 @@ query (void)
}
static void
run (gchar *name,
gint nparams,
run (gchar *name,
gint nparams,
GimpParam *param,
gint *nreturn_vals,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
GimpRunModeType run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint i;
static GimpParam values[1];
GimpDrawable *drawable;
GimpRunModeType run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint i;
run_mode = param[0].data.d_int32;
if (run_mode == GIMP_RUN_INTERACTIVE)
{
INIT_I18N_UI();
INIT_I18N_UI ();
}
else
{
INIT_I18N();
INIT_I18N ();
}
values[0].type = GIMP_PDB_STATUS;
@ -281,7 +280,7 @@ run (gchar *name,
}
else
{
mapvals.maptype = (MapType)param[3].data.d_int32;
mapvals.maptype = (MapType) param[3].data.d_int32;
mapvals.viewpoint.x = param[4].data.d_float;
mapvals.viewpoint.y = param[5].data.d_float;
mapvals.viewpoint.z = param[6].data.d_float;
@ -297,7 +296,7 @@ run (gchar *name,
mapvals.alpha = param[16].data.d_float;
mapvals.beta = param[17].data.d_float;
mapvals.gamma = param[18].data.d_float;
mapvals.lightsource.type = (LightType)param[19].data.d_int32;
mapvals.lightsource.type = (LightType) param[19].data.d_int32;
mapvals.lightsource.color.r = param[20].data.d_color.red;
mapvals.lightsource.color.g = param[20].data.d_color.green;
mapvals.lightsource.color.b = param[20].data.d_color.blue;
@ -312,10 +311,10 @@ run (gchar *name,
mapvals.material.diffuse_ref = param[29].data.d_float;
mapvals.material.specular_ref = param[30].data.d_float;
mapvals.material.highlight = param[31].data.d_float;
mapvals.antialiasing = (gint)param[32].data.d_int32;
mapvals.tiled = (gint)param[33].data.d_int32;
mapvals.create_new_image = (gint)param[34].data.d_int32;
mapvals.transparent_background = (gint)param[35].data.d_int32;
mapvals.antialiasing = (gint) param[32].data.d_int32;
mapvals.tiled = (gint) param[33].data.d_int32;
mapvals.create_new_image = (gint) param[34].data.d_int32;
mapvals.transparent_background = (gint) param[35].data.d_int32;
mapvals.radius = param[36].data.d_float;
mapvals.cylinder_radius = param[36].data.d_float;
mapvals.scale.x = param[37].data.d_float;

935
plug-ins/MapObject/mapobject_preview.c
View File

File diff suppressed because it is too large Load Diff

624
plug-ins/MapObject/mapobject_shade.c
View File

File diff suppressed because it is too large Load Diff

32
plug-ins/MapObject/mapobject_shade.h
View File

@ -5,22 +5,22 @@ typedef GckRGB (* get_ray_color_func) (GimpVector3 *pos);
extern get_ray_color_func get_ray_color;
GckRGB get_ray_color_plane (GimpVector3 *pos);
GckRGB get_ray_color_sphere (GimpVector3 *pos);
GckRGB get_ray_color_box (GimpVector3 *pos);
GckRGB get_ray_color_cylinder (GimpVector3 *pos);
void compute_bounding_box (void);
GckRGB get_ray_color_plane (GimpVector3 *pos);
GckRGB get_ray_color_sphere (GimpVector3 *pos);
GckRGB get_ray_color_box (GimpVector3 *pos);
GckRGB get_ray_color_cylinder (GimpVector3 *pos);
void compute_bounding_box (void);
void vecmulmat (GimpVector3 *u,
GimpVector3 *v,
gfloat m[16]);
void rotatemat (gfloat angle,
GimpVector3 *v,
gfloat m[16]);
void transpose_mat (gfloat m[16]);
void matmul (gfloat a[16],
gfloat b[16],
gfloat c[16]);
void ident_mat (gfloat m[16]);
void vecmulmat (GimpVector3 *u,
GimpVector3 *v,
gfloat m[16]);
void rotatemat (gfloat angle,
GimpVector3 *v,
gfloat m[16]);
void transpose_mat (gfloat m[16]);
void matmul (gfloat a[16],
gfloat b[16],
gfloat c[16]);
void ident_mat (gfloat m[16]);
#endif /* __MAPOBJECT_SHADE_H__ */

23
plug-ins/MapObject/mapobject_ui.c
View File

@ -2,6 +2,8 @@
/* Dialog creation and updaters, callbacks and event-handlers */
/**************************************************************/
#include "config.h"
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
@ -14,7 +16,6 @@
#include "mapobject_preview.h"
#include "mapobject_main.h"
#include "config.h"
#include "libgimp/stdplugins-intl.h"
#include "amb1.xpm"
@ -163,7 +164,9 @@ togglegrid_update (GtkWidget *widget,
gimp_toggle_button_update (widget, data);
if (mapvals.showgrid && linetab[0].x1 == -1)
draw_preview_wireframe ();
{
draw_preview_wireframe ();
}
else if (!mapvals.showgrid && linetab[0].x1 != -1)
{
gck_gc_set_foreground (visinfo, gc, 255, 255, 255);
@ -232,7 +235,9 @@ mapmenu_callback (GtkWidget *widget,
draw_preview_image (TRUE);
if (mapvals.showgrid && linetab[0].x1 == -1)
draw_preview_wireframe ();
{
draw_preview_wireframe ();
}
else if (!mapvals.showgrid && linetab[0].x1 != -1)
{
gck_gc_set_foreground (visinfo, gc, 255, 255, 255);
@ -438,10 +443,13 @@ preview_events (GtkWidget *area,
draw_preview_wireframe ();
}
break;
case GDK_ENTER_NOTIFY:
break;
case GDK_LEAVE_NOTIFY:
break;
case GDK_BUTTON_PRESS:
light_hit = check_light_hit (event->button.x, event->button.y);
if (light_hit == FALSE)
@ -455,9 +463,12 @@ preview_events (GtkWidget *area,
}
left_button_pressed = TRUE;
break;
case GDK_BUTTON_RELEASE:
if (light_hit == TRUE)
draw_preview_image (TRUE);
{
draw_preview_image (TRUE);
}
else
{
pos.x = -(2.0 * (gdouble) event->button.x /
@ -469,6 +480,7 @@ preview_events (GtkWidget *area,
}
left_button_pressed = FALSE;
break;
case GDK_MOTION_NOTIFY:
if (left_button_pressed == TRUE)
{
@ -499,6 +511,7 @@ preview_events (GtkWidget *area,
}
}
break;
default:
break;
}
@ -1500,7 +1513,7 @@ main_dialog (GimpDrawable *drawable)
gdk_image_destroy (image);
gck_visualinfo_destroy (visinfo);
gtk_widget_destroy(appwin);
gtk_widget_destroy (appwin);
gimp_help_free ();

38
plug-ins/libgck/gck/gck.h
View File

@ -42,8 +42,7 @@ extern "C" {
typedef enum
{
DITHER_NONE,
DITHER_FLOYD_STEINBERG,
DITHER_ORDERED
DITHER_FLOYD_STEINBERG
} GckDitherType;
typedef struct
@ -51,12 +50,6 @@ typedef struct
gdouble r, g, b, a;
} GckRGB;
typedef struct
{
guchar r, g, b;
const gchar *name;
} GckNamedRGB;
typedef struct
{
GdkVisual *visual;
@ -75,27 +68,11 @@ typedef void (* GckRenderFunction) (gdouble, gdouble, GckRGB *);
typedef void (* GckPutPixelFunction) (gint, gint, GckRGB *);
typedef void (* GckProgressFunction) (gint, gint, gint);
typedef void (* GckColorUpdateFunction) (GckRGB *);
typedef gint (* GckEventFunction) (GtkWidget *, GdkEvent *, gpointer);
typedef struct
{
GtkWidget *widget;
GckVisualInfo *visinfo;
} GckApplicationWindow;
typedef struct
{
gint x, y, w, h;
GdkImage *buffer;
} _GckBackBuffer;
GckVisualInfo *gck_visualinfo_new (void);
void gck_visualinfo_destroy (GckVisualInfo *visinfo);
GckDitherType gck_visualinfo_get_dither (GckVisualInfo *visinfo);
void gck_visualinfo_set_dither (GckVisualInfo *visinfo,
GckDitherType dithermethod);
/* RGB to Gdk routines */
/* =================== */
@ -103,13 +80,8 @@ void gck_visualinfo_set_dither (GckVisualInfo *visinfo,
void gck_rgb_to_gdkimage (GckVisualInfo *visinfo,
guchar *RGB_data,
GdkImage *image,
int width,int height);
/* returns a static storage */
GdkColor *gck_rgb_to_gdkcolor (GckVisualInfo *visinfo,guchar r,guchar g,guchar b);
/* returns a malloc'ed area */
GdkColor *gck_rgb_to_gdkcolor_r (GckVisualInfo *visinfo,guchar r,guchar g,guchar b);
int width,
int height);
void gck_gc_set_foreground (GckVisualInfo *visinfo,GdkGC *gc,
guchar r, guchar g, guchar b);
@ -166,8 +138,6 @@ gulong gck_adaptive_supersample_area (int x1,int y1,int x2,int y2,
GckPutPixelFunction put_pixel_func,
GckProgressFunction progress_func);
extern GckNamedRGB gck_named_colors[];
#ifdef __cplusplus
}
#endif

779
plug-ins/libgck/gck/gckcolor.c
View File

@ -25,6 +25,8 @@
/* to whatever format the current visual is. */
/*************************************************************/
#include "config.h"
#include <stdlib.h>
#include <string.h>
@ -44,767 +46,15 @@ typedef struct
GckRGB color;
} _GckSampleType;
const GckRGB gck_rgb_white = {1.0, 1.0, 1.0, 1.0};
const GckRGB gck_rgb_black = {0.0, 0.0, 0.0, 1.0};
const GckRGB gck_rgb_zero = {0.0, 0.0, 0.0, 0.0};
const GckRGB gck_rgb_full = {1.0, 1.0, 1.0, 1.0};
GckNamedRGB gck_named_colors[] =
{
{ 255,250,250, "snow" },
{ 248,248,255, "ghost white" },
{ 248,248,255, "GhostWhite" },
{ 245,245,245, "white smoke" },
{ 245,245,245, "WhiteSmoke" },
{ 220,220,220, "gainsboro" },
{ 255,250,240, "floral white" },
{ 255,250,240, "FloralWhite" },
{ 253,245,230, "old lace" },
{ 253,245,230, "OldLace" },
{ 250,240,230, "linen" },
{ 250,235,215, "antique white" },
{ 250,235,215, "AntiqueWhite" },
{ 255,239,213, "papaya whip" },
{ 255,239,213, "PapayaWhip" },
{ 255,235,205, "blanched almond" },
{ 255,235,205, "BlanchedAlmond" },
{ 255,228,196, "bisque" },
{ 255,218,185, "peach puff" },
{ 255,218,185, "PeachPuff" },
{ 255,222,173, "navajo white" },
{ 255,222,173, "NavajoWhite" },
{ 255,228,181, "moccasin" },
{ 255,248,220, "cornsilk" },
{ 255,255,240, "ivory" },
{ 255,250,205, "lemon chiffon" },
{ 255,250,205, "LemonChiffon" },
{ 255,245,238, "seashell" },
{ 240,255,240, "honeydew" },
{ 245,255,250, "mint cream" },
{ 245,255,250, "MintCream" },
{ 240,255,255, "azure" },
{ 240,248,255, "alice blue" },
{ 240,248,255, "AliceBlue" },
{ 230,230,250, "lavender" },
{ 255,240,245, "lavender blush" },
{ 255,240,245, "LavenderBlush" },
{ 255,228,225, "misty rose" },
{ 255,228,225, "MistyRose" },
{ 255,255,255, "white" },
{ 0, 0, 0, "black" },
{ 47, 79, 79, "dark slate gray" },
{ 47, 79, 79, "DarkSlateGray" },
{ 47, 79, 79, "dark slate grey" },
{ 47, 79, 79, "DarkSlateGrey" },
{ 105,105,105, "dim gray" },
{ 105,105,105, "DimGray" },
{ 105,105,105, "dim grey" },
{ 105,105,105, "DimGrey" },
{ 112,128,144, "slate gray" },
{ 112,128,144, "SlateGray" },
{ 112,128,144, "slate grey" },
{ 112,128,144, "SlateGrey" },
{ 119,136,153, "light slate gray" },
{ 119,136,153, "LightSlateGray" },
{ 119,136,153, "light slate grey" },
{ 119,136,153, "LightSlateGrey" },
{ 190,190,190, "gray" },
{ 190,190,190, "grey" },
{ 211,211,211, "light grey" },
{ 211,211,211, "LightGrey" },
{ 211,211,211, "light gray" },
{ 211,211,211, "LightGray" },
{ 25, 25,112, "midnight blue" },
{ 25, 25,112, "MidnightBlue" },
{ 0, 0,128, "navy" },
{ 0, 0,128, "navy blue" },
{ 0, 0,128, "NavyBlue" },
{ 100,149,237, "cornflower blue" },
{ 100,149,237, "CornflowerBlue" },
{ 72, 61,139, "dark slate blue" },
{ 72, 61,139, "DarkSlateBlue" },
{ 106, 90,205, "slate blue" },
{ 106, 90,205, "SlateBlue" },
{ 123,104,238, "medium slate blue" },
{ 123,104,238, "MediumSlateBlue" },
{ 132,112,255, "light slate blue" },
{ 132,112,255, "LightSlateBlue" },
{ 0, 0,205, "medium blue" },
{ 0, 0,205, "MediumBlue" },
{ 65,105,225, "royal blue" },
{ 65,105,225, "RoyalBlue" },
{ 0, 0,255, "blue" },
{ 30,144,255, "dodger blue" },
{ 30,144,255, "DodgerBlue" },
{ 0,191,255, "deep sky blue" },
{ 0,191,255, "DeepSkyBlue" },
{ 135,206,235, "sky blue" },
{ 135,206,235, "SkyBlue" },
{ 135,206,250, "light sky blue" },
{ 135,206,250, "LightSkyBlue" },
{ 70,130,180, "steel blue" },
{ 70,130,180, "SteelBlue" },
{ 176,196,222, "light steel blue" },
{ 176,196,222, "LightSteelBlue" },
{ 173,216,230, "light blue" },
{ 173,216,230, "LightBlue" },
{ 176,224,230, "powder blue" },
{ 176,224,230, "PowderBlue" },
{ 175,238,238, "pale turquoise" },
{ 175,238,238, "PaleTurquoise" },
{ 0,206,209, "dark turquoise" },
{ 0,206,209, "DarkTurquoise" },
{ 72,209,204, "medium turquoise" },
{ 72,209,204, "MediumTurquoise" },
{ 64,224,208, "turquoise" },
{ 0,255,255, "cyan" },
{ 224,255,255, "light cyan" },
{ 224,255,255, "LightCyan" },
{ 95,158,160, "cadet blue" },
{ 95,158,160, "CadetBlue" },
{ 102,205,170, "medium aquamarine" },
{ 102,205,170, "MediumAquamarine" },
{ 127,255,212, "aquamarine" },
{ 0,100, 0, "dark green" },
{ 0,100, 0, "DarkGreen" },
{ 85,107, 47, "dark olive green" },
{ 85,107, 47, "DarkOliveGreen" },
{ 143,188,143, "dark sea green" },
{ 143,188,143, "DarkSeaGreen" },
{ 46,139, 87, "sea green" },
{ 46,139, 87, "SeaGreen" },
{ 60,179,113, "medium sea green" },
{ 60,179,113, "MediumSeaGreen" },
{ 32,178,170, "light sea green" },
{ 32,178,170, "LightSeaGreen" },
{ 152,251,152, "pale green" },
{ 152,251,152, "PaleGreen" },
{ 0,255,127, "spring green" },
{ 0,255,127, "SpringGreen" },
{ 124,252, 0, "lawn green" },
{ 124,252, 0, "LawnGreen" },
{ 0,255, 0, "green" },
{ 127,255, 0, "chartreuse" },
{ 0,250,154, "medium spring green" },
{ 0,250,154, "MediumSpringGreen" },
{ 173,255, 47, "green yellow" },
{ 173,255, 47, "GreenYellow" },
{ 50,205, 50, "lime green" },
{ 50,205, 50, "LimeGreen" },
{ 154,205, 50, "yellow green" },
{ 154,205, 50, "YellowGreen" },
{ 34,139, 34, "forest green" },
{ 34,139, 34, "ForestGreen" },
{ 107,142, 35, "olive drab" },
{ 107,142, 35, "OliveDrab" },
{ 189,183,107, "dark khaki" },
{ 189,183,107, "DarkKhaki" },
{ 240,230,140, "khaki" },
{ 238,232,170, "pale goldenrod" },
{ 238,232,170, "PaleGoldenrod" },
{ 250,250,210, "light goldenrod yellow" },
{ 250,250,210, "LightGoldenrodYellow" },
{ 255,255,224, "light yellow" },
{ 255,255,224, "LightYellow" },
{ 255,255, 0, "yellow" },
{ 255,215, 0, "gold" },
{ 238,221,130, "light goldenrod" },
{ 238,221,130, "LightGoldenrod" },
{ 218,165, 32, "goldenrod" },
{ 184,134, 11, "dark goldenrod" },
{ 184,134, 11, "DarkGoldenrod" },
{ 188,143,143, "rosy brown" },
{ 188,143,143, "RosyBrown" },
{ 205, 92, 92, "indian red" },
{ 205, 92, 92, "IndianRed" },
{ 139, 69, 19, "saddle brown" },
{ 139, 69, 19, "SaddleBrown" },
{ 160, 82, 45, "sienna" },
{ 205,133, 63, "peru" },
{ 222,184,135, "burlywood" },
{ 245,245,220, "beige" },
{ 245,222,179, "wheat" },
{ 244,164, 96, "sandy brown" },
{ 244,164, 96, "SandyBrown" },
{ 210,180,140, "tan" },
{ 210,105, 30, "chocolate" },
{ 178, 34, 34, "firebrick" },
{ 165, 42, 42, "brown" },
{ 233,150,122, "dark salmon" },
{ 233,150,122, "DarkSalmon" },
{ 250,128,114, "salmon" },
{ 255,160,122, "light salmon" },
{ 255,160,122, "LightSalmon" },
{ 255,165, 0, "orange" },
{ 255,140, 0, "dark orange" },
{ 255,140, 0, "DarkOrange" },
{ 255,127, 80, "coral" },
{ 240,128,128, "light coral" },
{ 240,128,128, "LightCoral" },
{ 255, 99, 71, "tomato" },
{ 255, 69, 0, "orange red" },
{ 255, 69, 0, "OrangeRed" },
{ 255, 0, 0, "red" },
{ 255,105,180, "hot pink" },
{ 255,105,180, "HotPink" },
{ 255, 20,147, "deep pink" },
{ 255, 20,147, "DeepPink" },
{ 255,192,203, "pink" },
{ 255,182,193, "light pink" },
{ 255,182,193, "LightPink" },
{ 219,112,147, "pale violet red" },
{ 219,112,147, "PaleVioletRed" },
{ 176, 48, 96, "maroon" },
{ 199, 21,133, "medium violet red" },
{ 199, 21,133, "MediumVioletRed" },
{ 208, 32,144, "violet red" },
{ 208, 32,144, "VioletRed" },
{ 255, 0,255, "magenta" },
{ 238,130,238, "violet" },
{ 221,160,221, "plum" },
{ 218,112,214, "orchid" },
{ 186, 85,211, "medium orchid" },
{ 186, 85,211, "MediumOrchid" },
{ 153, 50,204, "dark orchid" },
{ 153, 50,204, "DarkOrchid" },
{ 148, 0,211, "dark violet" },
{ 148, 0,211, "DarkViolet" },
{ 138, 43,226, "blue violet" },
{ 138, 43,226, "BlueViolet" },
{ 160, 32,240, "purple" },
{ 147,112,219, "medium purple" },
{ 147,112,219, "MediumPurple" },
{ 216,191,216, "thistle" },
{ 255,250,250, "snow1" },
{ 238,233,233, "snow2" },
{ 205,201,201, "snow3" },
{ 139,137,137, "snow4" },
{ 255,245,238, "seashell1" },
{ 238,229,222, "seashell2" },
{ 205,197,191, "seashell3" },
{ 139,134,130, "seashell4" },
{ 255,239,219, "AntiqueWhite1" },
{ 238,223,204, "AntiqueWhite2" },
{ 205,192,176, "AntiqueWhite3" },
{ 139,131,120, "AntiqueWhite4" },
{ 255,228,196, "bisque1" },
{ 238,213,183, "bisque2" },
{ 205,183,158, "bisque3" },
{ 139,125,107, "bisque4" },
{ 255,218,185, "PeachPuff1" },
{ 238,203,173, "PeachPuff2" },
{ 205,175,149, "PeachPuff3" },
{ 139,119,101, "PeachPuff4" },
{ 255,222,173, "NavajoWhite1" },
{ 238,207,161, "NavajoWhite2" },
{ 205,179,139, "NavajoWhite3" },
{ 139,121, 94, "NavajoWhite4" },
{ 255,250,205, "LemonChiffon1" },
{ 238,233,191, "LemonChiffon2" },
{ 205,201,165, "LemonChiffon3" },
{ 139,137,112, "LemonChiffon4" },
{ 255,248,220, "cornsilk1" },
{ 238,232,205, "cornsilk2" },
{ 205,200,177, "cornsilk3" },
{ 139,136,120, "cornsilk4" },
{ 255,255,240, "ivory1" },
{ 238,238,224, "ivory2" },
{ 205,205,193, "ivory3" },
{ 139,139,131, "ivory4" },
{ 240,255,240, "honeydew1" },
{ 224,238,224, "honeydew2" },
{ 193,205,193, "honeydew3" },
{ 131,139,131, "honeydew4" },
{ 255,240,245, "LavenderBlush1" },
{ 238,224,229, "LavenderBlush2" },
{ 205,193,197, "LavenderBlush3" },
{ 139,131,134, "LavenderBlush4" },
{ 255,228,225, "MistyRose1" },
{ 238,213,210, "MistyRose2" },
{ 205,183,181, "MistyRose3" },
{ 139,125,123, "MistyRose4" },
{ 240,255,255, "azure1" },
{ 224,238,238, "azure2" },
{ 193,205,205, "azure3" },
{ 131,139,139, "azure4" },
{ 131,111,255, "SlateBlue1" },
{ 122,103,238, "SlateBlue2" },
{ 105, 89,205, "SlateBlue3" },
{ 71, 60,139, "SlateBlue4" },
{ 72,118,255, "RoyalBlue1" },
{ 67,110,238, "RoyalBlue2" },
{ 58, 95,205, "RoyalBlue3" },
{ 39, 64,139, "RoyalBlue4" },
{ 0, 0,255, "blue1" },
{ 0, 0,238, "blue2" },
{ 0, 0,205, "blue3" },
{ 0, 0,139, "blue4" },
{ 30,144,255, "DodgerBlue1" },
{ 28,134,238, "DodgerBlue2" },
{ 24,116,205, "DodgerBlue3" },
{ 16, 78,139, "DodgerBlue4" },
{ 99,184,255, "SteelBlue1" },
{ 92,172,238, "SteelBlue2" },
{ 79,148,205, "SteelBlue3" },
{ 54,100,139, "SteelBlue4" },
{ 0,191,255, "DeepSkyBlue1" },
{ 0,178,238, "DeepSkyBlue2" },
{ 0,154,205, "DeepSkyBlue3" },
{ 0,104,139, "DeepSkyBlue4" },
{ 135,206,255, "SkyBlue1" },
{ 126,192,238, "SkyBlue2" },
{ 108,166,205, "SkyBlue3" },
{ 74,112,139, "SkyBlue4" },
{ 176,226,255, "LightSkyBlue1" },
{ 164,211,238, "LightSkyBlue2" },
{ 141,182,205, "LightSkyBlue3" },
{ 96,123,139, "LightSkyBlue4" },
{ 198,226,255, "SlateGray1" },
{ 185,211,238, "SlateGray2" },
{ 159,182,205, "SlateGray3" },
{ 108,123,139, "SlateGray4" },
{ 202,225,255, "LightSteelBlue1" },
{ 188,210,238, "LightSteelBlue2" },
{ 162,181,205, "LightSteelBlue3" },
{ 110,123,139, "LightSteelBlue4" },
{ 191,239,255, "LightBlue1" },
{ 178,223,238, "LightBlue2" },
{ 154,192,205, "LightBlue3" },
{ 104,131,139, "LightBlue4" },
{ 224,255,255, "LightCyan1" },
{ 209,238,238, "LightCyan2" },
{ 180,205,205, "LightCyan3" },
{ 122,139,139, "LightCyan4" },
{ 187,255,255, "PaleTurquoise1" },
{ 174,238,238, "PaleTurquoise2" },
{ 150,205,205, "PaleTurquoise3" },
{ 102,139,139, "PaleTurquoise4" },
{ 152,245,255, "CadetBlue1" },
{ 142,229,238, "CadetBlue2" },
{ 122,197,205, "CadetBlue3" },
{ 83,134,139, "CadetBlue4" },
{ 0,245,255, "turquoise1" },
{ 0,229,238, "turquoise2" },
{ 0,197,205, "turquoise3" },
{ 0,134,139, "turquoise4" },
{ 0,255,255, "cyan1" },
{ 0,238,238, "cyan2" },
{ 0,205,205, "cyan3" },
{ 0,139,139, "cyan4" },
{ 151,255,255, "DarkSlateGray1" },
{ 141,238,238, "DarkSlateGray2" },
{ 121,205,205, "DarkSlateGray3" },
{ 82,139,139, "DarkSlateGray4" },
{ 127,255,212, "aquamarine1" },
{ 118,238,198, "aquamarine2" },
{ 102,205,170, "aquamarine3" },
{ 69,139,116, "aquamarine4" },
{ 193,255,193, "DarkSeaGreen1" },
{ 180,238,180, "DarkSeaGreen2" },
{ 155,205,155, "DarkSeaGreen3" },
{ 105,139,105, "DarkSeaGreen4" },
{ 84,255,159, "SeaGreen1" },
{ 78,238,148, "SeaGreen2" },
{ 67,205,128, "SeaGreen3" },
{ 46,139, 87, "SeaGreen4" },
{ 154,255,154, "PaleGreen1" },
{ 144,238,144, "PaleGreen2" },
{ 124,205,124, "PaleGreen3" },
{ 84,139, 84, "PaleGreen4" },
{ 0,255,127, "SpringGreen1" },
{ 0,238,118, "SpringGreen2" },
{ 0,205,102, "SpringGreen3" },
{ 0,139, 69, "SpringGreen4" },
{ 0,255, 0, "green1" },
{ 0,238, 0, "green2" },
{ 0,205, 0, "green3" },
{ 0,139, 0, "green4" },
{ 127,255, 0, "chartreuse1" },
{ 118,238, 0, "chartreuse2" },
{ 102,205, 0, "chartreuse3" },
{ 69,139, 0, "chartreuse4" },
{ 192,255, 62, "OliveDrab1" },
{ 179,238, 58, "OliveDrab2" },
{ 154,205, 50, "OliveDrab3" },
{ 105,139, 34, "OliveDrab4" },
{ 202,255,112, "DarkOliveGreen1" },
{ 188,238,104, "DarkOliveGreen2" },
{ 162,205, 90, "DarkOliveGreen3" },
{ 110,139, 61, "DarkOliveGreen4" },
{ 255,246,143, "khaki1" },
{ 238,230,133, "khaki2" },
{ 205,198,115, "khaki3" },
{ 139,134, 78, "khaki4" },
{ 255,236,139, "LightGoldenrod1" },
{ 238,220,130, "LightGoldenrod2" },
{ 205,190,112, "LightGoldenrod3" },
{ 139,129, 76, "LightGoldenrod4" },
{ 255,255,224, "LightYellow1" },
{ 238,238,209, "LightYellow2" },
{ 205,205,180, "LightYellow3" },
{ 139,139,122, "LightYellow4" },
{ 255,255, 0, "yellow1" },
{ 238,238, 0, "yellow2" },
{ 205,205, 0, "yellow3" },
{ 139,139, 0, "yellow4" },
{ 255,215, 0, "gold1" },
{ 238,201, 0, "gold2" },
{ 205,173, 0, "gold3" },
{ 139,117, 0, "gold4" },
{ 255,193, 37, "goldenrod1" },
{ 238,180, 34, "goldenrod2" },
{ 205,155, 29, "goldenrod3" },
{ 139,105, 20, "goldenrod4" },
{ 255,185, 15, "DarkGoldenrod1" },
{ 238,173, 14, "DarkGoldenrod2" },
{ 205,149, 12, "DarkGoldenrod3" },
{ 139,101, 8, "DarkGoldenrod4" },
{ 255,193,193, "RosyBrown1" },
{ 238,180,180, "RosyBrown2" },
{ 205,155,155, "RosyBrown3" },
{ 139,105,105, "RosyBrown4" },
{ 255,106,106, "IndianRed1" },
{ 238, 99, 99, "IndianRed2" },
{ 205, 85, 85, "IndianRed3" },
{ 139, 58, 58, "IndianRed4" },
{ 255,130, 71, "sienna1" },
{ 238,121, 66, "sienna2" },
{ 205,104, 57, "sienna3" },
{ 139, 71, 38, "sienna4" },
{ 255,211,155, "burlywood1" },
{ 238,197,145, "burlywood2" },
{ 205,170,125, "burlywood3" },
{ 139,115, 85, "burlywood4" },
{ 255,231,186, "wheat1" },
{ 238,216,174, "wheat2" },
{ 205,186,150, "wheat3" },
{ 139,126,102, "wheat4" },
{ 255,165, 79, "tan1" },
{ 238,154, 73, "tan2" },
{ 205,133, 63, "tan3" },
{ 139, 90, 43, "tan4" },
{ 255,127, 36, "chocolate1" },
{ 238,118, 33, "chocolate2" },
{ 205,102, 29, "chocolate3" },
{ 139, 69, 19, "chocolate4" },
{ 255, 48, 48, "firebrick1" },
{ 238, 44, 44, "firebrick2" },
{ 205, 38, 38, "firebrick3" },
{ 139, 26, 26, "firebrick4" },
{ 255, 64, 64, "brown1" },
{ 238, 59, 59, "brown2" },
{ 205, 51, 51, "brown3" },
{ 139, 35, 35, "brown4" },
{ 255,140,105, "salmon1" },
{ 238,130, 98, "salmon2" },
{ 205,112, 84, "salmon3" },
{ 139, 76, 57, "salmon4" },
{ 255,160,122, "LightSalmon1" },
{ 238,149,114, "LightSalmon2" },
{ 205,129, 98, "LightSalmon3" },
{ 139, 87, 66, "LightSalmon4" },
{ 255,165, 0, "orange1" },
{ 238,154, 0, "orange2" },
{ 205,133, 0, "orange3" },
{ 139, 90, 0, "orange4" },
{ 255,127, 0, "DarkOrange1" },
{ 238,118, 0, "DarkOrange2" },
{ 205,102, 0, "DarkOrange3" },
{ 139, 69, 0, "DarkOrange4" },
{ 255,114, 86, "coral1" },
{ 238,106, 80, "coral2" },
{ 205, 91, 69, "coral3" },
{ 139, 62, 47, "coral4" },
{ 255, 99, 71, "tomato1" },
{ 238, 92, 66, "tomato2" },
{ 205, 79, 57, "tomato3" },
{ 139, 54, 38, "tomato4" },
{ 255, 69, 0, "OrangeRed1" },
{ 238, 64, 0, "OrangeRed2" },
{ 205, 55, 0, "OrangeRed3" },
{ 139, 37, 0, "OrangeRed4" },
{ 255, 0, 0, "red1" },
{ 238, 0, 0, "red2" },
{ 205, 0, 0, "red3" },
{ 139, 0, 0, "red4" },
{ 255, 20,147, "DeepPink1" },
{ 238, 18,137, "DeepPink2" },
{ 205, 16,118, "DeepPink3" },
{ 139, 10, 80, "DeepPink4" },
{ 255,110,180, "HotPink1" },
{ 238,106,167, "HotPink2" },
{ 205, 96,144, "HotPink3" },
{ 139, 58, 98, "HotPink4" },
{ 255,181,197, "pink1" },
{ 238,169,184, "pink2" },
{ 205,145,158, "pink3" },
{ 139, 99,108, "pink4" },
{ 255,174,185, "LightPink1" },
{ 238,162,173, "LightPink2" },
{ 205,140,149, "LightPink3" },
{ 139, 95,101, "LightPink4" },
{ 255,130,171, "PaleVioletRed1" },
{ 238,121,159, "PaleVioletRed2" },
{ 205,104,137, "PaleVioletRed3" },
{ 139, 71, 93, "PaleVioletRed4" },
{ 255, 52,179, "maroon1" },
{ 238, 48,167, "maroon2" },
{ 205, 41,144, "maroon3" },
{ 139, 28, 98, "maroon4" },
{ 255, 62,150, "VioletRed1" },
{ 238, 58,140, "VioletRed2" },
{ 205, 50,120, "VioletRed3" },
{ 139, 34, 82, "VioletRed4" },
{ 255, 0,255, "magenta1" },
{ 238, 0,238, "magenta2" },
{ 205, 0,205, "magenta3" },
{ 139, 0,139, "magenta4" },
{ 255,131,250, "orchid1" },
{ 238,122,233, "orchid2" },
{ 205,105,201, "orchid3" },
{ 139, 71,137, "orchid4" },
{ 255,187,255, "plum1" },
{ 238,174,238, "plum2" },
{ 205,150,205, "plum3" },
{ 139,102,139, "plum4" },
{ 224,102,255, "MediumOrchid1" },
{ 209, 95,238, "MediumOrchid2" },
{ 180, 82,205, "MediumOrchid3" },
{ 122, 55,139, "MediumOrchid4" },
{ 191, 62,255, "DarkOrchid1" },
{ 178, 58,238, "DarkOrchid2" },
{ 154, 50,205, "DarkOrchid3" },
{ 104, 34,139, "DarkOrchid4" },
{ 155, 48,255, "purple1" },
{ 145, 44,238, "purple2" },
{ 125, 38,205, "purple3" },
{ 85, 26,139, "purple4" },
{ 171,130,255, "MediumPurple1" },
{ 159,121,238, "MediumPurple2" },
{ 137,104,205, "MediumPurple3" },
{ 93, 71,139, "MediumPurple4" },
{ 255,225,255, "thistle1" },
{ 238,210,238, "thistle2" },
{ 205,181,205, "thistle3" },
{ 139,123,139, "thistle4" },
{ 0, 0, 0, "gray0" },
{ 0, 0, 0, "grey0" },
{ 3, 3, 3, "gray1" },
{ 3, 3, 3, "grey1" },
{ 5, 5, 5, "gray2" },
{ 5, 5, 5, "grey2" },
{ 8, 8, 8, "gray3" },
{ 8, 8, 8, "grey3" },
{ 10, 10, 10, "gray4" },
{ 10, 10, 10, "grey4" },
{ 13, 13, 13, "gray5" },
{ 13, 13, 13, "grey5" },
{ 15, 15, 15, "gray6" },
{ 15, 15, 15, "grey6" },
{ 18, 18, 18, "gray7" },
{ 18, 18, 18, "grey7" },
{ 20, 20, 20, "gray8" },
{ 20, 20, 20, "grey8" },
{ 23, 23, 23, "gray9" },
{ 23, 23, 23, "grey9" },
{ 26, 26, 26, "gray10" },
{ 26, 26, 26, "grey10" },
{ 28, 28, 28, "gray11" },
{ 28, 28, 28, "grey11" },
{ 31, 31, 31, "gray12" },
{ 31, 31, 31, "grey12" },
{ 33, 33, 33, "gray13" },
{ 33, 33, 33, "grey13" },
{ 36, 36, 36, "gray14" },
{ 36, 36, 36, "grey14" },
{ 38, 38, 38, "gray15" },
{ 38, 38, 38, "grey15" },
{ 41, 41, 41, "gray16" },
{ 41, 41, 41, "grey16" },
{ 43, 43, 43, "gray17" },
{ 43, 43, 43, "grey17" },
{ 46, 46, 46, "gray18" },
{ 46, 46, 46, "grey18" },
{ 48, 48, 48, "gray19" },
{ 48, 48, 48, "grey19" },
{ 51, 51, 51, "gray20" },
{ 51, 51, 51, "grey20" },
{ 54, 54, 54, "gray21" },
{ 54, 54, 54, "grey21" },
{ 56, 56, 56, "gray22" },
{ 56, 56, 56, "grey22" },
{ 59, 59, 59, "gray23" },
{ 59, 59, 59, "grey23" },
{ 61, 61, 61, "gray24" },
{ 61, 61, 61, "grey24" },
{ 64, 64, 64, "gray25" },
{ 64, 64, 64, "grey25" },
{ 66, 66, 66, "gray26" },
{ 66, 66, 66, "grey26" },
{ 69, 69, 69, "gray27" },
{ 69, 69, 69, "grey27" },
{ 71, 71, 71, "gray28" },
{ 71, 71, 71, "grey28" },
{ 74, 74, 74, "gray29" },
{ 74, 74, 74, "grey29" },
{ 77, 77, 77, "gray30" },
{ 77, 77, 77, "grey30" },
{ 79, 79, 79, "gray31" },
{ 79, 79, 79, "grey31" },
{ 82, 82, 82, "gray32" },
{ 82, 82, 82, "grey32" },
{ 84, 84, 84, "gray33" },
{ 84, 84, 84, "grey33" },
{ 87, 87, 87, "gray34" },
{ 87, 87, 87, "grey34" },
{ 89, 89, 89, "gray35" },
{ 89, 89, 89, "grey35" },
{ 92, 92, 92, "gray36" },
{ 92, 92, 92, "grey36" },
{ 94, 94, 94, "gray37" },
{ 94, 94, 94, "grey37" },
{ 97, 97, 97, "gray38" },
{ 97, 97, 97, "grey38" },
{ 99, 99, 99, "gray39" },
{ 99, 99, 99, "grey39" },
{ 102,102,102, "gray40" },
{ 102,102,102, "grey40" },
{ 105,105,105, "gray41" },
{ 105,105,105, "grey41" },
{ 107,107,107, "gray42" },
{ 107,107,107, "grey42" },
{ 110,110,110, "gray43" },
{ 110,110,110, "grey43" },
{ 112,112,112, "gray44" },
{ 112,112,112, "grey44" },
{ 115,115,115, "gray45" },
{ 115,115,115, "grey45" },
{ 117,117,117, "gray46" },
{ 117,117,117, "grey46" },
{ 120,120,120, "gray47" },
{ 120,120,120, "grey47" },
{ 122,122,122, "gray48" },
{ 122,122,122, "grey48" },
{ 125,125,125, "gray49" },
{ 125,125,125, "grey49" },
{ 127,127,127, "gray50" },
{ 127,127,127, "grey50" },
{ 130,130,130, "gray51" },
{ 130,130,130, "grey51" },
{ 133,133,133, "gray52" },
{ 133,133,133, "grey52" },
{ 135,135,135, "gray53" },
{ 135,135,135, "grey53" },
{ 138,138,138, "gray54" },
{ 138,138,138, "grey54" },
{ 140,140,140, "gray55" },
{ 140,140,140, "grey55" },
{ 143,143,143, "gray56" },
{ 143,143,143, "grey56" },
{ 145,145,145, "gray57" },
{ 145,145,145, "grey57" },
{ 148,148,148, "gray58" },
{ 148,148,148, "grey58" },
{ 150,150,150, "gray59" },
{ 150,150,150, "grey59" },
{ 153,153,153, "gray60" },
{ 153,153,153, "grey60" },
{ 156,156,156, "gray61" },
{ 156,156,156, "grey61" },
{ 158,158,158, "gray62" },
{ 158,158,158, "grey62" },
{ 161,161,161, "gray63" },
{ 161,161,161, "grey63" },
{ 163,163,163, "gray64" },
{ 163,163,163, "grey64" },
{ 166,166,166, "gray65" },
{ 166,166,166, "grey65" },
{ 168,168,168, "gray66" },
{ 168,168,168, "grey66" },
{ 171,171,171, "gray67" },
{ 171,171,171, "grey67" },
{ 173,173,173, "gray68" },
{ 173,173,173, "grey68" },
{ 176,176,176, "gray69" },
{ 176,176,176, "grey69" },
{ 179,179,179, "gray70" },
{ 179,179,179, "grey70" },
{ 181,181,181, "gray71" },
{ 181,181,181, "grey71" },
{ 184,184,184, "gray72" },
{ 184,184,184, "grey72" },
{ 186,186,186, "gray73" },
{ 186,186,186, "grey73" },
{ 189,189,189, "gray74" },
{ 189,189,189, "grey74" },
{ 191,191,191, "gray75" },
{ 191,191,191, "grey75" },
{ 194,194,194, "gray76" },
{ 194,194,194, "grey76" },
{ 196,196,196, "gray77" },
{ 196,196,196, "grey77" },
{ 199,199,199, "gray78" },
{ 199,199,199, "grey78" },
{ 201,201,201, "gray79" },
{ 201,201,201, "grey79" },
{ 204,204,204, "gray80" },
{ 204,204,204, "grey80" },
{ 207,207,207, "gray81" },
{ 207,207,207, "grey81" },
{ 209,209,209, "gray82" },
{ 209,209,209, "grey82" },
{ 212,212,212, "gray83" },
{ 212,212,212, "grey83" },
{ 214,214,214, "gray84" },
{ 214,214,214, "grey84" },
{ 217,217,217, "gray85" },
{ 217,217,217, "grey85" },
{ 219,219,219, "gray86" },
{ 219,219,219, "grey86" },
{ 222,222,222, "gray87" },
{ 222,222,222, "grey87" },
{ 224,224,224, "gray88" },
{ 224,224,224, "grey88" },
{ 227,227,227, "gray89" },
{ 227,227,227, "grey89" },
{ 229,229,229, "gray90" },
{ 229,229,229, "grey90" },
{ 232,232,232, "gray91" },
{ 232,232,232, "grey91" },
{ 235,235,235, "gray92" },
{ 235,235,235, "grey92" },
{ 237,237,237, "gray93" },
{ 237,237,237, "grey93" },
{ 240,240,240, "gray94" },
{ 240,240,240, "grey94" },
{ 242,242,242, "gray95" },
{ 242,242,242, "grey95" },
{ 245,245,245, "gray96" },
{ 245,245,245, "grey96" },
{ 247,247,247, "gray97" },
{ 247,247,247, "grey97" },
{ 250,250,250, "gray98" },
{ 250,250,250, "grey98" },
{ 252,252,252, "gray99" },
{ 252,252,252, "grey99" },
{ 255,255,255, "gray100" },
{ 255,255,255, "grey100" },
{ 169,169,169, "dark grey" },
{ 169,169,169, "DarkGrey" },
{ 169,169,169, "dark gray" },
{ 169,169,169, "DarkGray" },
{ 0, 0,139, "dark blue" },
{ 0, 0,139, "DarkBlue" },
{ 0,139,139, "dark cyan" },
{ 0,139,139, "DarkCyan" },
{ 139, 0,139, "dark magenta" },
{ 139, 0,139, "DarkMagenta" },
{ 139, 0, 0, "dark red" },
{ 139, 0, 0, "DarkRed" },
{ 144,238,144, "light green" },
{ 144,238,144, "LightGreen" },
{ 0, 0, 0, NULL }
};
/* returns a static storage */
static GdkColor *gck_rgb_to_gdkcolor (GckVisualInfo *visinfo,
guchar r,guchar g,guchar b);
/* returns a malloc'ed area */
static GdkColor *gck_rgb_to_gdkcolor_r (GckVisualInfo *visinfo,
guchar r,guchar g,guchar b);
/******************/
/* Implementation */
@ -907,8 +157,7 @@ void gck_create_8bit_rgb(GckVisualInfo * visinfo)
visinfo->rgbpalette[i].red = (guint) ROUND_TO_INT(255.0 * (double)(r * visinfo->visual->colormap_size) / (double)dr);
visinfo->rgbpalette[i].green = (guint) ROUND_TO_INT(255.0 * (double)(g * visinfo->visual->colormap_size) / (double)dg);
visinfo->rgbpalette[i].blue = (guint) ROUND_TO_INT(255.0 * (double)(b * visinfo->visual->colormap_size) / (double)db);
visinfo->rgbpalette[i].pixel = visinfo->allocedpixels[i];
visinfo->rgbpalette[i].blue = (guint) ROUND_TO_INT(255.0 * (double)(b * visinfo->visual->colormap_size) / (double)db); visinfo->rgbpalette[i].pixel = visinfo->allocedpixels[i];
visinfo->indextab[r][g][b] = (guchar) visinfo->allocedpixels[i];
i++;
}
@ -1933,7 +1182,8 @@ void gck_rgb_to_gdkimage(GckVisualInfo * visinfo,
/*
* Non-reentrant function - GdkColor is a static storage
*/
GdkColor *gck_rgb_to_gdkcolor(GckVisualInfo * visinfo, guchar r, guchar g, guchar b)
static GdkColor *
gck_rgb_to_gdkcolor(GckVisualInfo * visinfo, guchar r, guchar g, guchar b)
{
GdkColor *color=NULL;
@ -1981,7 +1231,8 @@ GdkColor *gck_rgb_to_gdkcolor(GckVisualInfo * visinfo, guchar r, guchar g, gucha
/*
* Reentrant function - GdkColor will be malloc'ed
*/
GdkColor *gck_rgb_to_gdkcolor_r(GckVisualInfo * visinfo, guchar r, guchar g, guchar b)
static GdkColor *
gck_rgb_to_gdkcolor_r(GckVisualInfo * visinfo, guchar r, guchar g, guchar b)
{
GdkColor *color=NULL;