global.h

[Game.Programming].Academic - Graphics Gems (6 books source code)

#include <math.h>
#include <stdlib.h>

//      NUMERIC CONSTANTS AND RELATED THINGS

const double Pi=3.1415926535;
inline double RAD(double r) {return Pi*r/180.;}     // DEG-TO-RAD CONVERSION
const double EPS=1e-4;                              // VERY SMALL NUMBER

//      LIST TEMPLATE

template <class T> struct listelem {
        T o;                                            // OBJECT
        listelem<T> *n;                                 // NEXT ELEMENT
        listelem(T o) {this->o=o; n=(listelem<T>*)0;}
};

template <class T> class list {
        listelem<T> *h, *t, *a;                         // HEAD, TAIL, ACTUAL
public:
        list() {h=t=(listelem<T>*)0;}
        ~list() {for(;h;h=a) {a=h->n; delete h;}}
        void operator+=(T o) {                          // INSERT INTO LIST
                listelem<T> *e=new listelem<T>(o);
                if(t) {t->n=e; t=e;} else {h=e; t=e;}
        }
        T first() {a=h; return a?a->o:(T)0;}
        T next() {a=a->n; return a?a->o:(T)0;}
        int operator[](T o) {                                   // o ON LIST?
                for(listelem<T>*e=h;e;e=e->n) if(e->o==o) return 1;
                return 0;
        }
};

//      DECLARATION TEMPLATE (SIMILAR TO LIST BUT MAY BE ENHANCED)

template <class T> struct declaration {
        char *i;                                                // IDENTIFIER
        T *p;                                                   // OBJECT
        declaration<T> *n;                                      // NEXT
        declaration(char* i, T* p) {this->i=i; this->p=p;}
        ~declaration() {delete i; delete p;}
};

template <class T> class declarations {
        declaration<T> *h;                                      // HEAD
public:
        declarations() {h=(declaration<T>*)0;}
        ~declarations() {
                for(declaration<T>* a; h; h=a) {a=h->n; delete h;}
        }
        void operator+=(declaration<T>* d) {d->n=h; h=d;}       // INSERT
        T* operator[](char* i) {                                // GET
                for(declaration<T>* d=h; d; d=d->n)
                        if(strcmp(d->i,i)==0)
                                return d->p;
                cout<<"identifier "<<i<<" not found\n";
                exit(1);
                return (T*)0;
        }
};

//      VECTORS AND MATRICES

class xform;

class vector {
        friend ostream& operator<<(ostream& o, vector& v);
        friend vector operator-(vector& v);
        friend class xform;
        double x, y, z;
public:
        vector() {x=0.; y=0.; z=0.;}
        vector(double x, double y, double z) {
                this->x=x; this->y=y; this->z=z;
        }
        vector operator+(vector& v) {return vector(x+v.x,y+v.y,z+v.z);}
        vector operator-(vector& v) {return vector(x-v.x,y-v.y,z-v.z);}
        vector operator*(vector& v) {return vector(x*v.x,y*v.y,z*v.z);}
        vector operator/(vector& v) {return vector(x/v.x,y/v.y,z/v.z);}
        vector operator+(double d) {return vector(x+d,y+d,z+d);}
        vector operator-(double d) {return vector(x-d,y-d,z-d);}
        vector operator*(double d) {return vector(x*d,y*d,z*d);}
        vector operator/(double d) {return vector(x/d,y/d,z/d);}
        double operator%(vector& v) {return x*v.x+y*v.y+z*v.z;}
        operator double() {return y;}
        double operator[](int i) {return i==0?this->x:i==1?this->y:this->z;}
        double get_x() { return this->x;}
        double get_y() { return this->y;}
        double get_z() { return this->z;}
};

extern vector norm(vector& v);

