surface.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <iostream>
#include <math.h>

#include <archon/util/color.H>
#include <archon/util/image.H>

#include "surface.H"

namespace Archon
{
  using namespace Utilities;
  using namespace Math;

  namespace Raytracer
  {
    ColorRGBA Surface::shade(const Light &light, const Vector3 &normal,
                             const Vector3 &viewDirection, const Vector3 &lightDirection,
                             const ColorRGBA &surfaceColor) const
    {
      /*
       * Note: Phongs transmission term is not regarded.
       */
      Vector3 h = lightDirection;
      h += viewDirection;
      h /= 2;

      const double f = diffuseReflection * dot(lightDirection, normal);
      const double s = specularReflection * pow(dot(normal, h), reflectiveExponent);

      return Vector3(light.getColor()[0] * surfaceColor[0] * f + s,
                     light.getColor()[1] * surfaceColor[1] * f + s,
                     light.getColor()[2] * surfaceColor[2] * f + s);
    }

    inline int modulo(int x, int y)
    {
      const int v = x % y;
      return v < 0 ? v + y : v;
    }

    void Texture::getColor(const Vector2 &texturePoint, ColorRGBA &c) const
    {
      const int tileWidth  = image.getWidth();
      const int tileHeight = image.getHeight();

      const int width  = tileWidth  * horizontalTiles;
      const int height = tileHeight * verticalTiles;

      const double x = width  * texturePoint[0] - 0.5;
      const double y = height * texturePoint[1] - 0.5;

      // Determine indices of upper left pixel of releval 2x2 pixel box.
      const int xi = static_cast<int>(floor(x));
      const int yi = static_cast<int>(floor(y));

      const int x0 = modulo(xi, tileWidth);
      const int x1 = (x0 + 1) % tileWidth;
      const int y0 = modulo(yi, tileHeight);
      const int y1 = (y0 + 1) % tileHeight;

      const double xf = x - xi;
      const double yf = y - yi;

      const double k1 = (1 - xf) * (1 - yf);
      const double k2 = xf * (1 - yf);
      const double k3 = (1 - xf) * yf;
      const double k4 = xf * yf;

      ColorRGBA c1, c2, c3, c4;
      /*
        if(xi < 0)
        {
        if(yi < 0) c1 = c2 = c3 = c4 = texture->get_pixel(0, 0);
        else if(yi >= height - 1) c1 = c2 = c3 = c4 = texture->get_pixel(0, tileHeight - 1);
        else 
        {
        c1 = c2 = texture->get_pixel(0, yi % tileHeight);
        c3 = c4 = texture->get_pixel(0, (yi + 1) % tileHeight);
        }
        }
        else if(xi >= width - 1)
        {
        if(yi < 0) c1 = c2 = c3 = c4 = texture->get_pixel(tileWidth - 1, 0);
        else if(yi >= height - 1) c1 = c2 = c3 = c4 = texture->get_pixel(tileWidth - 1, tileHeight - 1);
        else
        {
        c1 = c2 = texture->get_pixel(tileWidth - 1, yi % tileHeight);
        c3 = c4 = texture->get_pixel(tileWidth - 1, (yi + 1) % tileHeight);
        }
        }
        else 
        {
        if(yi < 0) 
        {
        c1 = c3 = texture->get_pixel(xi % tileWidth, 0);
        c2 = c4 = texture->get_pixel((xi + 1) % tileWidth, 0);
        }
        else if(yi >= height - 1)
        {
        c1 = c3 = texture->get_pixel(xi % tileWidth, tileHeight - 1);
        c2 = c4 = texture->get_pixel((xi + 1) % tileWidth, tileHeight - 1);
        }
        else 
        {*/
      image.getPixel(x0, y0, c1[0], c1[1], c1[2], c1[3]);
      image.getPixel(x1, y0, c2[0], c2[1], c2[2], c2[3]);
      image.getPixel(x0, y1, c3[0], c3[1], c3[2], c3[3]);
      image.getPixel(x1, y1, c4[0], c4[1], c4[2], c4[3]);
      /*}
        }*/

      c[0] = k1 * c1[0] + k2 * c2[0] + k3 * c3[0] + k4 * c4[0];
      c[1] = k1 * c1[1] + k2 * c2[1] + k3 * c3[1] + k4 * c4[1];
      c[2] = k1 * c1[2] + k2 * c2[2] + k3 * c3[2] + k4 * c4[2];
      c[3] = k1 * c1[3] + k2 * c2[3] + k3 * c3[3] + k4 * c4[3];
    }
  }
}

---