ring.cpp

Go to the documentation of this file.

/*
    toxic - A Global Illumination Renderer
    Copyright (C) 2003-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of toxic.

    toxic is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    toxic is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with toxic; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "ring.h"   // include first
#include "context.h"
#include "hit.h"
#include "isurfaceshader.h"
#include "ray.h"
#include "scene.h"
#include "settings.h"
#include "statistics.h"
#include "surfacebasis.h"
#include "utilities.h"

#include <algorithm>    // std::min<>(), std::max<>()
#include <cassert>
#include <cmath>
#include <limits>

using namespace sheep;
using namespace std;
using namespace toxic;

Ring::Ring(const Matrix4 &m,
           const ISurfaceShader *surface_shader,
           Real inner_radius,
           IntersectionMask intersection_mask /*= INTERSECT_ALL_RAYS*/) :
    IAreaLight(m, surface_shader, intersection_mask),
    m_inner_radius2(sq(inner_radius)),
    m_center(TransformToWorld(Point3(0.0))),
    m_ex(TransformToWorld(Vector3(1.0, 0.0, 0.0))),
    m_ey(TransformToWorld(Vector3(0.0, 1.0, 0.0))),
    m_ez(TransformToWorld(Vector3(0.0, 0.0, 1.0)))
{
    assert(inner_radius >= 0.0 && inner_radius < 1.0);

    m_aabb = AABB3(Point3(-1.0, -0.5, -1.0), Point3(1.0, 0.5, 1.0)).Transform(m);

    // Enlarge the object bounding box to avoid numerical instabilities.
    m_aabb.Extend(OBJECT_AABB_EXTENSION);
}

Real Ring::ComputeSurfaceArea() const {
    //!\todo Implement.
    return 0.0;
}

void Ring::EvaluateSurface(const Point2 &input,
                           Point3 *point,
                           Vector3 *geometric_normal) const
{
    assert(point);
    assert(geometric_normal);

    //!\todo Implement.
    assert(!"Not implemented yet.");
}

