CURay.h

//
//  CURay.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a 3d ray.
//
//  Because math objects are intended to be on the stack, we do not provide
//  any shared pointer support in this class.
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 6/20/16
 
#ifndef __CU_RAY_H__
#define __CU_RAY_H__
 
#include "CUVec3.h"
#include "CUMat4.h"
 
namespace cugl {
class Ray {
 
#pragma mark Values
public:
    Vec3 origin;
    Vec3 direction;
    
    static const Ray X_AXIS;
    static const Ray Y_AXIS;
    static const Ray Z_AXIS;
 
#pragma mark -
#pragma mark Constructors
public:
    Ray() : direction(Vec3::UNIT_X) { }
 
    Ray (const Vec3& direction) {
        set(Vec3::ZERO,direction);
    }
    
    Ray (const Vec3&  origin, const Vec3& direction) {
        set(origin,direction);
    }
    
    Ray(const Ray& ray) {
        set(ray);
    }
    
    ~Ray() {}
    
    
#pragma mark -
#pragma mark Setters
 
    Ray& operator=(const Ray& ray) {
        return set(ray);
    }
 
    Ray& operator=(const Vec3& direction) {
        return set(direction);
    }
 
    Ray& set(const Ray& ray) {
        origin = ray.origin;
        direction = ray.direction;
        return *this;
    }
 
    Ray& set(const Vec3&  origin, const Vec3& direction) {
        this->origin = origin;
        this->direction  = direction.getNormalization();
        return *this;
    }
    
    Ray& set(const Vec3& direction) {
        origin.setZero();
        this->direction  = direction.getNormalization();
        return *this;
    }
 
#pragma mark -
#pragma mark Static Arithmetic
 
    static Vec3* endpoint(const Ray& ray, float distance, Vec3* dst);
 
    static Ray* multiply(const Ray& ray, const Mat4& mat, Ray* dst);
 
#pragma mark -
#pragma mark Arithmetic
 
    Vec3 getEndpoint(float distance) const {
        return direction*distance+origin;
    }
    
    Ray& multiply(const Mat4& mat) {
        return *(multiply(*this,mat,this));
    }
    
#pragma mark -
#pragma mark Operators
    
    Ray& operator*=(const Mat4& mat) {
        return multiply(mat);
    }
    
    Vec3 operator*(float distance) const {
        return getEndpoint(distance);
    }
 
    const Ray operator*(const Mat4& mat) const {
        Ray result(*this);
        return result.multiply(mat);
    }
    
#pragma mark -
#pragma mark Comparisons
 
    bool operator==(const Ray& r) const {
        return origin == r.origin && direction == r.direction;
    }
    
    bool operator!=(const Ray& r) const {
        return origin != r.origin || direction != r.direction;
    }
    
    bool equals(const Ray& r, float variance=CU_MATH_EPSILON) const {
        return (origin.equals(r.origin,variance) &&
                direction.equals(r.direction,variance));
    }
    
#pragma mark -
#pragma mark Conversion Methods
 
    std::string toString(bool verbose = false) const;
    
    operator std::string() const { return toString(); }
};
 
}
#endif /* __CU_RAY_H__ */