Sphere.h

#ifndef SPHERE_H
#define SPHERE_H 

/*
** ---------------------------------------------------------------
** Includes:
*/
#include <iostream>
#include "Vector3.h"
#include "AffineTransform.h"

/*
** ---------------------------------------------------------------
** Definitions:
*/

#define SPHERE 16

using namespace std;


class Sphere : public PrimitiveRep {


public:
        Sphere();
        Sphere(const Vector3 &c, double  r)
        void ~Sphere() 

        
        const Vector3 &center() const;
        double radius() const;

        static Val parse(int c, Pval *pl);


        int id(PrimitiveRep *p) const 
        Box3d bbox() const 
        virtual int classify( Vector3 q) const 
        virtual Vector3 point( Real u, Real v) const 
        virtual Vector3 normal( Real u, Real v) const 
        virtual Vector3 gradient( const Vector3 &q) const 
        virtual Inode *intersect( const Ray &r) const 
        virtual Polygon *uv_decomp( Real level) const;
        virtual Vector3 texc( Real u, Real v) const 
        virtual Vector3 du( Real u, Real v) const 
        virtual Vector3 dv( Real u, Real v) const 
        virtual AffineTransform local(PrimitiveRep *p) const 

        virtual ofstream &operator<<(ofstream &out) 

private :

        Vector3 &c;
        double  r;



};

inline ostream &operator<<(ostream &os, const Sphere3 &sphere);



inline const Vector3 &
Sphere::center() const 
{
        return c;
}

inline double 
Sphere::radius() const 
{
        return r;
}

inline int 
Sphere::id()
{
        return SPHERE;
}

inline Vector3 
Sphere::texc( Real u, Real v)
{
        return Vector3((u - UMIN)/ULEN, (v - VMIN)/VLEN, 0);
}

inline Vector3 
Sphere::du( Real u, Real v)
{
        return Vector3(- sin(u) * cos(v), cos(u) * cos(v), 0);
}

inline Vector3 
Sphere::dv( Real u, Real v)
{
        return Vector3(- cos(u) * sin(v), - sin(u) * sin(v), cos(v));
}

inline AffineTransform 
Sphere::local()
{
        return ti;
}

inline Val 
Sphere::parse(int pass, Pval *pl)
{
        Val v = {V_NULL, 0};
        
        if (pass == T_EXEC) {
        Vector3 c = pvl_get_v3(pl, "center", Vector3(0,0,0));
        double r = pvl_get_num(pl, "radius", 1);
        v.type = V_PRIM;
        set(v.u.v = instance(&funcs), c, r);
        }
        return v;
}

inline ostream &
Sphere::operator<<(ostream &os, const Sphere3 &sphere)
{
        return out << "sphere { \n") << 
        "\t\t center = {%g, %g, %g},\n",sphere.c.x,sphere.c.y,sphere.c.z) <<
        "\t\t radius = %g \n}\n",sphere.r);
}

#endif //SPHERE_H

---