CUVec4.h

//
//  CUVec4.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a 4d vector.  It has support for basic
//  arithmetic, as well as conversions to color formats.  It also has
//  homogenous vector support for Vec3.
//
//  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 zlib 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_VEC4_H__
#define __CU_VEC4_H__

// Vectorizaton support
#ifdef CU_MATH_VECTOR_APPLE
    // Need this hack, because Apple dumps Size/Rect into empty namespace
    #define VIMAGE_H
    #include <Accelerate/Accelerate.h>
#endif
#ifdef CU_MATH_VECTOR_SSE
    #include <xmmintrin.h>
#endif

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

namespace cugl {

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

#pragma mark Values
public:
#if defined CU_MATH_VECTOR_APPLE
    union {
        struct {
            float x;
            float y;
            float z;
            float w;
        };
        vFloat v;
    };
#elif defined CU_MATH_VECTOR_SSE
    __declspec(align(16)) union {
        struct {
            float x;
            float y;
            float z;
            float w;
        };
        __m128 v;
    };
#else

    float x;
    float y;
    float z;
    float w;
#endif
    
    static const Vec4 ZERO;
    static const Vec4 ONE;
    static const Vec4 UNIT_X;
    static const Vec4 UNIT_Y;
    static const Vec4 UNIT_Z;
    static const Vec4 UNIT_W;

    // Homogenous constants
    static const Vec4 HOMOG_ORIGIN;
    static const Vec4 HOMOG_X;
    static const Vec4 HOMOG_Y;
    static const Vec4 HOMOG_Z;
    
#pragma mark -
#pragma mark Constructors
public:
    Vec4() : x(0), y(0), z(0), w(0) {}
    
    Vec4(float x, float y, float z, float w) {
        this->x = x; this->y = y; this->z = z; this->w = w;
    }
    
    Vec4(const float* array) {
#if defined CU_MATH_VECTOR_APPLE
        v = *((vFloat*)array);
#else
        x = array[0]; y = array[1]; z = array[2]; w = array[3];
#endif
    }
    
    Vec4(const Vec4& p1, const Vec4& p2) {
#if defined CU_MATH_VECTOR_APPLE
        v = p2.v-p1.v;
#else
        x = p2.x-p1.x; y = p2.y-p1.y; z = p2.z-p1.z; w = p2.w-p1.w;
#endif
    }
    
    
#pragma mark -
#pragma mark Setters

    Vec4& operator=(const float* array) {
        return set(array);
    }
    
    Vec4& set(float x, float y, float z, float w) {
        this->x = x; this->y = y; this->z = z; this->w = w;
        return *this;
    }
    
    Vec4& set(const float* array) {
#if defined CU_MATH_VECTOR_APPLE
        v = *((vFloat*)array);
#else
        x = array[0]; y = array[1]; z = array[2]; w = array[3];
#endif
        return *this;
    }
    
    Vec4& set(const Vec4& v) {
#if defined CU_MATH_VECTOR_APPLE
        this->v = v.v;
#else
        x = v.x; y = v.y; z = v.z; w = v.w;
#endif
        return *this;
    }
    
    Vec4& set(const Vec4& p1, const Vec4& p2) {
#if defined CU_MATH_VECTOR_APPLE
        v = p2.v-p1.v;
#else
        x = p2.x-p1.x; y = p2.y-p1.y; z = p2.z-p1.z; w = p2.w-p1.w;
#endif
        return *this;
    }
    
    Vec4& setZero() {
        x = y = z = w = 0;
        return *this;
    }
    
    
#pragma mark -
#pragma mark Static Arithmetic

    static Vec4* clamp(const Vec4& v, const Vec4& min, const Vec4& max, Vec4* dst);
    
    static float angle(const Vec4& v1, const Vec4& v2);
    
    static Vec4* add(const Vec4& v1, const Vec4& v2, Vec4* dst);
    
    static Vec4* subtract(const Vec4& v1, const Vec4& v2, Vec4* dst);

    static Vec4* scale(const Vec4& v, float s, Vec4* dst);
    
    static Vec4* scale(const Vec4& v1, const Vec4& v2, Vec4* dst);

    static Vec4* divide(const Vec4& v, float s, Vec4* dst);
    
    static Vec4* divide(const Vec4& v1, const Vec4& v2, Vec4* dst);

