global.h

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

                i.p=T/i.p;
                color c=p->surfcolor(i.p);
                vector v=n->surfnormal(i.n, i.p);
                return f->surfoptics(c, v, r, i);
        }
};

class tiles : public texture {
public:
        void out(ostream& o) {
                o<<"texture {\n";
                o<<"tiles\n"<<*(texture*)this<<"tile2\n"<<*(l->first());
                o<<T<<"}\n";
        }
        texture* copy() {tiles* t=new tiles; *t=*this; return t;}
        intensity shade(ray& r, intersect& i)
                {return texture::shade(r,i);}
};

class materialmap : public texture {
};

//      OBJECTS IN GENERAL

class object {
protected:
        friend ostream& operator<<(ostream& o, object& p);
        texture t;                                      // TEXTURE
        xform T;                                        // TRANSFORMATION
        virtual list<intersect*> *shape(ray& r)   // RAY INTERSECTION
                {return new list<intersect*>;}
public:
        void outopt(ostream& o) {o<<t<<T;}
        virtual void out(ostream& o) {o<<"undefined {\n";outopt(o);o<<"}\n";}
        virtual ~object() {}
        void sett(texture& t) {this->t=t;}
        void setp(pigment& p) {t.setp(p);}
        void setn(normal& n) {t.setn(n);}
        void setf(finish& f) {t.setf(f);}
        void traT(vector& v) {T+=v;}
        void rotT(vector& v) {T<<=v;}
        void scaT(vector& v) {T*=v;}
        virtual object* copy() {object* o=new object; *o=*this; return o;}
        list<intersect*> *test(ray& r) {return T*shape(T/r);}
        intensity shade(ray& r, intersect& i) {return t.shade(r,i);}
        virtual list<vector*> *particles() {
                vector *v=new vector; *v=(this->T)*vector(0.,0.,0.);
                list<vector*> *l=new list<vector*>; *l+=v;
                return l;
        }
        virtual int operator&(halfspace& h) {return 1;}   // INTERSECTS h
};

//      INTERSECTION ACCELERATION TECHNIQUES

class method {
        list<object*> *lo;                              // SCENE OBJECTS
        virtual list<object*> *firstlist(ray& r)
                {return lo;}                            // BRUTE-FORCE METHOD
        virtual list<object*> *nextlist()
                {return (list<object*>*)0;}             // BRUTE-FORCE METHOD
public:
        method() {lo=new list<object*>;}
        virtual void preprocess(list<object*> *l)
                {delete lo; lo=l;}                      // NO PREPROCESSING
        intersect operator()(ray& r) {                  // GENERAL SCHEME
                intersect imin, *i;
                for(list<object*>*lo=firstlist(r); lo; lo=nextlist()) {
                        for(object *o=lo->first(); o; o=lo->next()) {
                                list<intersect*> *li=o->test(r);
                                if(i=li->first()) {
                                        if(!imin.o || i->t<imin.t )
                                                imin=*i;
                                }
                                for(i=li->first(); i; i=li->next())
                                        delete i;
                                delete li;
                        }
                }
                return imin;
        }
};

extern method* query;                                   // IN FILE main

//      OBJECTS SPECIFIED -  I. SOLID FINITE PRIMITIVES

class sphere : public object {
        vector c;                                       // CENTER
        double r;                                       // RADIUS
        list<intersect*> *shape(ray& r);
public:
        void out(ostream& o) {
                o<<"sphere {\n"<<c<<"\n"<<r<<"\n"; outopt(o); o<<"}\n";
        }
        friend ostream& operator<<(ostream& o, sphere& s);
        sphere() {c=vector(0.,0.,0.); r=1.;}
        sphere(vector& c, double r) {this->c=c;this->r=r;}
        object* copy() {sphere* o=new sphere; *o=*this; return o;}
        list<vector*> *particles() {
                vector *v=new vector; *v=T*c;
                list<vector*> *l=new list<vector*>; *l+=v;
                return l;
        }
        int operator&(halfspace& h)
                {halfspace H=T/h; return (c-H.n*(r+H.d))*H.n<=EPS;}
};

class box : public object {
};

class cone : public object {
};

class cylinder : public object {
};

class torus : public object {
};

class blob : public object {
};

//      OBJECTS SPECIFIED -  II. FINITE PATCH PRIMITIVES


//      OBJECTS SPECIFIED -  III. INFINITE SOLID PRIMITIVES

class plane : public object, public halfspace {
};

class quadric : public object {
};


//      OBJECTS SPECIFIED -  IV. CONSTRUCTIVE SOLID GEOMETRY (CSG)

class csg : public object {
        friend ostream& operator<<(ostream& o, csg& c);
protected:
        list<object*> *l;
public:
        csg(list<object*>*ol=(list<object*>*)0) {l=ol?ol:new list<object*>;}
        ~csg() {for(object* o=l->first();o;o=l->next()) delete o; delete l;}
        void outobj(ostream& o) {
                for(object *p=l->first();p;p=l->next()) o<<*p;
        }
        csg& operator=(csg& c) {
                object* o;
                for(o=l->first(); o; o=l->next()) delete o;
                delete l; l=new list<object*>;
                for(o=c.l->first(); o; o=c.l->next()) *l+=o->copy();
                return *this;
        }
        virtual object* copy() {csg* o=new csg; *o=*this; return o;}
        list<vector*> *particles() {
                list<vector*> *L=new list<vector*>;
                for(object*o=l->first();o;o=l->next()) {
                        list<vector*> *M=o->particles();
                        for(vector*v=M->first();v;v=M->next())
                                {*v=T*(*v); *L+=v;}
                        delete M;
                }
                return L;
        }
        int operator&(halfspace& h) {
                halfspace H=T/h;
                for(object*o=l->first();o;o=l->next()) if(*o&H) return 1;
                return 0;
        }
};