bool Ring::Intersect(const Context &context,
                     const Ray &ray,    //!< 'ray' is expressed in world space.
                     Hit *hit /*= 0*/) const
{
    // Test whether this object intersects with this type of ray.
    if(!(m_intersection_mask & ray.GetType()))
        return false;

    ++context.m_statistics->m_tested_intersections;

    Ray r = TransformToLocal(ray);
    const Real inv_scale = 1.0 / r.m_direction.Norm();

    // Normalize the ray's direction vector.
    r.m_direction *= inv_scale;

    Real min_t = std::numeric_limits<Real>::max();
    Vector3 normal;

    // Test intersection with the outer wrap.

    const Real a = sq(r.m_direction.m_x) + sq(r.m_direction.m_z);
    const Real b0 = sq(r.m_origin.m_x) + sq(r.m_origin.m_z) - 1.0;  // outer cylinder has unit radius
    const Real c = r.m_direction.m_x * r.m_origin.m_x + r.m_direction.m_z * r.m_origin.m_z;

    const Real delta0 = sq(c) - a * b0;

    if(delta0 >= 0.0) {
        const Real sqrt_delta0 = sqrt(delta0);
        //!\todo Handle the case where a=0.0.
        const Real t0 = (-c - sqrt_delta0) / a;
        const Real t1 = (-c + sqrt_delta0) / a;

        if(t0 >= 0.0) { // first test, don't compare t0 to min_t (since min_t is almost +infinity)
            // The ray intersects the cylinder supporting the outer wrap.

            const Real py = r.m_origin.m_y + t0 * r.m_direction.m_y;

            if(py >= -0.5 && py <= 0.5) {
                min_t = t0; // the ray intersects the outer wrap

                normal.m_x = r.m_origin.m_x + t0 * r.m_direction.m_x;
                normal.m_y = 0.0;
                normal.m_z = r.m_origin.m_z + t0 * r.m_direction.m_z;
            }
        }

        if(t1 >= 0.0 && t1 < min_t) {
            // The ray intersects the cylinder supporting the outer wrap.

            const Real py = r.m_origin.m_y + t1 * r.m_direction.m_y;

            if(py >= -0.5 && py <= 0.5) {
                min_t = t1; // the ray intersects the outer wrap

                normal.m_x = r.m_origin.m_x + t1 * r.m_direction.m_x;
                normal.m_y = 0.0;
                normal.m_z = r.m_origin.m_z + t1 * r.m_direction.m_z;
            }
        }
    }

    // Test intersection with the inner wrap.

    const Real b1 = sq(r.m_origin.m_x) + sq(r.m_origin.m_z) - m_inner_radius2;  // inner cylinder has custom radius

    const Real delta1 = sq(c) - a * b1;

    if(delta1 >= 0.0) {
        const Real sqrt_delta1 = sqrt(delta1);
        //!\todo Handle the case where a=0.0.
        const Real t0 = (-c - sqrt_delta1) / a;
        const Real t1 = (-c + sqrt_delta1) / a;

        if(t0 >= 0.0 && t0 < min_t) {
            // The ray intersects the cylinder supporting the inner wrap.

            const Real py = r.m_origin.m_y + t0 * r.m_direction.m_y;

            if(py >= -0.5 && py <= 0.5) {
                min_t = t0; // the ray intersects the inner wrap

                normal.m_x = -(r.m_origin.m_x + t0 * r.m_direction.m_x);
                normal.m_y = 0.0;
                normal.m_z = -(r.m_origin.m_z + t0 * r.m_direction.m_z);
            }
        }

        if(t1 >= 0.0 && t1 < min_t) {
            // The ray intersects the cylinder supporting the inner wrap.

            const Real py = r.m_origin.m_y + t1 * r.m_direction.m_y;

            if(py >= -0.5 && py <= 0.5) {
                min_t = t1; // the ray intersects the inner wrap

                normal.m_x = -(r.m_origin.m_x + t1 * r.m_direction.m_x);
                normal.m_y = 0.0;
                normal.m_z = -(r.m_origin.m_z + t1 * r.m_direction.m_z);
            }
        }
    }

    // Test intersection with the upper cap.

    //!\todo Handle the case where r.m_direction.m_y=0.0.
    const Real t0 = (0.5 - r.m_origin.m_y) / r.m_direction.m_y;

    if(t0 >= 0.0 && t0 < min_t) {
        // The ray intersects the plane supporting the upper cap.

        const Real px = r.m_origin.m_x + t0 * r.m_direction.m_x;
        const Real pz = r.m_origin.m_z + t0 * r.m_direction.m_z;
        const Real d2 = sq(px) + sq(pz);    // square of the distance to the Y axis

        if(d2 <= 1.0 && d2 >= m_inner_radius2) {
            min_t = t0; // the ray intersects the upper cap

            normal.m_x = normal.m_z = 0.0;
            normal.m_y = 1.0;
        }
    }

    // Test intersection with the lower cap.

    //!\todo Handle the case where r.m_direction.m_y=0.0.
    const Real t1 = (-0.5 - r.m_origin.m_y) / r.m_direction.m_y;

    if(t1 >= 0.0 && t1 < min_t) {
        // The ray intersects the plane supporting the lower cap.

        const Real px = r.m_origin.m_x + t1 * r.m_direction.m_x;
        const Real pz = r.m_origin.m_z + t1 * r.m_direction.m_z;
        const Real d2 = sq(px) + sq(pz);    // square of the distance to the Y axis

        if(d2 <= 1.0 && d2 >= m_inner_radius2) {
            min_t = t1; // the ray intersects the lower cap

            normal.m_x = normal.m_z = 0.0;
            normal.m_y = -1.0;
        }
    }

    // Conclude.

    if(min_t == std::numeric_limits<Real>::max())
        return false;   // the ray does not intersect the ring

    // The ray does intersect the ring.
    ++context.m_statistics->m_intersections_found;

    if(hit) {
        min_t *= inv_scale;

        hit->m_object = this;
        hit->m_abscissa = min_t;            // world space
        hit->m_geometric_normal = normal;   // object space
        hit->m_shading_normal = normal;     // object space

        // Normals will be made unit-length later, when absolutely necessary.
    }

    return true;
}

---