CUVec3.h

//
//  CUVec3.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a 3d vector.  It has support for basic
//  arithmetic, as well as conversions to color formats.
//
//  Because math objects are intended to be on the stack, we do not provide
//  any shared pointer support in this class.
//
//  This module is based on an original file from GamePlay3D: http://gameplay3d.org.
//  It has been modified to support the CUGL framework.
//
//  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: 5/30/16
#ifndef __CU_VEC3_H__
#define __CU_VEC3_H__

#include <math.h>
#include <functional>
#include <string>
#include "CUMathBase.h"

namespace cugl {

// Forward reference for conversions
class Color4;
class Color4f;
class Vec2;
class Vec4;
    
class  Vec3 {

#pragma mark Values
public:
    float x;
    float y;
    float z;
    
    static const Vec3 ZERO;
    static const Vec3 ONE;
    static const Vec3 UNIT_X;
    static const Vec3 UNIT_Y;
    static const Vec3 UNIT_Z;
    
    
#pragma mark -
#pragma mark Constructors
public:
    Vec3() : x(0), y(0), z(0) {}
    
    Vec3(float x, float y, float z) { this->x = x; this->y = y; this->z = z; }
    
    Vec3(const float* array) { x = array[0]; y = array[1]; z = array[2]; }
    
    Vec3(const Vec3& p1, const Vec3& p2) {
        x = p2.x-p1.x; y = p2.y-p1.y; z = p2.z-p1.z;
    }

    
#pragma mark -
#pragma mark Setters

    Vec3& operator=(const float* array) {
        return set(array);
    }
    
    Vec3& set(float x, float y, float z) {
        this->x = x; this->y = y; this->z = z;
        return *this;
    }

    Vec3& set(const float* array) {
        x = array[0]; y = array[1]; z = array[2];
        return *this;
    }
    
    Vec3& set(const Vec3& v) {
        x = v.x; y = v.y; z = v.z;
        return *this;
    }
    
    Vec3& set(const Vec3& p1, const Vec3& p2) {
        x = p2.x-p1.x; y = p2.y-p1.y; z = p2.z-p1.z;
        return *this;
    }
    
    Vec3& setZero() {
        x = y = z = 0;
        return *this;
    }
    
    
#pragma mark -
#pragma mark Static Arithmetic

    static Vec3* clamp(const Vec3& v, const Vec3& min, const Vec3& max, Vec3* dst);
    
    static float angle(const Vec3& v1, const Vec3& v2, const Vec3& up = Vec3::UNIT_Z);
    
    static Vec3* add(const Vec3& v1, const Vec3& v2, Vec3* dst);
    
    static Vec3* subtract(const Vec3& v1, const Vec3& v2, Vec3* dst);
    
    static Vec3* scale(const Vec3& v, float s, Vec3* dst);
    
    static Vec3* scale(const Vec3& v1, const Vec3& v2, Vec3* dst);
    
    static Vec3* divide(const Vec3& v, float s, Vec3* dst);
    
    static Vec3* divide(const Vec3& v1, const Vec3& v2, Vec3* dst);
    
    static Vec3* reciprocate(const Vec3& v, Vec3* dst);
    
    static Vec3* negate(const Vec3& v, Vec3* dst);
    
#pragma mark -
#pragma mark Arithmetic

    Vec3& clamp(const Vec3& min, const Vec3& max) {
        x = clampf(x, min.x, max.x);
        y = clampf(y, min.y, max.y);
        z = clampf(z, min.z, max.z);
        return *this;
    }
    
    Vec3 getClamp(const Vec3& min, const Vec3& max) const {
        return Vec3(clampf(x,min.x,max.x), clampf(y, min.y, max.y),clampf(z, min.z, max.z));
    }
    
    Vec3& add(const Vec3& v) {
        x += v.x; y += v.y; z += v.z;
        return *this;
    }
    
    Vec3& add(float x, float y, float z) {
        this->x += x; this->y += y; this->z += z;
        return *this;
    }
    