    static Vec4* reciprocate(const Vec4& v, Vec4* dst);
    
    static Vec4* negate(const Vec4& v, Vec4* dst);
    
    
#pragma mark -
#pragma mark Arithmetic

    Vec4& clamp(const Vec4& min, const Vec4& max);
    
    Vec4 getClamp(const Vec4& min, const Vec4& max) const {
        return Vec4(clampf(x,min.x,max.x), clampf(y,min.y,max.y),
                    clampf(z,min.z,max.z), clampf(w,min.w,max.w));
    }
    
    Vec4& add(const Vec4& v) {
#if defined CU_MATH_VECTOR_APPLE
        this->v += v.v;
#else
        x += v.x; y += v.y; z += v.z; w += v.w;
#endif
        return *this;
    }
    
    Vec4& add(float x, float y, float z, float w) {
        this->x += x; this->y += y; this->z += z; this->w += w;
        return *this;
    }
    
    Vec4& subtract(const Vec4& v) {
#if defined CU_MATH_VECTOR_APPLE
        this->v -= v.v;
#else
        x -= v.x; y -= v.y; z -= v.z;  w -= v.w;
#endif
        return *this;
    }
    
    Vec4& subtract(float x, float y, float z, float w) {
        this->x -= x; this->y -= y; this->z -= z; this->w -= w;
        return *this;
    }
    
    Vec4& scale(float s) {
#if defined CU_MATH_VECTOR_APPLE
        vSscal(4, s, &v);
#else
        x *= s; y *= s; z *= s; w *= s;
#endif
        return *this;
    }
    
    Vec4& scale(float sx, float sy, float sz, float sw) {
        x *= sx; y *= sy; z *= sz; w *= sw;
        return *this;
    }
    
    Vec4& scale(const Vec4& v) {
#if defined CU_MATH_VECTOR_APPLE
        this->v *= v.v;
#else
        x *= v.x; y *= v.y; z *= v.z; w *= v.w;
#endif
        return *this;
    }
    
    Vec4& divide(float s);
    
    Vec4& divide(float sx, float sy, float sz, float sw);
    
    Vec4& divide(const Vec4& v);
    
    Vec4& negate() {
        x = -x; y = -y; z = -z; w = -w;
        return *this;
    }

    Vec4& reciprocate() {
        x = 1.0f/x; y = 1.0f/y; z = 1.0f/z; w = 1.0f/w;
        return *this;
    }

    Vec4 getNegation() const {
        Vec4 result(*this);
        return result.negate();
    }

    Vec4 getReciprocal() const {
        Vec4 result(*this);
        return result.reciprocate();
    }
    
    Vec4& map(std::function<float(float)> func) {
        x = func(x); y = func(y); z = func(z); w = func(w);
        return *this;
    }
    
    Vec4 getMap(std::function<float(float)> func) const {
        return Vec4(func(x), func(y), func(z), func(w));
    }
    
    
#pragma mark -
#pragma mark Operators

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

    bool operator<(const Vec4& v) const {
        return (x == v.x ? (y == v.y ? (z == v.z ? w < v.w : z < v.z) : y < v.y) : x < v.x);
    }
    
    bool operator<=(const Vec4& v) const {
        return (x == v.x ? (y == v.y ? (z == v.z ? w <= v.w : z <= v.z) : y <= v.y) : x <= v.x);
    }
    
    bool operator>(const Vec4& v) const {
        return (x == v.x ? (y == v.y ? (z == v.z ? w > v.w : z > v.z) : y > v.y) : x > v.x);
    }
    
    bool operator>=(const Vec4& v) const {
        return (x == v.x ? (y == v.y ? (z == v.z ? w >= v.w : z >= v.z) : y >= v.y) : x >= v.x);
    }
    
    bool operator==(const Vec4& v) const {
        return x == v.x && y == v.y && z == v.z && w == v.w;
    }
    
    bool operator!=(const Vec4& v) const {
        return x != v.x || y != v.y || z != v.z || w != v.w;
    }
    
    bool under(const Vec4& v) const {
        return x <= v.x && y <= v.y && z <= v.z && w <= v.w;
    }
    
    bool over(const Vec4& v) const {
        return x >= v.x && y >= v.y && z >= v.z && w >= v.w;
    }
    