class csguni : public csg {
        friend ostream& operator<<(ostream& o, csguni& c);
public:
        csguni(list<object*>*ol=(list<object*>*)0) : csg(ol) {}
        ~csguni() {}
        void out(ostream& o) {
                o<<"union {\n"; outobj(o); outopt(o); o<<"}\n";
        }
        object* copy() {csguni* o=new csguni; *o=*this; return o;}
};

class csgmer : public csg {
        friend ostream& operator<<(ostream& o, csgmer& c);
public:
        csgmer(list<object*>*ol=(list<object*>*)0) : csg(ol) {}
        ~csgmer() {}
        void out(ostream& o) {
                o<<"merge {\n"; outobj(o); outopt(o); o<<"}\n";
        }
        object* copy() {csgmer* o=new csgmer; *o=*this; return o;}
};

class csgint : public csg {
        friend ostream& operator<<(ostream& o, csgint& c);
public:
        csgint(list<object*>*ol=(list<object*>*)0) : csg(ol) {}
        ~csgint() {}
        void out(ostream& o) {
                o<<"intersection {\n";outobj(o);outopt(o);o<<"}\n";
        }
        object* copy() {csgint* o=new csgint; *o=*this; return o;}
};

class csgdif : public csg {
        friend ostream& operator<<(ostream& o, csgdif& c);
public:
        csgdif(list<object*>*ol=(list<object*>*)0) : csg(ol) {}
        ~csgdif() {}
        void out(ostream& o) {
                o<<"difference {\n";outobj(o);outopt(o);o<<"}\n";
        }
        object* copy() {csgdif* o=new csgdif; *o=*this; return o;}
};


//      OBJECTS SPECIFIED -  V. LIGHT SOURCES

struct light {
        intensity i;
        vector v;
        light(intensity& i, vector& v) {this->i=i; this->v=v;}
};

class lightsource : public object {
        friend ostream& operator<<(ostream& o, lightsource& l);
protected:
        vector p;                                       // POSITION
        color c;                                        // COLOR
public:
        virtual void out(ostream& o) {
                o<<"light_source {\n"<<p<<"\n"<<c<<"\n"; o<<T; o<<"}\n";
        }
        lightsource() {p=vector(0.,0.,0.); c=color(1.,1.,1.);}
        void setp(vector& p) {this->p=p;}
        void setc(color& c)  {this->c=c;}
        object* copy() {lightsource* o=new lightsource; *o=*this; return o;}
        list<intersect*> *shape(ray& r) {return new list<intersect*>;}
        virtual list<light*>* illum(intersect& i) {
                list<light*> *L=new list<light*>;
                if((*query)(ray(this->p,norm(i.p-this->p),0,-1)).o!=i.o)
                        return L;
                light *l=new light((intensity)c,norm(this->p-i.p));
                *L+=l;
                return L;
        }
        list<vector*> *particles() {
                vector *v=new vector; *v=T*p;
                list<vector*> *l=new list<vector*>; *l+=v;
                return l;
        }
};

class spotlight : public lightsource {
        friend ostream& operator<<(ostream& o, spotlight& l);
        vector a;                                               // POINT AT
        double r;                                               // RADIUS
        double f;                                               // FALLOFF
        double t;                                               // TIGHTNESS
public:
        virtual void out(ostream& o) {
                o<<"light_source {\n"<<p<<"\n"<<c<<"\n";
                o<<"spotlight\npoint_at "<<a<<"\nradius "<<r<<"\n";
                o<<"falloff "<<f<<"\ntightness "<<t<<"\n";
                o<<T;
                o<<"}\n";
        }
        spotlight() {a=vector(0.,0.,0.); r=0.; f=0., t=10;}
        spotlight(vector a, double r, double f, double t)
                {this->a=a; this->r=r; this->f=f; this->t=t;}
        void seta(vector& a) {this->a=a;}
        void setr(double r) {this->r=r;}
        void setf(double f) {this->f=f;}
        void sett(double t) {this->t=t;}
        object* copy() {spotlight* o=new spotlight; *o=*this; return o;}
};

//      ACCELERATION TECHNIQUES - I. VIA VORONOI-DIAGRAM

struct cell;                                    // DECLARED IN voronoi.cxx

class voronoi : public method {
        cell *C;                                // CELL CLOSEST TO CENTROID
        cell **s;                               // ARRAY OF STARTING CELLS
        long traverse;                          // TRAVERSE CODE (disperse)
        void disperse(object *o, cell*C);
        cell* a; ray* r; double t;              // USED BY step()
        void step();                            // USED BY first-,nextlist()
        list<object*> *firstlist(ray& r);
        list<object*> *nextlist();
public:
        void preprocess(list<object*> *lo);
};

//      GLOBAL OBJECTS

extern int lmax;                                // MAXIMAL LEVEL OF RECURSION
extern int verbose;                             // PRINTOUTS
extern list<object*> objects;                   // SCENE OBJECTS
extern list<lightsource*> lightsources;         // LIGHTSOURCES
extern camera actcamera;                        // CAMERA
extern intensity trace(ray& r);                 // RECURSIVE RAY TRACING
extern fog actfog;                              // FOG