geometry.hh

Go to the documentation of this file.

#include <assert.h>
#include <iostream>
#include "misc.hh"
#include "matrix.hh"

#ifndef GEOMETRY_HH
#define GEOMETRY_HH

class Color;
template <unsigned int n> class Point;
template <unsigned int n> class Vector;
template <unsigned int n> class Ray;
template <unsigned int n> class Object;
class Sphere;

class Color {
  public:
    Color() { data[0] = 0.0; data[1] = 0.0; data[2] = 0.0; }

    Color (double r, double g, double b);

    static Color makeRGB (double r, double g, double b) { return Color(r,g,b); }

    static Color makeHSV (double h, double s, double v) {
        Color c; c.setHSV (h, s, v); return c;
    }

    void setRGB (double r, double g, double b) {
        data[0] = r; data[1] = g; data[2] = b;
    }

    void setHSV (double h, double s, double v);

    const Color& operator+= (const Color &c);

    const Color& operator*= (const Color &c);

    const Color& operator*= (double s);

    double operator[] (unsigned int i) const { assert (i < 3); return data[i]; }

    const static Color BLACK;
    const static Color RED;
    const static Color GREEN;
    const static Color BLUE;
    const static Color WHITE;
  private:
    double data[3];
};

inline Color operator+ (const Color &a, const Color &b)
  { Color c (a); c += b; return c; }

inline Color operator* (const Color &a, const Color &b)
  { Color c (a); c *= b; return c; }

inline Color operator* (const Color &a, double b)
  { Color c (a); c *= b; return c; }

inline Color operator* (double a, const Color &b)
  { Color c (b); c *= a; return c; }

template <unsigned int n>
class Point {
  public:
    Point();

    Point (const double data[n]);

    double operator[] (unsigned int i) const
      { assert (i < n); return data(i,0); }

    const Point<n>& operator+= (const Vector<n> &v)
      { data += v.getMatrix(); return *this; }

    const Point<n>& operator-= (const Vector<n> &v)
      { data -= v.getMatrix(); return *this; }

    const Matrix<n+1,1>& getMatrix() const { return data; }
  private:
    Matrix<n+1,1> data;
};

template <unsigned int n>
Point<n> operator+ (const Point<n> &a, const Vector<n> &b)
  { Point<n> r (a); r += b; return r; }

template <unsigned int n>
Point<n> operator- (const Point<n> &a, const Vector<n> &b)
  { Point<n> r (a); r -= b; return r; }

template <unsigned int n>
inline std::ostream& operator<< (std::ostream&, const Point<n>&);

template <unsigned int n>
class Vector {
    template <unsigned int n2> friend Vector<n2> operator-
            (const Point<n2> &a, const Point<n2> &b);
  public:
    Vector() { assert (n > 0); }

    Vector (const double data[n]);

    double getLength() const;

    const static double NORMAL_EPSILON;

    bool isNormalized() const { return abs(getLength()-1.0) < NORMAL_EPSILON; }

    void normalize();

    void translateGL() const;

    double operator[] (unsigned int i) const
      { assert (i < n); return data(i,0); }

    const Vector<n>& operator*= (double d) { data *= d; return *this; }

    const Vector<n>& operator/= (double d) { data /= d; return *this; }

    const Vector<n>& operator+= (const Vector<n> &v)
      { data += v.data; return *this; }

    const Vector<n>& operator-= (const Vector<n> &v)
      { data -= v.data; return *this; }

    Vector<n> operator-() const;

    const Matrix<n+1,1>& getMatrix() const { return data; }
  private:
    Matrix<n+1,1> data;
};

template <unsigned int n>
Vector<n> operator* (const Vector<n> &a, double b)
  { Vector<n> r (a); r *= b; return r; }

template <unsigned int n>
Vector<n> operator/ (const Vector<n> &a, double b)
  { Vector<n> r (a); r /= b; return r; }

  template <unsigned int n>
Vector<n> operator* (double b, const Vector<n> &a)
  { Vector<n> r (a); r *= b; return r; }

template <unsigned int n>
Vector<n> operator+ (const Vector<n> &a, const Vector<n> &b)
  { Vector<n> r (a); r += b; return r; }

template <unsigned int n>
Vector<n> operator- (const Vector<n> &a, const Vector<n> &b)
  { Vector<n> r (a); r -= b; return r; }

template <unsigned int n>
double operator* (const Vector<n> &a, const Vector<n> &b);

template <unsigned int n>
inline std::ostream& operator<< (std::ostream&, const Vector<n>&);

template <unsigned int n>
class Ray {
  public:
    Ray();

    Ray (const Point<n> &start, const Vector<n> &dir) : start(start), dir(dir) {
        assert (n > 0);
        assert (dir.isNormalized());
    }

    const Point<n>& getStart() const { return start; }

    const Vector<n>& getDirection() const { return dir; }

    Point<n> operator() (double d) const { return start + dir*d; }
  private:
    Point<n> start;     
    Vector<n> dir;      
};

template <unsigned int n>
std::ostream& operator<< (std::ostream&, const Ray<n>&);

template <unsigned int n>
class Object {
  public:
    virtual Pair<double> getCoordRange (int axis) const = 0;

    const static double INTERSECT_EPSILON;

    virtual bool testIntersection (const Ray<n>&, double &d) const = 0;

    virtual Vector<n> computeNormal (const Point<n>&) const = 0;

    virtual void drawGL() const = 0;

    const Color& getAmbient() const { return ambient; }

    void setAmbient (const Color &newambient) { ambient = newambient; }

    double getShininess() const { return shininess; }

    void setShininess (double newshininess)
      { assert (shininess >= 0.0); shininess = newshininess; }

    const Color& getDiffuse() const { return diffuse; }

    void setDiffuse (const Color &newdiffuse) { diffuse = newdiffuse; }

    const Color& getSpecular() const { return specular; }

    void setSpecular (const Color &newspecular) { specular = newspecular; }

  private:
    Color ambient;      
    Color diffuse;      

    Color specular;     

    double shininess;   

};

class Sphere : public Object<3> {
  public:
    Sphere (const Point<3> &center = Point<3>(), double radius = 1.0)
        : center(center), radius(radius) {}

    Pair<double> getCoordRange (int axis) const;
    bool testIntersection (const Ray<3>&, double &d) const;
    Vector<3> computeNormal (const Point<3> &p) const
      { Vector<3> n (p-center); n.normalize(); return n; }
    void drawGL() const;

  private:
    Point<3> center;
    double radius;
};

class Light {
  public:
    Light (const Point<3> &position, const Color &ambient,
            const Color &diffuse, const Color &specular) :
            position(position), ambient(ambient), diffuse(diffuse),
            specular(specular) {}

    const Point<3>& getPosition() const { return position; }

    const Color& getAmbient() const { return ambient; }
    void setAmbient (const Color &newambient) { ambient = newambient; }

    const Color& getDiffuse() const { return diffuse; }
    void setDiffuse (const Color &newdiffuse) { diffuse = newdiffuse; }

    const Color& getSpecular() const { return specular; }
    void setSpecular (const Color &newspecular) { specular = newspecular; }

  private:
    Point<3> position;
    Color ambient, diffuse, specular;
};

#include "geometry.impl"

#endif // !GEOMETRY_HH

---