    Vec3& subtract(const Vec3& v) {
        x -= v.x; y -= v.y; z -= v.z;
        return *this;
    }
    
    Vec3& subtract(float x, float y, float z) {
        this->x -= x; this->y -= y; this->z -= z;
        return *this;
    }
    
    Vec3& scale(float s) {
        x *= s; y *= s; z *= s;
        return *this;
    }
    
    Vec3& scale(float sx, float sy, float sz) {
        x *= sx; y *= sy; z *= sz;
        return *this;
    }
    
    Vec3& scale(const Vec3& v) {
        x *= v.x; y *= v.y; z *= v.z;
        return *this;
    }
    
    Vec3& divide(float s);
    
    Vec3& divide(float sx, float sy, float sz);
    
    Vec3& divide(const Vec3& v);
    
    Vec3& negate() {
        x = -x; y = -y; z = -z;
        return *this;
    }
    
    Vec3& reciprocate() {
        x = 1.0f/x; y = 1.0f/y; z = 1.0f/z;
        return *this;
    }
    
    Vec3 getNegation() const {
        Vec3 result(*this);
        return result.negate();
    }
    
    Vec3 getReciprocal() const {
        Vec3 result(*this);
        return result.reciprocate();
    }
        
    Vec3& map(std::function<float(float)> func) {
        x = func(x); y = func(y); z = func(z);
        return *this;
    }
        
    Vec3 getMap(std::function<float(float)> func) const {
        return Vec3(func(x), func(y), func(z));
    }
    
    
#pragma mark -
#pragma mark Operators

    Vec3& operator+=(const Vec3& v) {
        return add(v);
    }
    
    Vec3& operator-=(const Vec3& v) {
        return subtract(v);
    }
    
    Vec3& operator*=(float s) {
        return scale(s);
    }
    
    Vec3& operator*=(const Vec3& v) {
        return scale(v);
    }
    
    Vec3& operator/=(float s) {
        return divide(s);
    }
    
    Vec3& operator/=(const Vec3& v) {
        return divide(v);
    }
    
    const Vec3 operator+(const Vec3& v) const {
        Vec3 result(*this);
        return result.add(v);
    }
    
    const Vec3 operator-(const Vec3& v) const  {
        Vec3 result(*this);
        return result.subtract(v);
    }
    
    const Vec3 operator-() const {
        Vec3 result(*this);
        return result.negate();
    }
    
    const Vec3 operator*(float s) const {
        Vec3 result(*this);
        return result.scale(s);
    }
    
    const Vec3 operator*(const Vec3& v) const {
        Vec3 result(*this);
        return result.scale(v);
    }
    
    const Vec3 operator/(float s) const {
        Vec3 result(*this);
        return result.divide(s);
    }
    
    const Vec3 operator/(const Vec3& v) const {
        Vec3 result(*this);
        return result.divide(v);
    }
    
    
#pragma mark -
#pragma mark Comparisons

    bool operator<(const Vec3& v) const {
        return (x == v.x ? (y == v.y ? z < v.z : y < v.y) : x < v.x);
    }
    
    bool operator<=(const Vec3& v) const {
        return (x == v.x ? (y == v.y ? z <= v.z : y <= v.y) : x <= v.x);
    }
    
    bool operator>(const Vec3& v) const {
        return (x == v.x ? (y == v.y ? z > v.z : y > v.y) : x > v.x);
    }
    
    bool operator>=(const Vec3& v) const {
        return (x == v.x ? (y == v.y ? z >= v.z : y >= v.y) : x >= v.x);
    }
    
    bool operator==(const Vec3& v) const {
        return x == v.x && y == v.y && z == v.z;
    }
    
    bool operator!=(const Vec3& v) const {
        return x != v.x || y != v.y || z != v.z;
    }
    
    bool under(const Vec3& v) const {
        return x <= v.x && y <= v.y && z <= v.z;
    }
    
    bool over(const Vec3& v) const {
        return x >= v.x && y >= v.y && z >= v.z;
    }
    
    bool equals(const Vec3& v, float variance=CU_MATH_EPSILON) const {
        return distanceSquared(v) <= variance*variance;
    }
    
    
#pragma mark -
#pragma mark Linear Attributes

