object.H

/*
 * 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).
 */

#ifndef ARCHON_RAYTRACER_OBJECT_H
#define ARCHON_RAYTRACER_OBJECT_H

#include <string>
#include <vector>

#include <archon/math/vector.H>
#include <archon/math/coord_system.H>
#include <archon/math/geometry.H>

#include "exception.H"
#include "surface.H"
#include "light.H"

namespace Archon
{
  namespace Raytracer
  {
    using namespace std;
    using namespace Utilities;
    using namespace Math;

    class Object
    {
    public:
      class Part
      {
      protected:
        const Surface *surface;

        Part(const Surface *surface): surface(surface) {}
        virtual ~Part() {}

      public:
        const Surface *getSurface() const { return surface; }
        virtual void map(const Vector3 &point, Vector3 &normal) const = 0;
        virtual void map(const Vector3 &point, Vector3 &normal,
                         Vector2 &texturePoint) const = 0;
      };

      virtual ~Object() {}

      virtual bool intersect(const Line3 &ray,
                             const Object *originObject,
                             const Part *originPart,
                             double &dist, const Part **p = 0) const = 0;
    };

    class Solid: public Object
    {
    public:
      virtual void interiorIntersect(const Line3 &ray,
                                     const Part *originPart,
                                     double &dist,
                                     const Part *&p) const = 0;
    };

    // A thin X-Z plane
    class Plane: public Object, public Object::Part
    {
      CoordSystem3x3 invMap;
      Vector3 origin;
      Vector3 normal;
    public:
      Plane(const Surface *surface, const CoordSystem3x3 &s):
        Object::Part(surface), origin(s.origin), normal(s.basis.y)
      {
        invMap.setInverseOf(s);
        normal.normalize();
      }

      bool intersect(const Line3 &ray, const Object *originObject,
                     const Object::Part *originPart, double &dist,
                     const Object::Part ** = 0) const;

      void map(const Vector3 &point, Vector3 &normal) const;
      void map(const Vector3 &point, Vector3 &normal,
               Vector2 &texturePoint) const;
    };

    class Cylinder: public Solid, private Object::Part
    {
    private:
      CoordSystem3x3 invMap; // The world coordinate system described in the coordinate system of the sphere
      CoordSystem3x3 pointToNormalMap; // The map that takes a world coordinate system point to the corresponding normal of the sphere surface.
      Plane *topCap;
      Plane *bottomCap;

    public:
      Cylinder(const Surface *surface, const CoordSystem3x3 &s);
      ~Cylinder();

      bool intersect(const Line3 &ray, const Object *originObject,
                     const Object::Part *originPart, double &dist,
                     const Object::Part ** = 0) const;

      void interiorIntersect(const Line3 &ray,
                             const Object::Part *originPart,
                             double &dist, const Object::Part *&) const;

      void map(const Vector3 &point, Vector3 &normal) const
      {
        normal = pointToNormalMap(point);
        normal.normalize();
      }

      void map(const Vector3 &point, Vector3 &normal,
               Vector2 &texturePoint) const;
    };

    class Sphere: public Solid, private Object::Part
    {
      CoordSystem3x3 invMap; // The world coordinate system described in the coordinate system of the sphere
      CoordSystem3x3 pointToNormalMap; // The map that takes a world coordinate system point to the corresponding normal of the sphere surface.

    public:
      Sphere(const Surface *surface, const CoordSystem3x3 &s):
        Object::Part(surface)
      {
        invMap.setInverseOf(s);
        pointToNormalMap = invMap;
        pointToNormalMap.basis.transpose();
        pointToNormalMap.basis.map(pointToNormalMap.origin);
        pointToNormalMap.basis *= invMap.basis;
      }

      ~Sphere() {}

      bool intersect(const Line3 &ray, const Object *originObject,
                     const Object::Part *originPart, double &dist,
                     const Object::Part ** = 0) const;

      void interiorIntersect(const Line3 &ray,
                             const Object::Part *originPart,
                             double &dist, const Object::Part *&) const;

      void map(const Vector3 &point, Vector3 &normal) const
      {
        normal = pointToNormalMap(point);
        normal.normalize();
      }

      void map(const Vector3 &point, Vector3 &normal,
               Vector2 &texturePoint) const;
    };

    class Torus: public Solid, private Object::Part
    {
    private:
      CoordSystem3x3 invMap; // The world coordinate system described in the coordinate system of the torus
      Matrix3x3 normalMap; // The map that takes a local normal to the corresponding normal in the global coordinate system.
      double majorRadius, minorRadius; 

    public:
      Torus(const Surface *surface, const CoordSystem3x3 &s,
            double majorRadius, double minorRadius):
        Object::Part(surface), 
        majorRadius(majorRadius), minorRadius(minorRadius)
      {
        invMap.setInverseOf(s);
        normalMap = invMap.basis;
        normalMap.transpose();
      }

      ~Torus() {}

      bool intersect(const Line3 &ray, const Object *originObject,
                     const Object::Part *originPart, double &dist,
                     const Object::Part ** = 0) const;

      void interiorIntersect(const Line3 &ray,
                             const Object::Part *originPart,
                             double &dist, const Object::Part *&) const;

      void map(const Vector3 &point, Vector3 &normal) const;

      void map(const Vector3 &point, Vector3 &normal,
               Vector2 &texturePoint) const;
    };


    class Polygon: public Object, private Object::Part
    { 
      friend class ConvexPolyhedron;

    private:
      vector<Vector3 *> vertexList;
      Vector3 normal;

      Vector3 texMapX;
      Vector3 texMapY;
      Vector2 texMapOrigin;

      /*
        Vector3 textureOrigin;
        Vector3 textureAxisX;
        Vector3 textureAxisY;
        double scaling;
      */

    public:
      // Unstretchable
      Polygon(const Surface *surface,
              const vector<Vector3 *> &vertexList,
              const Vector2 &textureVertex1,
              const Vector2 &textureVertex2);
      // Semi-stretchable (scale + skew) (works for triangles and parallelograms)
      Polygon(const Surface *surface,
              const vector<Vector3 *> &vertexList,
              const Vector2 &textureVertex1,
              const Vector2 &textureVertex2,
              const Vector2 &textureVertex3);

      ~Polygon() {}

      bool intersect(const Line3 &ray, const Object *originObject,
                     const Object::Part *originPart, double &dist,
                     const Object::Part ** = 0) const;

      bool backfaceIntersect(const Line3 &ray, const Object *originObject,
                             const Object::Part *originPart, double &dist,
                             const Object::Part ** = 0) const;

      void map(const Vector3 &point, Vector3 &normal) const
      {
        normal = this->normal;
      }

      void map(const Vector3 &point, Vector3 &normal,
               Vector2 &texturePoint) const;
    };


    class ConvexPolyhedron: public Solid
    {
    private:
      vector<Polygon *> polygonList;
      Sphere3 boundingVolume;

    public:
      /*
       * The polyhedron is responsible for destroying the polygons that
       * are passed to the constructor.
       */
      ConvexPolyhedron(const vector<Polygon *> &polygonList);
      ~ConvexPolyhedron();

      bool intersect(const Line3 &ray, const Object *originObject,
                     const Part *originPart, double &dist,
                     const Object::Part ** = 0) const;

      void interiorIntersect(const Line3 &ray,
                             const Object::Part *originPart,
                             double &dist, const Object::Part *&) const;
    };
  }
}

#endif // ARCHON_RAYTRACER_OBJECT_H

---