src/Sphere.h

Go to the documentation of this file.

#ifndef SPHERE_H
#define SPHERE_H


#include <cassert>

#include "Primitive.h"


class Sphere : public Primitive
{
public:
    Sphere(const Vec3f & center, float radius)
        : mCenter(center),
            mRadius(radius)
    {
        assert(radius > 0.0f);
        calcBounds();
    }

    virtual ~Sphere()
    {
    }

    bool intersect(Ray & ray) const
    {
        // mathematical derivation, numerically not very stable, but simple

        // --> find roots of f(t) = ((R+tD)-C)^2 - r^2
        // f(t) = (R-C)^2 + 2(R-C)(tD) + (tD)^2 -r^2
        // --> f(t) = [D^2] t^2 + [2D(R-C)] t + [(R-C)^2 - r^2]
        Vec3f diff = ray.org() - mCenter;
        float a = ray.dir().dot(ray.dir());
        float b = 2 * ray.dir().dot(diff);
        float c = diff.dot(diff) - mRadius * mRadius;

        // use 'abc'-formula for finding root t_1, 2 = (-b +/- sqrt(b^2-4ac))/(2a)
        float inRoot = b*b - 4*a*c;
        if (inRoot < 0)
            return false;
        float root = sqrtf(inRoot);

        float dist = (-b - root)/(2*a);
        if (dist > ray.t())
            return false;

        if (dist < EPSILON)
        {
            dist = (-b + root)/(2*a);
            if (dist < EPSILON || dist > ray.t())
                return false;
        }
        ray.setHit(this, dist);
        // u and v correspond to theta and phi from spherical coordinates of the hitpoint with p set
        // to radius. range -PI .. PI is compressed into 0 .. 1
        // u goes arond the equator
        Vec3f hitP = ray.hitPoint(0.0f) - mCenter;
        float theta = 1.0f - (atan2f(hitP.y(), hitP.x()) + M_PI)*0.5f/M_PI;
        float phi   = atan2f(sqrtf(hitP.x()*hitP.x() + hitP.y()*hitP.y()), hitP.z())/M_PI;
        ray.setUV(theta, phi);
//        LOG("theta / phi : " << theta << " " << phi);
//        assert(0 <= theta && theta <= 1.0f + EPSILON);
//        assert(0 <= phi && phi <= 1.0f + EPSILON);
        return true;
    }

    Vec3f normal(const Ray & ray) const
    {
        assert(ray.hit() == this);
        assert(ray.obj());

        // transform spherical coordinates of the hit point to cartesian with p = 1
        float theta = (1.0f - ray.u())*2*M_PI - M_PI;
        float phi   = ray.v()*M_PI;
        Vec3f norm(sinf(phi)*cosf(theta), sinf(phi)*sinf(theta), cosf(phi));
        ray.obj()->toGlobalCoordinates(norm);
        return norm.normal();
    }

    virtual TexCoordinate texCoord(const Ray & ray) const
    {
        return TexCoordinate(ray.u(), ray.v());
    }

    void axes(const Ray & ray, Vec3f & x, Vec3f & y) const
    {
        assert(ray.hit() == this);
        assert(ray.obj());

        Vec3f n = normal(ray);
        Vec3f fn = n.fabs();
        fn.setX(1 - fn.x());
        if (fn.x() <= EPSILON && fn.y() <= EPSILON && fn.z() <= EPSILON)
        {
            x = Vec3f(0, 1, 0);
            y = Vec3f(0, 0, 1);
            return;
        }
        x = - n.cross(Vec3f(1, 0, 0)).normal();
        y = n.cross(x).normal();

        // take x and y coordinate axes rotated with phi and theta
//        float theta = (1.0f - ray.u())*2*M_PI - M_PI;
//        float phi   = ray.v()*M_PI;
//        x = Vec3f(cosf(phi)*cosf(theta), cosf(phi)*sinf(theta), -sinf(phi));
//        y = Vec3f(-cosf(phi)*sinf(theta), cosf(theta), sinf(phi)*sinf(theta));
    }

protected:
    Vec3f   mCenter;

    // Sphere radius
    float   mRadius;


    void calcBounds()
    {
        // sphere's bounding box is computed based on the radius of the sphere
        mBounds.extend(mCenter + Vec3f(-mRadius));
        mBounds.extend(mCenter + Vec3f(mRadius));
    }
};


#endif

---