Adding upstream version 2.10.36.upstream/2.10.36

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1254 insertions, 0 deletions

diff --git a/plug-ins/map-object/map-object-shade.c b/plug-ins/map-object/map-object-shade.c
new file mode 100644
index 0000000..f91345b
--- /dev/null
+++ b/plug-ins/map-object/map-object-shade.c
@@ -0,0 +1,1254 @@
+/*****************/
+/* Shading stuff */
+/*****************/
+
+#include "config.h"
+
+#include <string.h>
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "map-object-apply.h"
+#include "map-object-main.h"
+#include "map-object-image.h"
+#include "map-object-shade.h"
+
+
+static gdouble     bx1, by1, bx2, by2;
+get_ray_color_func get_ray_color;
+
+typedef struct
+{
+  gdouble     u, v;
+  gdouble     t;
+  GimpVector3 s;
+  GimpVector3 n;
+  gint        face;
+} FaceIntersectInfo;
+
+/*****************/
+/* Phong shading */
+/*****************/
+
+static GimpRGB
+phong_shade (GimpVector3 *pos,
+             GimpVector3 *viewpoint,
+             GimpVector3 *normal,
+             GimpRGB     *diff_col,
+             GimpRGB     *spec_col,
+             LightType    type)
+{
+  GimpRGB       ambientcolor, diffusecolor, specularcolor;
+  gdouble      NL, RV, dist;
+  GimpVector3  L, NN, V, N;
+  GimpVector3  *light;
+
+  light = mapvals.lightsource.type == DIRECTIONAL_LIGHT
+    ? &mapvals.lightsource.direction
+    : &mapvals.lightsource.position,
+
+  /* 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 = 0.0 < RV ? pow (RV, mapvals.material.highlight) : 0.0;
+
+      /* 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 gint
+plane_intersect (GimpVector3 *dir,
+                 GimpVector3 *viewp,
+                 GimpVector3 *ipos,
+                 gdouble     *u,
+                 gdouble     *v)
+{
+  static gdouble det, det1, det2, det3, t;
+
+  imat[0][0] = dir->x;
+  imat[1][0] = dir->y;
+  imat[2][0] = dir->z;
+
+  /* Compute determinant of the first 3x3 sub matrix (denominator) */
+  /* ============================================================= */
+
+  det = (imat[0][0] * imat[1][1] * imat[2][2] +
+         imat[0][1] * imat[1][2] * imat[2][0] +
+         imat[0][2] * imat[1][0] * imat[2][1] -
+         imat[0][2] * imat[1][1] * imat[2][0] -
+         imat[0][0] * imat[1][2] * imat[2][1] -
+         imat[2][2] * imat[0][1] * imat[1][0]);
+
+  /* If the determinant is non-zero, a intersection point exists */
+  /* =========================================================== */
+
+  if (det != 0.0)
+    {
+      /* Now, lets compute the numerator determinants (wow ;) */
+      /* ==================================================== */
+
+      det1 = (imat[0][3] * imat[1][1] * imat[2][2] +
+              imat[0][1] * imat[1][2] * imat[2][3] +
+              imat[0][2] * imat[1][3] * imat[2][1] -
+              imat[0][2] * imat[1][1] * imat[2][3] -
+              imat[1][2] * imat[2][1] * imat[0][3] -
+              imat[2][2] * imat[0][1] * imat[1][3]);
+
+      det2 = (imat[0][0] * imat[1][3] * imat[2][2] +
+              imat[0][3] * imat[1][2] * imat[2][0] +
+              imat[0][2] * imat[1][0] * imat[2][3] -
+              imat[0][2] * imat[1][3] * imat[2][0] -
+              imat[1][2] * imat[2][3] * imat[0][0] -
+              imat[2][2] * imat[0][3] * imat[1][0]);
+
+      det3 = (imat[0][0] * imat[1][1] * imat[2][3] +
+              imat[0][1] * imat[1][3] * imat[2][0] +
+              imat[0][3] * imat[1][0] * imat[2][1] -
+              imat[0][3] * imat[1][1] * imat[2][0] -
+              imat[1][3] * imat[2][1] * imat[0][0] -
+              imat[2][3] * imat[0][1] * imat[1][0]);
+
+      /* Now we have the simultaneous solutions. Lets compute the unknowns */
+      /* (skip u&v if t is <0, this means the intersection is behind us)  */
+      /* ================================================================ */
+
+      t = det1 / det;
+
+      if (t > 0.0)
+        {
+          *u = 1.0 + ((det2 / det) - 0.5);
+          *v = 1.0 + ((det3 / det) - 0.5);
+
+                ipos->x = viewp->x + t * dir->x;
+          ipos->y = viewp->y + t * dir->y;
+          ipos->z = viewp->z + t * dir->z;
+
+          return TRUE;
+        }
+    }
+
+  return FALSE;
+}
+
+/*****************************************************************************
+ * These routines computes the color of the surface
+ * of the plane at a given point
+ *****************************************************************************/
+
+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,
+                               &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;
+}
+
+/***********************************************************************/
+/* Given the NorthPole, Equator and a third vector (normal) compute    */
+/* the conversion from spherical oordinates to image space coordinates */
+/***********************************************************************/
+
+static void
+sphere_to_image (GimpVector3 *normal,
+                 gdouble     *u,
+                 gdouble     *v)
+{
+  static gdouble      alpha, fac;
+  static GimpVector3  cross_prod;
+
+  alpha = acos (-gimp_vector3_inner_product (&mapvals.secondaxis, normal));
+
+  *v = alpha / G_PI;
+
+  if (*v == 0.0 || *v == 1.0)
+    {
+      *u = 0.0;
+    }
+  else
+    {
+      fac = (gimp_vector3_inner_product (&mapvals.firstaxis, normal) /
+             sin (alpha));
+
+      /* Make sure that we map to -1.0..1.0 (take care of rounding errors) */
+      /* ================================================================= */
+
+      fac = CLAMP (fac, -1.0, 1.0);
+
+      *u = acos (fac) / (2.0 * G_PI);
+
+      cross_prod = gimp_vector3_cross_product (&mapvals.secondaxis,
+                                               &mapvals.firstaxis);
+
+      if (gimp_vector3_inner_product (&cross_prod, normal) < 0.0)
+        *u = 1.0 - *u;
+    }
+}
+
+/***************************************************/
+/* Compute intersection point with sphere (if any) */
+/***************************************************/
+
+static gint
+sphere_intersect (GimpVector3 *dir,
+                  GimpVector3 *viewp,
+                  GimpVector3 *spos1,
+                  GimpVector3 *spos2)
+{
+  static gdouble      alpha, beta, tau, s1, s2, tmp;
+  static GimpVector3  t;
+
+  gimp_vector3_sub (&t, &mapvals.position, viewp);
+
+  alpha = gimp_vector3_inner_product (dir, &t);
+  beta  = gimp_vector3_inner_product (&t, &t);
+
+  tau = alpha * alpha - beta + mapvals.radius * mapvals.radius;
+
+  if (tau >= 0.0)
+    {
+      tau = sqrt (tau);
+      s1 = alpha + tau;
+      s2 = alpha - tau;
+
+      if (s2 < s1)
+        {
+          tmp = s1;
+          s1 = s2;
+          s2 = tmp;
+        }
+
+      spos1->x = viewp->x + s1 * dir->x;
+      spos1->y = viewp->y + s1 * dir->y;
+      spos1->z = viewp->z + s1 * dir->z;
+      spos2->x = viewp->x + s2 * dir->x;
+      spos2->y = viewp->y + s2 * dir->y;
+      spos2->z = viewp->z + s2 * dir->z;
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+/*****************************************************************************
+ * These routines computes the color of the surface
+ * of the sphere at a given point
+ *****************************************************************************/
+
+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,
+                               &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,
+                                &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,
+                               &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;
+}
+
+/***************************************************/
+/* Transform the corners of the bounding box to 2D */
+/***************************************************/
+
+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;
+}
+
+/* These two were taken from the Mesa source. Mesa is written   */
+/* and is (C) by Brian Paul. vecmulmat() performs a post-mul by */
+/* a 4x4 matrix to a 1x4(3) vector. rotmat() creates a matrix   */
+/* that by post-mul will rotate a 1x4(3) vector the given angle */
+/* about the given axis.                                        */
+/* ============================================================ */
+
+void
+vecmulmat (GimpVector3 *u,
+           GimpVector3 *v,
+           gfloat       m[16])
+{
+  gfloat v0=v->x, v1=v->y, v2=v->z;
+#define M(row,col)  m[col*4+row]
+  u->x = v0 * M(0,0) + v1 * M(1,0) + v2 * M(2,0) + M(3,0);
+  u->y = v0 * M(0,1) + v1 * M(1,1) + v2 * M(2,1) + M(3,1);
+  u->z = v0 * M(0,2) + v1 * M(1,2) + v2 * M(2,2) + M(3,2);
+#undef M
+}
+
+void
+rotatemat (gfloat       angle,
+           GimpVector3 *v,
+           gfloat       m[16])
+{
+  /* This function contributed by Erich Boleyn (erich@uruk.org) */
+  gfloat mag, s, c;
+  gfloat xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c;
+  gfloat IdentityMat[16];
+  gint   cnt;
+
+  s = sin (angle * (G_PI / 180.0));
+  c = cos (angle * (G_PI / 180.0));
+
+  mag = sqrt (v->x*v->x + v->y*v->y + v->z*v->z);
+
+  if (mag == 0.0)
+    {
+      /* generate an identity matrix and return */
+
+      for (cnt = 0; cnt < 16; cnt++)
+        IdentityMat[cnt] = 0.0;
+
+      IdentityMat[0]  = 1.0;
+      IdentityMat[5]  = 1.0;
+      IdentityMat[10] = 1.0;
+      IdentityMat[15] = 1.0;
+
+      memcpy (m, IdentityMat, sizeof (gfloat) * 16);
+      return;
+   }
+
+  v->x /= mag;
+  v->y /= mag;
+  v->z /= mag;
+
+#define M(row,col)  m[col*4+row]
+
+  xx = v->x * v->x;
+  yy = v->y * v->y;
+  zz = v->z * v->z;
+  xy = v->x * v->y;
+  yz = v->y * v->z;
+  zx = v->z * v->x;
+  xs = v->x * s;
+  ys = v->y * s;
+  zs = v->z * s;
+  one_c = 1.0F - c;
+
+  M(0,0) = (one_c * xx) + c;
+  M(0,1) = (one_c * xy) - zs;
+  M(0,2) = (one_c * zx) + ys;
+  M(0,3) = 0.0F;
+
+  M(1,0) = (one_c * xy) + zs;
+  M(1,1) = (one_c * yy) + c;
+  M(1,2) = (one_c * yz) - xs;
+  M(1,3) = 0.0F;
+
+  M(2,0) = (one_c * zx) - ys;
+  M(2,1) = (one_c * yz) + xs;
+  M(2,2) = (one_c * zz) + c;
+  M(2,3) = 0.0F;
+
+  M(3,0) = 0.0F;
+  M(3,1) = 0.0F;
+  M(3,2) = 0.0F;
+  M(3,3) = 1.0F;
+
+#undef M
+}
+
+/* Transpose the matrix m. If m is orthogonal (like a rotation matrix), */
+/* this is equal to the inverse of the matrix.                          */
+/* ==================================================================== */
+
+void
+transpose_mat (gfloat m[16])
+{
+  gint    i, j;
+  gfloat  t;
+
+  for (i = 0; i < 4; i++)
+    {
+      for (j = 0; j < i; j++)
+        {
+          t = m[j*4+i];
+          m[j*4+i] = m[i*4+j];
+          m[i*4+j] = t;
+        }
+    }
+}
+
+/* Compute the matrix product c=a*b */
+/* ================================ */
+
+void
+matmul (gfloat a[16],
+        gfloat b[16],
+        gfloat c[16])
+{
+  gint   i, j, k;
+  gfloat value;
+
+#define A(row,col)  a[col*4+row]
+#define B(row,col)  b[col*4+row]
+#define C(row,col)  c[col*4+row]
+
+  for (i = 0; i < 4; i++)
+    {
+      for (j = 0; j < 4; j++)
+        {
+          value = 0.0;
+
+          for (k = 0; k < 4; k++)
+            value += A(i,k) * B(k,j);
+
+          C(i,j) = value;
+        }
+    }
+
+#undef A
+#undef B
+#undef C
+}
+
+void
+ident_mat (gfloat m[16])
+{
+  gint  i, j;
+
+#define M(row,col)  m[col*4+row]
+
+  for (i = 0; i < 4; i++)
+    {
+      for (j = 0; j < 4; j++)
+        {
+          if (i == j)
+            M(i,j) = 1.0;
+          else
+            M(i,j) = 0.0;
+        }
+    }
+
+#undef M
+}
+
+static gboolean
+intersect_rect (gdouble            u,
+                gdouble            v,
+                gdouble            w,
+                GimpVector3        viewp,
+                GimpVector3        dir,
+                FaceIntersectInfo *face_info)
+{
+  gboolean result = FALSE;
+  gdouble  u2, v2;
+
+  if (dir.z!=0.0)
+    {
+      u2 = u / 2.0;
+      v2 = v / 2.0;
+
+      face_info->t = (w-viewp.z) / dir.z;
+      face_info->s.x = viewp.x + face_info->t * dir.x;
+      face_info->s.y = viewp.y + face_info->t * dir.y;
+      face_info->s.z = w;
+
+      if (face_info->s.x >= -u2 && face_info->s.x <= u2 &&
+          face_info->s.y >= -v2 && face_info->s.y <= v2)
+        {
+          face_info->u = (face_info->s.x + u2) / u;
+          face_info->v = (face_info->s.y + v2) / v;
+          result = TRUE;
+        }
+    }
+
+  return result;
+}
+
+static gboolean
+intersect_box (GimpVector3        scale,
+               GimpVector3        viewp,
+               GimpVector3        dir,
+               FaceIntersectInfo *face_intersect)
+{
+  GimpVector3        v, d, tmp, axis[3];
+  FaceIntersectInfo  face_tmp;
+  gboolean           result = FALSE;
+  gfloat             m[16];
+  gint               i = 0;
+
+  gimp_vector3_set (&axis[0], 1.0, 0.0, 0.0);
+  gimp_vector3_set (&axis[1], 0.0, 1.0, 0.0);
+  gimp_vector3_set (&axis[2], 0.0, 0.0, 1.0);
+
+  /* Front side */
+  /* ========== */
+
+  if (intersect_rect (scale.x, scale.y, scale.z / 2.0,
+                      viewp, dir, &face_intersect[i]) == TRUE)
+    {
+      face_intersect[i].face = 0;
+      gimp_vector3_set (&face_intersect[i++].n, 0.0, 0.0, 1.0);
+      result = TRUE;
+    }
+
+  /* Back side */
+  /* ========= */
+
+  if (intersect_rect (scale.x, scale.y, -scale.z / 2.0,
+                      viewp, dir, &face_intersect[i]) == TRUE)
+    {
+      face_intersect[i].face = 1;
+      face_intersect[i].u = 1.0 - face_intersect[i].u;
+      gimp_vector3_set (&face_intersect[i++].n, 0.0, 0.0, -1.0);
+      result = TRUE;
+    }
+
+  /* Check if we've found the two possible intersection points */
+  /* ========================================================= */
+
+  if (i < 2)
+    {
+      /* Top: Rotate viewpoint and direction into rectangle's local coordinate system */
+      /* ============================================================================ */
+
+      rotatemat (90, &axis[0], m);
+      vecmulmat (&v, &viewp, m);
+      vecmulmat (&d, &dir, m);
+
+      if (intersect_rect (scale.x, scale.z, scale.y / 2.0,
+                          v, d, &face_intersect[i]) == TRUE)
+        {
+          face_intersect[i].face = 2;
+
+          transpose_mat (m);
+          vecmulmat(&tmp, &face_intersect[i].s, m);
+          face_intersect[i].s = tmp;
+
+          gimp_vector3_set (&face_intersect[i++].n, 0.0, -1.0, 0.0);
+          result = TRUE;
+        }
+    }
+
+  /* Check if we've found the two possible intersection points */
+  /* ========================================================= */
+
+  if (i < 2)
+    {
+      /* Bottom: Rotate viewpoint and direction into rectangle's local coordinate system */
+      /* =============================================================================== */
+
+      rotatemat (90, &axis[0], m);
+      vecmulmat (&v, &viewp, m);
+      vecmulmat (&d, &dir, m);
+
+      if (intersect_rect (scale.x, scale.z, -scale.y / 2.0,
+                          v, d, &face_intersect[i]) == TRUE)
+        {
+          face_intersect[i].face = 3;
+
+          transpose_mat (m);
+
+          vecmulmat (&tmp, &face_intersect[i].s, m);
+          face_intersect[i].s = tmp;
+
+          face_intersect[i].v = 1.0 - face_intersect[i].v;
+
+          gimp_vector3_set (&face_intersect[i++].n, 0.0, 1.0, 0.0);
+
+          result = TRUE;
+        }
+    }
+
+  /* Check if we've found the two possible intersection points */
+  /* ========================================================= */
+
+  if (i < 2)
+    {
+      /* Left side: Rotate viewpoint and direction into rectangle's local coordinate system */
+      /* ================================================================================== */
+
+      rotatemat (90, &axis[1], m);
+      vecmulmat (&v, &viewp, m);
+      vecmulmat (&d, &dir, m);
+
+      if (intersect_rect (scale.z, scale.y, scale.x / 2.0,
+                          v, d, &face_intersect[i]) == TRUE)
+        {
+          face_intersect[i].face = 4;
+
+          transpose_mat (m);
+          vecmulmat (&tmp, &face_intersect[i].s, m);
+          face_intersect[i].s = tmp;
+
+          gimp_vector3_set (&face_intersect[i++].n, 1.0, 0.0, 0.0);
+          result = TRUE;
+        }
+    }
+
+  /* Check if we've found the two possible intersection points */
+  /* ========================================================= */
+
+  if (i < 2)
+    {
+      /* Right side: Rotate viewpoint and direction into rectangle's local coordinate system */
+      /* =================================================================================== */
+
+      rotatemat (90, &axis[1], m);
+      vecmulmat (&v, &viewp, m);
+      vecmulmat (&d, &dir, m);
+
+      if (intersect_rect (scale.z, scale.y, -scale.x / 2.0,
+                          v, d, &face_intersect[i]) == TRUE)
+        {
+          face_intersect[i].face = 5;
+
+          transpose_mat (m);
+          vecmulmat (&tmp, &face_intersect[i].s, m);
+
+          face_intersect[i].u = 1.0 - face_intersect[i].u;
+
+          gimp_vector3_set (&face_intersect[i++].n, -1.0, 0.0, 0.0);
+          result = TRUE;
+        }
+    }
+
+  /* Sort intersection points */
+  /* ======================== */
+
+  if (face_intersect[0].t > face_intersect[1].t)
+    {
+      face_tmp = face_intersect[0];
+      face_intersect[0] = face_intersect[1];
+      face_intersect[1] = face_tmp;
+    }
+
+  return result;
+}
+
+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,
+                               &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,
+                                &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,
+                               &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;
+}
+
+static gboolean
+intersect_circle (GimpVector3        vp,
+                  GimpVector3        dir,
+                  gdouble            w,
+                  FaceIntersectInfo *face_info)
+{
+  gboolean result = FALSE;
+  gdouble  r, d;
+
+#define sqr(a) (a*a)
+
+  if (dir.y != 0.0)
+    {
+      face_info->t = (w-vp.y)/dir.y;
+      face_info->s.x = vp.x + face_info->t*dir.x;
+      face_info->s.y = w;
+      face_info->s.z = vp.z + face_info->t*dir.z;
+
+      r = sqrt (sqr (face_info->s.x) + sqr (face_info->s.z));
+
+      if (r <= mapvals.cylinder_radius)
+        {
+          d = 2.0 * mapvals.cylinder_radius;
+          face_info->u = (face_info->s.x + mapvals.cylinder_radius) / d;
+          face_info->v = (face_info->s.z + mapvals.cylinder_radius) / d;
+          result = TRUE;
+        }
+    }
+
+#undef sqr
+
+  return result;
+}
+
+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 GimpRGB
+get_cylinder_color (gint    face,
+                    gdouble u,
+                    gdouble v)
+{
+  GimpRGB  color;
+  gint    inside;
+
+  if (face == 0)
+    color = get_image_color (u, v, &inside);
+  else
+    color = get_cylinder_image_color (face - 1, u, v);
+
+  return color;
+}
+
+GimpRGB
+get_ray_color_cylinder (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;
+
+  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);
+
+  if (intersect_cylinder (lvp, ldir, face_intersect) == TRUE)
+    {
+      /* We've hit the cylinder. 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_cylinder_color (face_intersect[0].face,
+                                  face_intersect[0].u,
+                                  face_intersect[0].v);
+
+      /* Check for 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,
+                               &color,
+                               &mapvals.lightsource.color,
+                               mapvals.lightsource.type);
+
+          gimp_rgb_clamp (&color);
+
+          color2 = get_cylinder_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,
+                                &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,
+                               &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;
+}