    bool isZero() const {
        return x == 0.0f && y == 0.0f && z == 0.0f;
    }
    
    bool isNearZero(float variance=CU_MATH_EPSILON) const {
        return lengthSquared() < variance*variance;
    }
    
    bool isOne() const {
        return x == 1.0f && y == 1.0f && z == 1.0f;
    }
    
    bool isInvertible() const {
        return x != 0.0f && y != 0.0f && z != 0.0f;
    }
    
    bool isUnit(float variance=CU_MATH_EPSILON) const {
        float dot = lengthSquared()-1;
        return dot < variance && dot > -variance;
    }
    
    float getAngle(const Vec3& other, const Vec3& up = Vec3::UNIT_Z) const;
    
    float distance(const Vec3& v) const {
        return sqrt(distanceSquared(v));
    }
    
    float distanceSquared(const Vec3& v) const {
        return (x-v.x)*(x-v.x)+(y-v.y)*(y-v.y)+(z-v.z)*(z-v.z);
    }

    float length() const {
        return sqrt(lengthSquared());
    }
    
    float lengthSquared() const {
        return x*x+y*y+z*z;
    }

    
#pragma mark -
#pragma mark Linear Algebra

    float dot(const Vec3& v) const { return (x * v.x + y * v.y + z * v.z); }

    Vec3& cross(const Vec3& v) {
        return *(cross(*this,v,this));
    }
    
    Vec3 getCross(const Vec3& other) const {
        Vec3 result(*this);
        return result.cross(other);
    }
    
    Vec3& normalize();
    
    Vec3 getNormalization() const {
        Vec3 result(*this);
        return result.normalize();
    }

    Vec3 getMidpoint(const Vec3& other) const {
        return Vec3((x + other.x) / 2.0f, (y + other.y) / 2.0f, (z + other.z) / 2.0f);
    }
    
    Vec3& project(const Vec3& other) {
        *this = getProjection(other);
        return *this;
    }
    
    Vec3 getProjection(const Vec3& other) const {
        return other * (dot(other)/other.dot(other));
    }

    Vec3& lerp(const Vec3& other, float alpha) {
        *this *= (1.f - alpha);
        return *this += other * alpha;
    }
    
    Vec3 getLerp(const Vec3& other, float alpha) {
        return *this * (1.f - alpha) + other * alpha;
    }
    
    Vec3& smooth(const Vec3& target, float elapsed, float response);

    
#pragma mark -
#pragma mark Static Linear Algebra

    static float dot(const Vec3& v1, const Vec3& v2);
    
    static Vec3* cross(const Vec3& v1, const Vec3& v2, Vec3* dst);

    static Vec3* normalize(const Vec3& v, Vec3* dst);
    
    static Vec3* midpoint(const Vec3& v1, const Vec3& v2, Vec3* dst);
    
    static Vec3* project(const Vec3& v1, const Vec3& v2, Vec3* dst);
    
    static Vec3* lerp(const Vec3& v1, const Vec3& v2, float alpha, Vec3* dst);


#pragma mark -
#pragma mark Conversion Methods
public:
    std::string toString(bool verbose = false) const;
    
    operator std::string() const { return toString(); }
    
    operator Color4() const;
    
    explicit Vec3(Color4 color);
    
    Vec3& operator= (Color4 color);

    operator Color4f() const;
    
    explicit Vec3(const Color4f& color);
    
    Vec3& operator= (const Color4f& color);
    
    operator Vec2() const;
    
    explicit Vec3(const Vec2& v);
    
    Vec3& operator= (const Vec2& v);
    
    operator Vec4() const;
    
    explicit Vec3(const Vec4& v);
    
    Vec3& operator= (const Vec4& size);

};

#pragma mark -
#pragma mark Friend Operations

inline const Vec3 operator*(float x, const Vec3& v) {
    Vec3 result(v);
    return result.scale(x);
}

typedef Vec3 Point3;

}
#endif /* __CU_VEC3_H__ */