    bool equals(const Vec4& 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 && w == 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 && w == 1.0f;
    }

    bool isInvertible() const {
        return x != 0.0f && y != 0.0f && z != 0.0f && w != 0.0f;
    }
    
    bool isUnit(float variance=CU_MATH_EPSILON) const {
        float dot = length()-1.0f;
        return dot <= variance && dot >= -variance;
    }
    
    bool isHomogenous() const {
        return w == 1.0f;
    }
    
    float getAngle(const Vec4& other) const;
    
    float distance(const Vec4& v) const {
#if defined CU_MATH_VECTOR_APPLE
        vFloat nv = this->v-v.v;
        return vSnorm2(4, &nv);
#else
        return sqrt(distanceSquared(v));
#endif
    }
    
    float distanceSquared(const Vec4& v) const {
#if defined CU_MATH_VECTOR_APPLE
        vFloat nv = this->v-v.v;
        return vSdot(4, &nv, &nv);
#else
        return (x-v.x)*(x-v.x)+(y-v.y)*(y-v.y)+(z-v.z)*(z-v.z)+(w-v.w)*(w-v.w);
#endif
    }
    
    float length() const {
#if defined CU_MATH_VECTOR_APPLE
        return vSnorm2(4, &v);
#else
        return sqrt(lengthSquared());
#endif
    }
    
    float lengthSquared() const {
#if defined CU_MATH_VECTOR_APPLE
        return vSdot(4, &v, &v);
#else
        return x*x+y*y+z*z+w*w;
#endif
    }
    
    
#pragma mark -
#pragma mark Linear Algebra

    float dot(const Vec4& v) const {
#if defined CU_MATH_VECTOR_APPLE
        return vSdot(4, &(this->v), &(v.v));
#else
        return (x * v.x + y * v.y + z * v.z + w * v.w);
#endif
    }
    
    Vec4& normalize();
    
    Vec4 getNormalization() const {
        Vec4 result(*this);
        return result.normalize();
    }
    
    Vec4 getMidpoint(const Vec4& other) const {
        Vec4 result;
        midpoint(*this,other, &result);
        return result;
    }
    
    Vec4& project(const Vec4& other) {
        *this = getProjection(other);
        return *this;
    }
    
    Vec4 getProjection(const Vec4& other) const {
        return other * (dot(other)/other.dot(other));
    }
    
    Vec4& homogenize() {
        float dw = (w == 0 ? 1 : 1/w);
        *this *= dw; w = 1;
        return *this;
    }
    
    Vec4 getHomogenized() {
        Vec4 copy(*this);
        copy.homogenize();
        return copy;
    }
    
    Vec4& lerp(const Vec4& other, float alpha) {
        *this *= (1.f - alpha);
        return *this += other * alpha;
    }
    
    Vec4 getLerp(const Vec4& other, float alpha) {
        return *this * (1.f - alpha) + other * alpha;
    }
    
    void smooth(const Vec4& target, float elapsed, float response);
    
    
#pragma mark -
#pragma mark Static Linear Algebra

    static float dot(const Vec4& v1, const Vec4& v2);

    static Vec4* normalize(const Vec4& v, Vec4* dst);
    
    static Vec4* homogenize(const Vec4& v, Vec4* dst);
    
    static Vec4* midpoint(const Vec4& v1, const Vec4& v2, Vec4* dst);
    
    static Vec4* project(const Vec4& v1, const Vec4& v2, Vec4* dst);
    
    static Vec4* lerp(const Vec4& v1, const Vec4& v2, float alpha, Vec4* 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 Vec4(Color4 color);
    
    Vec4& operator= (Color4 color);
    
    operator Color4f() const;
    
    explicit Vec4(const Color4f& color);
    
    Vec4& operator= (const Color4f& color);
    
    operator Vec2() const;
    
    explicit Vec4(const Vec2& v);
    
    Vec4& operator= (const Vec2& size);
    
    operator Vec3() const;
    
    explicit Vec4(const Vec3& v);

    Vec4(const Vec3& v, float w);

    Vec4& operator= (const Vec3& v);
    
    Vec4& set(const Vec3& v, float w);
};
    
    
#pragma mark -
#pragma mark Friend Operations

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

}

#endif /* __CU_VEC4_H__ */