Box.cc

Go to the documentation of this file.

#include "BoundingBox.h"
#include "Box.h"
#include "HitRecord.h"
#include "Math.h"
#include "Ray.h"
#include "Point.h"
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
using namespace std;


Box::Box(Material* material, const Point& lo, const Point& hi)
    : Primitive(material)
{
    bounds[0] = lo;
    bounds[1] = hi;
}

Box::~Box()
{
}

void Box::intersect(HitRecord& hit, const RenderContext& context, const Ray& ray) const
{
    // Algorithm from Williams et. al.  http://www.cs.utah.edu/~awilliam/box/
    float tmin, tmax, txmin, txmax, tymin, tymax, tzmin, tzmax;
    float lonorm[3] = { -1, -1, -1 };
    float hinorm[3] = {  1,  1,  1 };
    int lo, hi;


    txmin = tmin = (bounds[  ray.is_neg[0]].x() - ray.origin().x()) * ray.inv_direction.x(); 
    txmax = tmax = (bounds[1-ray.is_neg[0]].x() - ray.origin().x()) * ray.inv_direction.x(); 
    tymin =(bounds[  ray.is_neg[1]].y() - ray.origin().y()) * ray.inv_direction.y(); 
    tymax =(bounds[1-ray.is_neg[1]].y() - ray.origin().y()) * ray.inv_direction.y(); 
    tzmin = (bounds[  ray.is_neg[2]].z() - ray.origin().z()) * ray.inv_direction.z(); 
    tzmax = (bounds[1-ray.is_neg[2]].z() - ray.origin().z()) * ray.inv_direction.z(); 


    if ( (txmin > tymax) || (tymin > txmax) ) 
        return; //  FALSE 
#if 0
    Point d = ray.origin() + ray.direction() * 7;
    fprintf(stderr, "%g %g %g  -> %g %g %g ( %g %g %g )\n",
            ray.origin().x(), ray.origin().y(), ray.origin().z(),
            ray.direction().x(), ray.direction().y(), ray.direction().z(),
            d.x(), d.y(), d.z() );

    fprintf(stderr, "%g %g %g\n", bounds[0].x(), bounds[0].y(), bounds[0].z());
    fprintf(stderr, "%g %g %g\n", bounds[1].x(), bounds[1].y(), bounds[1].z());


    fprintf(stderr, "X %g %g, Y %g %g Z %g %g\n", txmin, txmax, tymin, tymax, tzmin, tzmax);
#endif


    if (tymin > txmin) {
        tmin = tymin; 

        // it's not txmin
        lonorm[0] = 0;
        lo = 1;
    } else {
        // it's not tymin
        lonorm[1] = 0;
        lo = 0;
    }

    if (tymax < txmax) {
        tmax = tymax; 

        // it's not txmax
        hinorm[0] = 0;
        hi = 1;
    } else {
        // it's not tymax
        hinorm[1] = 0;
        hi = 0;
    }


    if ( (tmin > tzmax) || (tzmin > tmax) ) 
        return; // FALSE 

    if (tzmin > tmin) {
        tmin = tzmin; 

        // we're using tzmin
        lonorm[lo] = 0;
    } else {
        // we're NOT using tzmin
        lonorm[2] = 0;
    }

    if (tzmax < tmax) {
        // we're using tzmax
        tmax = tzmax;
        
        hinorm[hi] = 0;
    } else {
        hinorm[2] = 0;
    }

    if ( (tmin < HUGE) && (tmax > 0) ) {
        float *p = (float *)&hit.scratchdata[0];

        // hit
        if (tmin >= 0.0) {
            Point pt = ray.origin() + ray.direction() * tmin;

            if ( hit.hit(tmin, this, matl) ) {
                p[0] = lonorm[0];
                p[1] = lonorm[1];
                p[2] = lonorm[2];
            }
        } else {
            Point pt = ray.origin() + ray.direction() * tmax;
            if (hit.hit(tmax, this, matl)) {
                p[0] = hinorm[0];
                p[1] = hinorm[1];
                p[2] = hinorm[2];
            }
        }
    }
    ;
}

void Box::normal(Vector& normal, const RenderContext& ctx,
                   const Point& pt, const Ray& ray, const HitRecord& hit) const
{
    float *p = (float *)&hit.scratchdata[0];

    normal = Vector(p[0], p[1], p[2]);

}

void Box::getBounds(BoundingBox& bbox) const
{
  cerr <<  "Box::getBounds() called!" << endl;
  bbox.extend(bounds[0]);
  bbox.extend(bounds[1]);
  exit( 1 );
}

---