struct matrix {
        double m11, m12, m13;                                   // 1ST ROW
        double m21, m22, m23;                                   // 2ND ROW
        double m31, m32, m33;                                   // 3RD ROW
        matrix(double m11=1., double m12=0., double m13=0.,
               double m21=0., double m22=1., double m23=0.,
               double m31=0., double m32=0., double m33=1.) {
                this->m11=m11; this->m12=m12; this->m13=m13;
                this->m21=m21; this->m22=m22; this->m23=m23;
                this->m31=m31; this->m32=m32; this->m33=m33;
        }
        matrix operator*(matrix& m) {
                return matrix(
                        m11*m.m11+m12*m.m21+m13*m.m31,
                        m11*m.m12+m12*m.m22+m13*m.m32,
                        m11*m.m13+m12*m.m23+m13*m.m33,

                        m21*m.m11+m22*m.m21+m23*m.m31,
                        m21*m.m12+m22*m.m22+m23*m.m32,
                        m21*m.m13+m22*m.m23+m23*m.m33,

                        m31*m.m11+m32*m.m21+m33*m.m31,
                        m31*m.m12+m32*m.m22+m33*m.m32,
                        m31*m.m13+m32*m.m23+m33*m.m33
                );
        }
        vector operator*(vector& v) {
                return vector(
                        vector(m11,m12,m13)%v,
                        vector(m21,m22,m23)%v,
                        vector(m31,m32,m33)%v
                );
        }
        vector operator/(vector& v) {                     // INVERSE
                return vector(
                        v%vector(m11,m21,m31),
                        v%vector(m12,m22,m32),
                        v%vector(m13,m23,m33)
                );
        }
};

//      RAYS AND INTERSECTIONS

struct ray {
        vector o;                                               // ORIGIN
        vector d;                                               // DIRECTION
        int l;                                                  // LEVEL
        int c;                                                  // CODE
        ray(vector& o, vector& d, int l, int c)
                {this->o=o; this->d=d; this->l=l; this->c=c;}
};

class object;

struct intersect {
        double t;                                       // RAY PARAMETER
        vector p;                                       // SURFACE POINT
        vector n;                                       // SURFACE NORMAL
        object *o;                                      // OBJECT SURFACE
        intersect() {o=(object*)0;}
        intersect(double t, vector& p, vector& n, object *o) {
                this->t=t; this->p=p; this->n=n; this->o=o;
        }
};

//      HALF-SPACES

struct halfspace {
        vector n;                                       // NORMAL
        double d;                                       // DISTANCE FROM ORIGIN
        halfspace()                                     // DEFAULT CONSTRUCTOR
                {this->n=vector(0.,0.,1.); this->d=0.;}
        halfspace(vector& n, double d)                  // USUAL DEFINITION
                {this->n=norm(n); this->d=d;}
        halfspace(vector& u, vector& v)     // BISECTOR PLANE
                {n=norm(v-u); d=((u+v)/2.)%n;}
        int operator&(vector& p) {return n%p<=d;} // IF CONTAINS POINT p
};

//      GEOMETRIC TRANSFORMATIONS (RIGID MOTIONS)

