Cyl.cc

Go to the documentation of this file.

#include <iostream>
#include "Cyl.h"
#include "BoundingBox.h"
#include "HitRecord.h"
#include "Point.h"
#include "Plane.h"
#include "Ray.h"
#include "Vector.h"
#include <math.h>
#include <stdlib.h>
#include <float.h>

Cyl::Cyl(Material* material, const Point & b, const Point & t, const float rad)
    : Primitive(material), base(b), top(t), radius(rad)
{
    A = top - base;
    topPlane = new Plane(material, A, t);
    basePlane = new Plane(material, -A, b);

    A.normalize();
}


Cyl::~Cyl()
{
    delete basePlane;
    delete topPlane;
}

void Cyl::getBounds(BoundingBox& bbox) const
{
}


void Cyl::normal(Vector& normal, const RenderContext&, const Point& hitpos,
                    const Ray& ray, const HitRecord& hit) const
{
    Vector BH = hitpos - base;
    Vector N;

    switch (hit.scratchdata[0]) {
    case 0:
        N = BH - (Dot(BH, A) * A);
        N = N / radius;

        normal = N;
        break;
    case 1:
        // hit the base
        normal = -A;
        break;
    case 2:
        // hit the top
        normal = A;
        break;
    }
}


void Cyl::intersect(HitRecord& hit, const RenderContext& context, const Ray& ray) const
{
    Vector D = Cross(ray.direction(), A);

    D.normalize();

    Vector BrMinusBc = ray.origin() - base;

    float d = Abs( Dot(BrMinusBc, D) );

    if (d > radius)
        return;

    Vector RcrossA = Cross(ray.direction(), A);

    float t_pca = Dot(Cross(BrMinusBc, A), RcrossA) / RcrossA.length2();
    t_pca *= -1.0;


    Vector O = Cross(D, A);
    O.normalize();

    float s = sqrt((radius*radius)-(d*d))/Dot(ray.direction(), O);

    float tmin = t_pca-s;
    float tmax = t_pca+s;

    if (tmin > tmax) {
        tmin = t_pca+s;
        tmax = t_pca-s;
    }

    int max_surf, min_surf;
    max_surf = min_surf = 0;

    double t_plane;



#if 1
    HitRecord baseHit(DBL_MAX);
    basePlane->intersect(baseHit, context, ray);
    t_plane = baseHit.minT();
    if (Dot(-A, ray.direction()) >= 0) {
        // ray leaving base plane
        if (t_plane < tmax) {
            tmax = t_plane;
            max_surf = 1;
        }
    } else {
        // ray entering base plane
        if (t_plane > tmin) {
            tmin = t_plane;
            min_surf = 1;
        }
    }
#endif

    HitRecord topHit(DBL_MAX);
    topPlane->intersect(topHit, context, ray);
    t_plane = topHit.minT();
    if (Dot(A, ray.direction()) >= 0) {
        // ray leaving top plane
        if (t_plane < tmax) {
            tmax = t_plane;
            max_surf = 2;
        }
    } else {
        // ray entering top plane
        if (t_plane > tmin) {
            tmin = t_plane;
            min_surf = 2;
        }
    }


    if (tmin > tmax)
        return;

    if (hit.hit(tmin, this, matl)) {
        hit.scratchdata[0] = min_surf;
    } else if (hit.hit(tmax, this, matl)) {
        hit.scratchdata[0] = max_surf;
    }
}

---