mxwcore-wotlk/deps/g3dlite/source/Ray.cpp

/**
 @file Ray.cpp 
 
 @maintainer Morgan McGuire, http://graphics.cs.williams.edu
 
 @created 2002-07-12
 @edited  2004-03-19
 */

#include "G3D/platform.h"
#include "G3D/Ray.h"
#include "G3D/Plane.h"
#include "G3D/Sphere.h"
#include "G3D/CollisionDetection.h"

namespace G3D {

void Ray::set(const Vector3& origin, const Vector3& direction) {
    m_origin = origin;
    m_direction = direction;
    debugAssert(direction.isUnit());
    
    m_invDirection = Vector3::one() / direction;
    
    // ray slope
    ibyj = m_direction.x * m_invDirection.y;
    jbyi = m_direction.y * m_invDirection.x;
    jbyk = m_direction.y * m_invDirection.z;
    kbyj = m_direction.z * m_invDirection.y;
    ibyk = m_direction.x * m_invDirection.z;
    kbyi = m_direction.z * m_invDirection.x;
    
    // precomputed terms
    c_xy = m_origin.y - jbyi * m_origin.x;
    c_xz = m_origin.z - kbyi * m_origin.x;
    c_yx = m_origin.x - ibyj * m_origin.y;
    c_yz = m_origin.z - kbyj * m_origin.y;
    c_zx = m_origin.x - ibyk * m_origin.z;
    c_zy = m_origin.y - jbyk * m_origin.z;    
    
    //ray slope classification
    if (m_direction.x < 0) {
        if (m_direction.y < 0) {
            if (m_direction.z < 0) {
                classification = MMM;
            } else if (m_direction.z > 0) {
                classification = MMP;
            } else { //(m_direction.z >= 0)
                classification = MMO;
            }
        } else { //(m_direction.y >= 0)
            if (m_direction.z < 0) {
                if (m_direction.y == 0) {
                    classification = MOM;
                } else {
                    classification = MPM;
                }
            } else { //(m_direction.z >= 0)
                if ((m_direction.y == 0) && (m_direction.z == 0)) {
                    classification = MOO;
                } else if (m_direction.z == 0) {
                    classification = MPO;
                } else if (m_direction.y == 0) {
                    classification = MOP;
                } else {
                    classification = MPP;
                }
            }
        }
    } else { //(m_direction.x >= 0)
        if (m_direction.y < 0) {
            if (m_direction.z < 0) {
                if (m_direction.x == 0) {
                    classification = OMM;
                } else {
                    classification = PMM;
                }
            } else { //(m_direction.z >= 0)
                if ((m_direction.x == 0) && (m_direction.z == 0)) {
                    classification = OMO;
                } else if (m_direction.z == 0) {
                    classification = PMO;
                } else if (m_direction.x == 0) {
                    classification = OMP;
                } else {
                    classification = PMP;
                }
            }
        } else { //(m_direction.y >= 0)
            if (m_direction.z < 0) {
                if ((m_direction.x == 0) && (m_direction.y == 0)) {
                    classification = OOM;
                } else if (m_direction.x == 0) {
                    classification = OPM;
                } else if (m_direction.y == 0) {
                    classification = POM;
                } else {
                    classification = PPM;
                }
            } else { //(m_direction.z > 0)
                if (m_direction.x == 0) {
                    if (m_direction.y == 0) {
                        classification = OOP;
                    } else if (m_direction.z == 0) {
                        classification = OPO;
                    } else {
                        classification = OPP;
                    }
                } else {
                    if ((m_direction.y == 0) && (m_direction.z == 0)) {
                        classification = POO;
                    } else if (m_direction.y == 0) {
                        classification = POP;
                    } else if (m_direction.z == 0) {
                        classification = PPO;
                    } else {
                        classification = PPP;
                    }
                }
            }            
        }
    }
}


Ray::Ray(class BinaryInput& b) {
    deserialize(b);
}


void Ray::serialize(class BinaryOutput& b) const {
    m_origin.serialize(b);
    m_direction.serialize(b);
}


void Ray::deserialize(class BinaryInput& b) {
    m_origin.deserialize(b);
    m_direction.deserialize(b);
    set(m_origin, m_direction);
}


Ray Ray::refract(
    const Vector3&  newOrigin,
    const Vector3&  normal,
    float           iInside,
    float           iOutside) const {

    Vector3 D = m_direction.refractionDirection(normal, iInside, iOutside);
    return Ray(newOrigin + (m_direction + normal * (float)sign(m_direction.dot(normal))) * 0.001f, D);
}


Ray Ray::reflect(
    const Vector3&  newOrigin,
    const Vector3&  normal) const {

    Vector3 D = m_direction.reflectionDirection(normal);
    return Ray(newOrigin + (D + normal) * 0.001f, D);
}


Vector3 Ray::intersection(const Plane& plane) const {
    float d;
    Vector3 normal = plane.normal();
    plane.getEquation(normal, d);
    float rate = m_direction.dot(normal);

    if (rate >= 0.0f) {
        return Vector3::inf();
    } else {
        float t = -(d + m_origin.dot(normal)) / rate;
        return m_origin + m_direction * t;
    }
}


float Ray::intersectionTime(const class Sphere& sphere, bool solid) const {
    Vector3 dummy;
    return CollisionDetection::collisionTimeForMovingPointFixedSphere(
            m_origin, m_direction, sphere, dummy, dummy, solid);
}


float Ray::intersectionTime(const class Plane& plane) const {
    Vector3 dummy;
    return CollisionDetection::collisionTimeForMovingPointFixedPlane(
            m_origin, m_direction, plane, dummy);
}


float Ray::intersectionTime(const class Box& box) const {
    Vector3 dummy;
    float time = CollisionDetection::collisionTimeForMovingPointFixedBox(
            m_origin, m_direction, box, dummy);

    if ((time == finf()) && (box.contains(m_origin))) {
        return 0.0f;
    } else {
        return time;
    }
}


float Ray::intersectionTime(const class AABox& box) const {
    Vector3 dummy;
    bool inside;
    float time = CollisionDetection::collisionTimeForMovingPointFixedAABox(
            m_origin, m_direction, box, dummy, inside);

    if ((time == finf()) && inside) {
        return 0.0f;
    } else {
        return time;
    }
}

}