class xform {
        friend ostream& operator<<(ostream& o, xform& T);
        matrix A;                               // ORTHONORMAL ORIENTATION
        vector s;                               // DIAGONAL SCALE
        vector t;                               // TRANSLATION VECTOR
public:
        xform() {s=vector(1.,1.,1.); t=vector(0.,0.,0.);}
        void operator+=(vector& t) {this->t=this->t+t;}   // TRANSLATE
        void operator*=(vector& s) {                      // SCALE
                this->s=this->s*s; this->t=s*this->t;
        }
        void operator<<=(vector& r) {                     // ROTATE
                double sa=sin(RAD(r.x)), ca=cos(RAD(r.x));
                double sb=sin(RAD(r.y)), cb=cos(RAD(r.y));
                double sc=sin(RAD(r.z)), cc=cos(RAD(r.z));
                matrix Ap=matrix(cc,-sc,0., sc,cc,0., 0.,0.,1.)*
                         (matrix(cb,0.,sb, 0.,1.,0., -sb,0.,cb)*
                          matrix(1.,0.,0., 0.,ca,-sa, 0.,sa,ca));
                matrix B(
                        s.x*Ap.m11, s.y*Ap.m12, s.z*Ap.m13,
                        s.x*Ap.m21, s.y*Ap.m22, s.z*Ap.m23,
                        s.x*Ap.m31, s.y*Ap.m32, s.z*Ap.m33
                );
                s=vector(
                        sqrt(B.m11*B.m11+B.m12*B.m12+B.m13*B.m13),
                        sqrt(B.m21*B.m21+B.m22*B.m22+B.m23*B.m23),
                        sqrt(B.m31*B.m31+B.m32*B.m32+B.m33*B.m33)
                );
                A=matrix(
                        B.m11/s.x, B.m12/s.x, B.m13/s.x,
                        B.m21/s.y, B.m22/s.y, B.m23/s.y,
                        B.m31/s.z, B.m32/s.z, B.m33/s.z
                );
                t=Ap*t;
        }
        vector operator*(vector& v) {return s*(A*v)+t;}         // TRANSFORM
        vector operator/(vector& v) {return (A/(v-t))/s;}       // INVERSE
        vector operator<<(vector& v) {return s*(A*v);}          // ROTATE
        vector operator>>(vector& v) {return (A/v)/s;}          // INVERSE
        ray operator*(ray& r)
                {return ray((*this)*r.o,(*this)<<r.d,r.l,r.c);}
        ray operator/(ray& r)
                {return ray((*this)/r.o,(*this)>>r.d,r.l,r.c);}
        intersect operator*(intersect& i)
                {return intersect(i.t,(*this)*i.p,norm((*this)<<i.n),i.o);}
        list<intersect*> *operator*(list<intersect*> *l) {
                for(intersect* i=l->first(); i; i=l->next())
                        *i=(*this)*(*i);
                return l;
        }
        halfspace operator*(halfspace& h) {
                vector p=(*this)*(h.n*h.d); vector n=(*this)<<h.n;
                return halfspace(n,p%n);
        }
        halfspace operator/(halfspace& h) {
                vector p=(*this)/(h.n*h.d); vector n=(*this)>>h.n;
                return halfspace(n,p%n);
        }
};

//      CAMERA MODEL

class camera {
        friend ostream& operator<<(ostream& o, camera& c);
        vector l;                                       // LOCATION
        vector s;                                       // SKY
        vector d;                                       // DIRECTION
        vector u;                                       // UP
        vector r;                                       // RIGHT
        vector a;                                       // LOOK_AT
        xform T;                                        // TRANSFORMATION
public:
        camera() {
                l=vector(0.,0.,0.); s=vector(0.,1.,0.); d=vector(0.,0.,1.);
                u=vector(0.,1.,0.); r=vector(1.33,0.,0.); a=vector(0.,0.,1.);
        }
        void setl(vector& v) {l=v;}
        void sets(vector& v) {s=v;}
        void setd(vector& v) {d=v;}
        void setu(vector& v) {u=v;}
        void setr(vector& v) {r=v;}
        void seta(vector& v) {a=v;}
        void traT(vector& v) {T+=v;}
        void rotT(vector& v) {T<<=v;}
        void scaT(vector& v) {T*=v;}
        ray getray(double x, double y) {
                return this->T*ray(l,norm((r*x)+(u*y)+d),0,0);
        }
};

//      TEXTURES - I. PIGMENT

class icolor {
        unsigned char r, g, b;                          // RED, GREEN, BLUE
public:
        icolor(unsigned char r=0, unsigned char g=0, unsigned char b=0) {
                this->r=r; this->g=g; this->b=b;
        }
};

class color;

class intensity {
        friend ostream& operator<<(ostream& o, intensity& i);
        friend class color;
        double r, g, b;                                 // RED, GREEN, BLUE
public:
        intensity(double r=0., double g=0., double b=0.) {
                this->r=r; this->g=g; this->b=b;
        }
        intensity operator*(double d) {return intensity(r*d,g*d,b*d);}
        intensity operator+(intensity& i)
                {return intensity(r+i.r,g+i.g,b+i.b);}
        void operator+=(intensity& i) {r+=i.r; g+=i.g; b+=i.b;}
        operator icolor() {
                unsigned char ir=r<1.?(unsigned char)(r*255.):255;
                unsigned char ig=g<1.?(unsigned char)(g*255.):255;
                unsigned char ib=b<1.?(unsigned char)(b*255.):255;
                return icolor(ir, ig, ib);
        }
};

class color {
        friend ostream& operator<<(ostream& o, color& c);
        double r, g, b;                                 // RED, GREEN, BLUE
        double f;                                       // FILTER
public:
        color(double r=0., double g=0., double b=0., double f=0.) {
                this->r=r; this->g=g; this->b=b; this->f=f;