/**
* gimp_vector_3d_to_2d:
* @sx: the abscissa of the upper-left screen rectangle.
* @sy: the ordinate of the upper-left screen rectangle.
* @w: the width of the screen rectangle.
* @h: the height of the screen rectangle.
* @x: the abscissa of the point in the screen rectangle to map (return value).
* @y: the ordinate of the point in the screen rectangle to map (return value).
* @vp: position of the observer.
* @p: the 3D point to project to the plane.
*
* Convert the given 3D point to 2D (project it onto the viewing
* plane, (sx, sy, 0) - (sx + w, sy + h, 0). The input is assumed to
* be in the unit square (0, 0, z) - (1, 1, z). The viewpoint of the
* observer is passed in vp.
*
* This is basically the opposite of gimp_vector_2d_to_3d().
**/
void
gimp_vector_3d_to_2d (gint sx,
gint sy,
gint w,
gint h,
gdouble *x,
gdouble *y,
const GimpVector3 *vp,
const GimpVector3 *p)
{
gdouble t;
GimpVector3 dir;
gimp_vector3_sub (&dir, p, vp);
gimp_vector3_normalize (&dir);
if (dir.z != 0.0)
{
t = (-1.0 * vp->z) / dir.z;
*x = (gdouble) sx + ((vp->x + t * dir.x) * (gdouble) w);
*y = (gdouble) sy + ((vp->y + t * dir.y) * (gdouble) h);
}
else
{
*x = (gdouble) sx + (p->x * (gdouble) w);
*y = (gdouble) sy + (p->y * (gdouble) h);
}
}
void
compute_bounding_box (void)
{
GimpVector3 p1, p2;
gdouble t;
GimpVector3 dir;
p1 = mapvals.position;
p1.x -= (mapvals.radius + 0.01);
p1.y -= (mapvals.radius + 0.01);
p2 = mapvals.position;
p2.x += (mapvals.radius + 0.01);
p2.y += (mapvals.radius + 0.01);
gimp_vector3_sub (&dir, &p1, &mapvals.viewpoint);
gimp_vector3_normalize (&dir);
if (dir.z != 0.0)
{
t = (-1.0 * mapvals.viewpoint.z) / dir.z;
p1.x = (mapvals.viewpoint.x + t * dir.x);
p1.y = (mapvals.viewpoint.y + t * dir.y);
}
gimp_vector3_sub (&dir, &p2, &mapvals.viewpoint);
gimp_vector3_normalize (&dir);
if (dir.z != 0.0)
{
t = (-1.0 * mapvals.viewpoint.z) / dir.z;
p2.x = (mapvals.viewpoint.x + t * dir.x);
p2.y = (mapvals.viewpoint.y + t * dir.y);
}
bx1 = p1.x;
by1 = p1.y;
bx2 = p2.x;
by2 = p2.y;
}
GimpRGB
get_ray_color_plane (GimpVector3 *pos)
{
GimpRGB color = background;
static gint inside = FALSE;
static GimpVector3 ray, spos;
static gdouble vx, vy;
/* Construct a line from our VP to the point */
/* ========================================= */
gimp_vector3_sub (&ray, pos, &mapvals.viewpoint);
gimp_vector3_normalize (&ray);
/* Check for intersection. This is a quasi ray-tracer. */
/* =================================================== */
if (plane_intersect (&ray, &mapvals.viewpoint, &spos, &vx, &vy) == TRUE)
{
color = get_image_color (vx, vy, &inside);
if (color.a != 0.0 && inside == TRUE &&
mapvals.lightsource.type != NO_LIGHT)
{
/* Compute shading at this point */
/* ============================= */
color = phong_shade (&spos,
&mapvals.viewpoint,
&mapvals.normal,
&mapvals.lightsource.position,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
gimp_rgb_clamp (&color);
}
}
if (mapvals.transparent_background == FALSE && color.a < 1.0)
{
gimp_rgb_composite (&color, &background,
GIMP_RGB_COMPOSITE_BEHIND);
}
return color;
}
GimpRGB
get_ray_color_box (GimpVector3 *pos)
{
GimpVector3 lvp, ldir, vp, p, dir, ns, nn;
GimpRGB color, color2;
gfloat m[16];
gint i;
FaceIntersectInfo face_intersect[2];
color = background;
vp = mapvals.viewpoint;
p = *pos;
/* Translate viewpoint so that the box has its origin */
/* at its lower left corner. */
/* ================================================== */
vp.x = vp.x - mapvals.position.x;
vp.y = vp.y - mapvals.position.y;
vp.z = vp.z - mapvals.position.z;
p.x = p.x - mapvals.position.x;
p.y = p.y - mapvals.position.y;
p.z = p.z - mapvals.position.z;
/* Compute direction */
/* ================= */
gimp_vector3_sub (&dir, &p, &vp);
gimp_vector3_normalize (&dir);
/* Compute inverse of rotation matrix and apply it to */
/* the viewpoint and direction. This transforms the */
/* observer into the local coordinate system of the box */
/* ==================================================== */
memcpy (m, rotmat, sizeof (gfloat) * 16);
transpose_mat (m);
vecmulmat (&lvp, &vp, m);
vecmulmat (&ldir, &dir, m);
/* Ok. Now the observer is in the space where the box is located */
/* with its lower left corner at the origin and its axis aligned */
/* to the cartesian basis. Check if the transformed ray hits it. */
/* ============================================================= */
face_intersect[0].t = 1000000.0;
face_intersect[1].t = 1000000.0;
if (intersect_box (mapvals.scale, lvp, ldir, face_intersect) == TRUE)
{
/* We've hit the box. Transform the hit points and */
/* normals back into the world coordinate system */
/* =============================================== */
for (i = 0; i < 2; i++)
{
vecmulmat (&ns, &face_intersect[i].s, rotmat);
vecmulmat (&nn, &face_intersect[i].n, rotmat);
ns.x = ns.x + mapvals.position.x;
ns.y = ns.y + mapvals.position.y;
ns.z = ns.z + mapvals.position.z;
face_intersect[i].s = ns;
face_intersect[i].n = nn;
}
color = get_box_image_color (face_intersect[0].face,
face_intersect[0].u,
face_intersect[0].v);
/* Check for total transparency... */
/* =============================== */
if (color.a < 1.0)
{
/* Hey, we can see through here! */
/* Lets see what's on the other side.. */
/* =================================== */
color = phong_shade (&face_intersect[0].s,
&mapvals.viewpoint,
&face_intersect[0].n,
&mapvals.lightsource.position,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
gimp_rgb_clamp (&color);
color2 = get_box_image_color (face_intersect[1].face,
face_intersect[1].u,
face_intersect[1].v);
/* Make the normal point inwards */
/* ============================= */
gimp_vector3_mul (&face_intersect[1].n, -1.0);
color2 = phong_shade (&face_intersect[1].s,
&mapvals.viewpoint,
&face_intersect[1].n,
&mapvals.lightsource.position,
&color2,
&mapvals.lightsource.color,
mapvals.lightsource.type);
gimp_rgb_clamp (&color2);
if (mapvals.transparent_background == FALSE && color2.a < 1.0)
{
gimp_rgb_composite (&color2, &background,
GIMP_RGB_COMPOSITE_BEHIND);
}
/* Compute a mix of the first and second colors */
/* ============================================ */
gimp_rgb_composite (&color, &color2, GIMP_RGB_COMPOSITE_NORMAL);
gimp_rgb_clamp (&color);
}
else if (color.a != 0.0 && mapvals.lightsource.type != NO_LIGHT)
{
color = phong_shade (&face_intersect[0].s,
&mapvals.viewpoint,
&face_intersect[0].n,
&mapvals.lightsource.position,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
gimp_rgb_clamp (&color);
}
}
else
{
if (mapvals.transparent_background == TRUE)
gimp_rgb_set_alpha (&color, 0.0);
}
return color;
}
GimpRGB
get_ray_color_sphere (GimpVector3 *pos)
{
GimpRGB color = background;
static GimpRGB color2;
static gint inside = FALSE;
static GimpVector3 normal, ray, spos1, spos2;
static gdouble vx, vy;
/* Check if ray is within the bounding box */
/* ======================================= */
if (pos->x<bx1 || pos->x>bx2 || pos->y<by1 || pos->y>by2)
return color;
/* Construct a line from our VP to the point */
/* ========================================= */
gimp_vector3_sub (&ray, pos, &mapvals.viewpoint);
gimp_vector3_normalize (&ray);
/* Check for intersection. This is a quasi ray-tracer. */
/* =================================================== */
if (sphere_intersect (&ray, &mapvals.viewpoint, &spos1, &spos2) == TRUE)
{
/* Compute spherical to rectangular mapping */
/* ======================================== */
gimp_vector3_sub (&normal, &spos1, &mapvals.position);
gimp_vector3_normalize (&normal);
sphere_to_image (&normal, &vx, &vy);
color = get_image_color (vx, vy, &inside);
/* Check for total transparency... */
/* =============================== */
if (color.a < 1.0)
{
/* Hey, we can see through here! */
/* Lets see what's on the other side.. */
/* =================================== */
color = phong_shade (&spos1,
&mapvals.viewpoint,
&normal,
&mapvals.lightsource.position,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
gimp_rgb_clamp (&color);
gimp_vector3_sub (&normal, &spos2, &mapvals.position);
gimp_vector3_normalize (&normal);
sphere_to_image (&normal, &vx, &vy);
color2 = get_image_color (vx, vy, &inside);
/* Make the normal point inwards */
/* ============================= */
gimp_vector3_mul (&normal, -1.0);
color2 = phong_shade (&spos2,
&mapvals.viewpoint,
&normal,
&mapvals.lightsource.position,
&color2,
&mapvals.lightsource.color,
mapvals.lightsource.type);
gimp_rgb_clamp (&color2);
/* Compute a mix of the first and second colors */
/* ============================================ */
gimp_rgb_composite (&color, &color2, GIMP_RGB_COMPOSITE_NORMAL);
gimp_rgb_clamp (&color);
}
else if (color.a != 0.0 &&
inside == TRUE &&
mapvals.lightsource.type != NO_LIGHT)
{
/* Compute shading at this point */
/* ============================= */
color = phong_shade (&spos1,
&mapvals.viewpoint,
&normal,
&mapvals.lightsource.position,
&color,
&mapvals.lightsource.color,
mapvals.lightsource.type);
gimp_rgb_clamp (&color);
}
}
if (mapvals.transparent_background == FALSE && color.a < 1.0)
{
gimp_rgb_composite (&color, &background,
GIMP_RGB_COMPOSITE_BEHIND);
}
return color;
}
static GimpRGB
phong_shade (GimpVector3 *pos,
GimpVector3 *viewpoint,
GimpVector3 *normal,
GimpVector3 *light,
GimpRGB *diff_col,
GimpRGB *spec_col,
gint type)
{
GimpRGB ambientcolor, diffusecolor, specularcolor;
gdouble NL, RV, dist;
GimpVector3 L, NN, V, N;
/* Compute ambient intensity */
/* ========================= */
N = *normal;
ambientcolor = *diff_col;
gimp_rgb_multiply (&ambientcolor, mapvals.material.ambient_int);
/* Compute (N*L) term of Phong's equation */
/* ====================================== */
if (type == POINT_LIGHT)
gimp_vector3_sub (&L, light, pos);
else
L = *light;
dist = gimp_vector3_length (&L);
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, pos);
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);
/* Compute diffuse and specular intensity contribution */
/* =================================================== */
diffusecolor = *diff_col;
gimp_rgb_multiply (&diffusecolor, mapvals.material.diffuse_ref);
gimp_rgb_multiply (&diffusecolor, NL);
specularcolor = *spec_col;
gimp_rgb_multiply (&specularcolor, mapvals.material.specular_ref);
gimp_rgb_multiply (&specularcolor, RV);
gimp_rgb_add (&diffusecolor, &specularcolor);
gimp_rgb_multiply (&diffusecolor, mapvals.material.diffuse_int);
gimp_rgb_clamp (&diffusecolor);
gimp_rgb_add (&ambientcolor, &diffusecolor);
}
return ambientcolor;
}
static gboolean
intersect_cylinder (GimpVector3 vp,
GimpVector3 dir,
FaceIntersectInfo *face_intersect)
{
gdouble a, b, c, d, e, f, tmp, l;
gboolean result = FALSE;
gint i;
#define sqr(a) (a*a)
a = sqr (dir.x) + sqr (dir.z);
b = 2.0 * (vp.x * dir.x + vp.z * dir.z);
c = sqr (vp.x) + sqr (vp.z) - sqr (mapvals.cylinder_radius);
d = sqr (b) - 4.0 * a * c;
if (d >= 0.0)
{
e = sqrt (d);
f = 2.0 * a;
if (f != 0.0)
{
result = TRUE;
face_intersect[0].t = (-b+e)/f;
face_intersect[1].t = (-b-e)/f;
if (face_intersect[0].t>face_intersect[1].t)
{
tmp = face_intersect[0].t;
face_intersect[0].t = face_intersect[1].t;
face_intersect[1].t = tmp;
}
for (i = 0; i < 2; i++)
{
face_intersect[i].s.x = vp.x + face_intersect[i].t * dir.x;
face_intersect[i].s.y = vp.y + face_intersect[i].t * dir.y;
face_intersect[i].s.z = vp.z + face_intersect[i].t * dir.z;
face_intersect[i].n = face_intersect[i].s;
face_intersect[i].n.y = 0.0;
gimp_vector3_normalize(&face_intersect[i].n);
l = mapvals.cylinder_length/2.0;
face_intersect[i].u = (atan2(face_intersect[i].s.x,face_intersect[i].s.z)+G_PI)/(2.0*G_PI);
face_intersect[i].v = (face_intersect[i].s.y+l)/mapvals.cylinder_length;
/* Mark hitpoint as on the cylinder hull */
/* ===================================== */
face_intersect[i].face = 0;
/* Check if we're completely off the cylinder axis */
/* =============================================== */
if (face_intersect[i].s.y>l || face_intersect[i].s.y<-l)
{
/* Check if we've hit a cap */
/* ======================== */
if (face_intersect[i].s.y>l)
{
if (intersect_circle(vp,dir,l,&face_intersect[i])==FALSE)
result = FALSE;
else
{
face_intersect[i].face = 2;
face_intersect[i].v = 1 - face_intersect[i].v;
gimp_vector3_set(&face_intersect[i].n, 0.0, 1.0, 0.0);
}
}
else
{
if (intersect_circle(vp,dir,-l,&face_intersect[i])==FALSE)
result = FALSE;
else
{
face_intersect[i].face = 1;
gimp_vector3_set(&face_intersect[i].n, 0.0, -1.0, 0.0);
}
}
}
}
}
}
#undef sqr
return result;
}
static void
draw_wireframe_plane (gint startx,
gint starty,
gint pw,
gint ph)
{
GimpVector3 v1, v2, a, b, c, d, dir1, dir2;
gint cnt, n = 0;
gdouble x1, y1, x2, y2, cx1, cy1, cx2, cy2, fac;
/* Find rotated box corners */
/* ======================== */
gimp_vector3_set (&v1, 0.5, 0.0, 0.0);
gimp_vector3_set (&v2, 0.0, 0.5, 0.0);
gimp_vector3_rotate (&v1,
gimp_deg_to_rad (mapvals.alpha),
gimp_deg_to_rad (mapvals.beta),
gimp_deg_to_rad (mapvals.gamma));
gimp_vector3_rotate (&v2,
gimp_deg_to_rad (mapvals.alpha),
gimp_deg_to_rad (mapvals.beta),
gimp_deg_to_rad (mapvals.gamma));
dir1 = v1; gimp_vector3_normalize (&dir1);
dir2 = v2; gimp_vector3_normalize (&dir2);
fac = 1.0 / (gdouble) WIRESIZE;
gimp_vector3_mul (&dir1, fac);
gimp_vector3_mul (&dir2, fac);
gimp_vector3_add (&a, &mapvals.position, &v1);
gimp_vector3_sub (&b, &a, &v2);
gimp_vector3_add (&a, &a, &v2);
gimp_vector3_sub (&d, &mapvals.position, &v1);
gimp_vector3_sub (&d, &d, &v2);
c = b;
cx1 = (gdouble) startx;
cy1 = (gdouble) starty;
cx2 = cx1 + (gdouble) pw;
cy2 = cy1 + (gdouble) ph;
for (cnt = 0; cnt <= WIRESIZE; cnt++)
{
gimp_vector_3d_to_2d (startx, starty, pw, ph,
&x1, &y1, &mapvals.viewpoint, &a);
gimp_vector_3d_to_2d (startx, starty, pw, ph,
&x2, &y2, &mapvals.viewpoint, &b);
if (clip_line (&x1, &y1, &x2, &y2, cx1, cy1, cx2, cy2) == TRUE)
{
linetab[n].x1 = RINT (x1);
linetab[n].y1 = RINT (y1);
linetab[n].x2 = RINT (x2);
linetab[n].y2 = RINT (y2);
linetab[n].linewidth = 1;
linetab[n].linestyle = GDK_LINE_SOLID;
gdk_gc_set_line_attributes (gc,
linetab[n].linewidth,
linetab[n].linestyle,
GDK_CAP_NOT_LAST,
GDK_JOIN_MITER);
gdk_draw_line (previewarea->window, gc,
linetab[n].x1, linetab[n].y1,
linetab[n].x2, linetab[n].y2);
n++;
}
gimp_vector_3d_to_2d (startx, starty, pw, ph,
&x1, &y1, &mapvals.viewpoint, &c);
gimp_vector_3d_to_2d (startx, starty, pw, ph,
&x2, &y2, &mapvals.viewpoint, &d);
if (clip_line (&x1, &y1, &x2, &y2, cx1, cy1, cx2, cy2) == TRUE)
{
linetab[n].x1 = RINT (x1);
linetab[n].y1 = RINT (y1);
linetab[n].x2 = RINT (x2);
linetab[n].y2 = RINT (y2);
linetab[n].linewidth = 1;
linetab[n].linestyle = GDK_LINE_SOLID;
gdk_gc_set_line_attributes (gc,
linetab[n].linewidth,
linetab[n].linestyle,
GDK_CAP_NOT_LAST,
GDK_JOIN_MITER);
gdk_draw_line (previewarea->window, gc,
linetab[n].x1, linetab[n].y1,
linetab[n].x2, linetab[n].y2);
n++;
}
gimp_vector3_sub (&a, &a, &dir1);
gimp_vector3_sub (&b, &b, &dir1);
gimp_vector3_add (&c, &c, &dir2);
gimp_vector3_add (&d, &d, &dir2);
}
/* Mark end of lines */
/* ================= */
linetab[n].x1 = -1;
}
GimpRGB
get_ray_color_no_bilinear_ref (GimpVector3 *position)
{
GimpRGB color_sum;
GimpRGB color_int;
GimpRGB light_color;
GimpRGB color, env_color;
gint x;
gdouble xf, yf;
GimpVector3 normal, *p, v, r;
gint k;
gdouble tmpval;
pos_to_float (position->x, position->y, &xf, &yf);
x = RINT (xf);
if (mapvals.bump_mapped == FALSE || mapvals.bumpmap_id == -1)
normal = mapvals.planenormal;
else
normal = vertex_normals[1][(gint) RINT (xf)];
gimp_vector3_normalize (&normal);
if (mapvals.transparent_background && heights[1][x] == 0)
{
gimp_rgb_set_alpha (&color_sum, 0.0);
}
else
{
color = peek (RINT (xf), RINT (yf));
color_sum = color;
gimp_rgb_multiply (&color_sum, mapvals.material.ambient_int);
for (k = 0; k < NUM_LIGHTS; k++)
{
p = &mapvals.lightsource[k].direction;
if (!mapvals.lightsource[k].active
|| mapvals.lightsource[k].type == NO_LIGHT)
continue;
else if (mapvals.lightsource[k].type == POINT_LIGHT)
p = &mapvals.lightsource[k].position;
color_int = mapvals.lightsource[k].color;
gimp_rgb_multiply (&color_int, mapvals.lightsource[k].intensity);
light_color = phong_shade (position,
&mapvals.viewpoint,
&normal,
p,
&color,
&color_int,
mapvals.lightsource[0].type);
}
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 (RINT (env_width * xf),
RINT (env_height * yf));
tmpval = mapvals.material.diffuse_int;
mapvals.material.diffuse_int = 0.;
light_color = phong_shade (position,
&mapvals.viewpoint,
&normal,
&r,
&color,
&env_color,
DIRECTIONAL_LIGHT);
mapvals.material.diffuse_int = tmpval;
gimp_rgb_add (&color_sum, &light_color);
}
gimp_rgb_clamp (&color_sum);
return color_sum;
}
static GimpRGB
phong_shade (GimpVector3 *position,
GimpVector3 *viewpoint,
GimpVector3 *normal,
GimpVector3 *lightposition,
GimpRGB *diff_col,
GimpRGB *light_col,
LightType light_type)
{
GimpRGB diffuse_color, specular_color;
gdouble nl, rv, dist;
GimpVector3 l, v, n, lnormal, h;
/* Compute ambient intensity */
/* ========================= */
n = *normal;
/* Compute (N*L) term of Phong's equation */
/* ====================================== */
if (light_type == POINT_LIGHT)
gimp_vector3_sub (&l, lightposition, position);
else
{
l = *lightposition;
gimp_vector3_normalize (&l);
}
dist = gimp_vector3_length (&l);
if (dist != 0.0)
gimp_vector3_mul (&l, 1.0 / dist);
nl = MAX (0., 2.0 * gimp_vector3_inner_product (&n, &l));
lnormal = l;
gimp_vector3_normalize (&lnormal);
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_add (&h, &lnormal, &v);
gimp_vector3_normalize (&h);
rv = MAX (0.01, gimp_vector3_inner_product (&n, &h));
rv = pow (rv, mapvals.material.highlight);
rv *= nl;
/* Compute diffuse and specular intensity contribution */
/* =================================================== */
diffuse_color = *light_col;
gimp_rgb_multiply (&diffuse_color, mapvals.material.diffuse_int);
diffuse_color.r *= diff_col->r;
diffuse_color.g *= diff_col->g;
diffuse_color.b *= diff_col->b;
gimp_rgb_multiply (&diffuse_color, nl);
specular_color = *light_col;
if (mapvals.material.metallic) /* for metals, specular color = diffuse color */
{
specular_color.r *= diff_col->r;
specular_color.g *= diff_col->g;
specular_color.b *= diff_col->b;
}
gimp_rgb_multiply (&specular_color, mapvals.material.specular_ref);
gimp_rgb_multiply (&specular_color, rv);
gimp_rgb_add (&diffuse_color, &specular_color);
gimp_rgb_clamp (&diffuse_color);
}
gimp_rgb_clamp (&diffuse_color);
return diffuse_color;
}
void
precompute_normals (gint x1,
gint x2,
gint y)
{
GimpVector3 *tmpv, p1, p2, p3, normal;
gdouble *tmpd;
gint n, i, nv;
guchar *map = NULL;
gint bpp = 1;
guchar mapval;
/* First, compute the heights */
/* ========================== */
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;
if (mapvals.bumpmap_id != -1)
{
bpp = gimp_drawable_bpp(mapvals.bumpmap_id);
}
gimp_pixel_rgn_get_row (&bump_region, bumprow, x1, y, x2 - x1);
if (mapvals.bumpmaptype > 0)
{
switch (mapvals.bumpmaptype)
{
case 1:
map = logmap;
break;
case 2:
map = sinemap;
break;
default:
map = spheremap;
break;
}
for (n = 0; n < (x2 - x1); n++)
{
if (bpp>1)
{
mapval = (guchar)((float)((bumprow[n * bpp] +bumprow[n * bpp +1] + bumprow[n * bpp + 2])/3.0 )) ;
}
else
{
mapval = bumprow[n * bpp];
}
heights[2][n] = (gdouble) mapvals.bumpmax * (gdouble) map[mapval] / 255.0;
}
}
else
{
for (n = 0; n < (x2 - x1); n++)
{
if (bpp>1)
{
mapval = (guchar)((float)((bumprow[n * bpp] +bumprow[n * bpp +1] + bumprow[n * bpp + 2])/3.0 )) ;
}
else
{
mapval = bumprow[n * bpp];
}
heights[2][n] = (gdouble) mapvals.bumpmax * (gdouble) mapval / 255.0;
}
}
/* Compute triangle normals */
/* ======================== */
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];
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++)
{
nv = 0;
if (n > 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;
}
if (y < pre_h)
{
gimp_vector3_add (&normal, &normal, &triangle_normals[1][i-1]);
nv++;
}
}
if (n <pre_w)
{
if (y > 0)
{
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)
{
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;
}
}
/* Interpol linearly height[2] and triangle_normals[1]
* using the next row
*/
void
interpol_row (gint x1,
gint x2,
gint y)
{
GimpVector3 p1, p2, p3;
gint n, i;
guchar *map = NULL;
gint bpp = 1;
guchar* bumprow1 = NULL;
guchar* bumprow2 = NULL;
if (mapvals.bumpmap_id != -1)
{
bpp = gimp_drawable_bpp(mapvals.bumpmap_id);
}
bumprow1 = g_new (guchar, pre_w * bpp);
bumprow2 = g_new (guchar, pre_w * bpp);
gimp_pixel_rgn_get_row (&bump_region, bumprow1, x1, y, x2 - x1);
gimp_pixel_rgn_get_row (&bump_region, bumprow2, x1, y+1, x2 - x1);
if (mapvals.bumpmaptype > 0)
{
switch (mapvals.bumpmaptype)
{
case 1:
map = logmap;
break;
case 2:
map = sinemap;
break;
default:
map = spheremap;
break;
}
}
for (n = 0; n < (x2 - x1); n++)
{
gdouble diff;
guchar mapval;
guchar mapval1, mapval2;
if (bpp>1)
{
mapval1 = (guchar)((float)((bumprow1[n * bpp] +bumprow1[n * bpp +1] + bumprow1[n * bpp + 2])/3.0 )) ;
mapval2 = (guchar)((float)((bumprow2[n * bpp] +bumprow2[n * bpp +1] + bumprow2[n * bpp + 2])/3.0 )) ;
}
else
{
mapval1 = bumprow1[n * bpp];
mapval2 = bumprow2[n * bpp];
}
diff = mapval1 - mapval2;
mapval = (guchar) CLAMP (mapval1 + diff, 0.0, 255.0);
if (mapvals.bumpmaptype > 0)
{
heights[1][n] = (gdouble) mapvals.bumpmax * (gdouble) map[mapval1] / 255.0;
heights[2][n] = (gdouble) mapvals.bumpmax * (gdouble) map[mapval] / 255.0;
}
else
{
heights[1][n] = (gdouble) mapvals.bumpmax * (gdouble) mapval1 / 255.0;
heights[2][n] = (gdouble) mapvals.bumpmax * (gdouble) mapval / 255.0;
}
}
i = 0;
for (n = 0; n < (x2 - x1 - 1); n++)
{
/* heights rows 1 and 2 are inverted */
p1.x = 0.0;
p1.y = ystep;
p1.z = heights[1][n] - heights[2][n];
p2.x = xstep;
p2.y = ystep;
p2.z = heights[1][n+1] - heights[2][n];
p3.x = xstep;
p3.y = 0.0;
p3.z = heights[2][n+1] - heights[2][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;
}
g_free (bumprow1);
g_free (bumprow2);
}