CUVec2.h

//
//  CUVec2.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a 2d vector.  It has support for basic
//  arithmetic, as well as some common line intersection properties.
//
//  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_VEC2_H__
#define __CU_VEC2_H__
 
#include <math.h>
#include <string>
#include <functional>
#include "CUMathBase.h"
 
namespace cugl {
 
// Forward references for conversions
class Size;
class Vec3;
class Vec4;
    
class Vec2 {
    
#pragma mark Values
public:
    float x;
    float y;
    
    static const Vec2 ZERO;
    static const Vec2 ONE;
    static const Vec2 UNIT_X;
    static const Vec2 UNIT_Y;
    
    static const Vec2 ANCHOR_CENTER;
    static const Vec2 ANCHOR_BOTTOM_LEFT;
    static const Vec2 ANCHOR_TOP_LEFT;
    static const Vec2 ANCHOR_BOTTOM_RIGHT;
    static const Vec2 ANCHOR_TOP_RIGHT;
    static const Vec2 ANCHOR_MIDDLE_RIGHT;
    static const Vec2 ANCHOR_MIDDLE_LEFT;
    static const Vec2 ANCHOR_TOP_CENTER;
    static const Vec2 ANCHOR_BOTTOM_CENTER;
 
#pragma mark -
#pragma mark Constructors
public:
    Vec2() : x(0), y(0) { }
 
    Vec2(float x, float y) { this->x = x; this->y = y; }
    
    Vec2(const float* array) { x = array[0]; y = array[1]; }
    
    Vec2(const Vec2& p1, const Vec2& p2) {
        x = p2.x-p1.x; y = p2.y-p1.y;
    }
    
 
#pragma mark -
#pragma mark Setters
 
    Vec2& operator=(const float* array) {
        return set(array);
    }
    
    Vec2& set(float x, float y) {
        this->x = x; this->y = y;
        return *this;
    }
    
    Vec2& set(const float* array) {
        x = array[0]; y = array[1];
        return *this;
    }
    
    Vec2& set(const Vec2& v) {
        x = v.x; y = v.y;
        return *this;
    }
    
    Vec2& set(const Vec2& p1, const Vec2& p2) {
        x = p2.x-p1.x; y = p2.y-p1.y;
        return *this;
    }
    
    Vec2& setZero() {
        x = y = 0;
        return *this;
    }
    
    
#pragma mark -
#pragma mark Static Arithmetic
 
    static Vec2 forAngle(const float a) {
        return Vec2(cosf(a), sinf(a));
    }
    
    static Vec2* clamp(const Vec2& v, const Vec2& min, const Vec2& max, Vec2* dst);
    
    static float angle(const Vec2& v1, const Vec2& v2);
    
    static Vec2* add(const Vec2& v1, const Vec2& v2, Vec2* dst);
 
    static Vec2* subtract(const Vec2& v1, const Vec2& v2, Vec2* dst);
 
    static Vec2* scale(const Vec2& v, float s, Vec2* dst);
    
    static Vec2* scale(const Vec2& v1, const Vec2& v2, Vec2* dst);
    
    static Vec2* divide(const Vec2& v, float s, Vec2* dst);
    
    static Vec2* divide(const Vec2& v1, const Vec2& v2, Vec2* dst);
    
    static Vec2* reciprocate(const Vec2& v, Vec2* dst);
    
    static Vec2* negate(const Vec2& v, Vec2* dst);
    
#pragma mark -
#pragma mark Arithmetic
 
    Vec2& clamp(const Vec2& min, const Vec2& max) {
        x = clampf(x, min.x, max.x);
        y = clampf(y, min.y, max.y);
        return *this;
    }
    
    Vec2 getClamp(const Vec2& min, const Vec2& max) const {
        return Vec2(clampf(x,min.x,max.x), clampf(y, min.y, max.y));
    }
 
    Vec2& add(const Vec2& v) {
        x += v.x; y += v.y;
        return *this;
    }
    
    Vec2& add(float x, float y) {
        this->x += x; this->y += y;
        return *this;
    }
    
    Vec2& subtract(const Vec2& v) {
        x -= v.x; y -= v.y;
        return *this;
    }
    
    Vec2& subtract(float x, float y) {
        this->x -= x; this->y -= y;
        return *this;
    }
    
    Vec2& scale(float s) {
        x *= s; y *= s;
        return *this;
    }
    
    Vec2& scale(float sx, float sy) {
        x *= sx; y *= sy;
        return *this;
    }
    
    Vec2& scale(const Vec2& v) {
        x *= v.x; y *= v.y;
        return *this;
    }
    
    Vec2& divide(float s);
    
    Vec2& divide(float sx, float sy);
    
    Vec2& divide(const Vec2& v);
    
    Vec2& negate() {
        x = -x; y = -y;
        return *this;
    }
 
    Vec2& reciprocate() {
        x = 1.0f/x; y = 1.0f/y;
        return *this;
    }
    
    Vec2 getNegation() const {
        Vec2 result(*this);
        return result.negate();
    }
    
    Vec2 getReciprocal() const {
        Vec2 result(*this);
        return result.reciprocate();
    }
    
    Vec2& map(std::function<float(float)> func) {
        x = func(x); y = func(y);
        return *this;
    }
    
    Vec2 getMap(std::function<float(float)> func) const {
        return Vec2(func(x), func(y));
    }
 
    
#pragma mark -
#pragma mark Operators
 
    Vec2& operator+=(const Vec2& v) {
        return add(v);
    }
 
    Vec2& operator-=(const Vec2& v) {
        return subtract(v);
    }
 
    Vec2& operator*=(float s) {
        return scale(s);
    }
 
    Vec2& operator*=(const Vec2& v) {
        return scale(v);
    }
 
    Vec2& operator/=(float s) {
        return divide(s);
    }
 
    Vec2& operator/=(const Vec2& v) {
        return divide(v);
    }
    
    const Vec2 operator+(const Vec2& v) const {
        Vec2 result(*this);
        return result.add(v);
    }
 
    const Vec2 operator-(const Vec2& v) const  {
        Vec2 result(*this);
        return result.subtract(v);
    }
    
    const Vec2 operator-() const {
        Vec2 result(*this);
        return result.negate();
    }
    
    const Vec2 operator*(float s) const {
        Vec2 result(*this);
        return result.scale(s);
    }
 
    const Vec2 operator*(const Vec2& v) const {
        Vec2 result(*this);
        return result.scale(v);
    }
 
    const Vec2 operator/(float s) const {
        Vec2 result(*this);
        return result.divide(s);
    }
 
    const Vec2 operator/(const Vec2& v) const {
        Vec2 result(*this);
        return result.divide(v);
    }
 
    
#pragma mark -
#pragma mark Comparisons
 
    bool operator<(const Vec2& v) const {
        return (x == v.x ? y < v.y : x < v.x);
    }
 
    bool operator<=(const Vec2& v) const {
        return (x == v.x ? y <= v.y : x <= v.x);
    }
 
    bool operator>(const Vec2& v) const {
        return (x == v.x ? y > v.y : x > v.x);
    }
 
    bool operator>=(const Vec2& v) const {
        return (x == v.x ? y >= v.y : x >= v.x);
    }
 
    bool operator==(const Vec2& v) const {
        return x == v.x && y == v.y;
    }
    
    bool operator!=(const Vec2& v) const {
        return x != v.x || y != v.y;
    }
    
    bool under(const Vec2& v) const {
        return x <= v.x && y <= v.y;
    }
    
    bool over(const Vec2& v) const {
        return x >= v.x && y >= v.y;
    }
    
    bool equals(const Vec2& v, float variance=CU_MATH_EPSILON) const {
        return distanceSquared(v) <= variance*variance;
    }
 
 
#pragma mark -
#pragma mark Linear Attributes
 
    float getAngle() const {
        return atan2f(y, x);
    }
    
    float getAngle(const Vec2& other) const;
    
    bool isZero() const {
        return x == 0.0f && y == 0.0f;
    }
 
    bool isNearZero(float variance=CU_MATH_EPSILON) const {
        return lengthSquared() < variance*variance;
    }
 
    bool isOne() const {
        return x == 1.0f && y == 1.0f;
    }
    
    bool isInvertible() const {
        return x != 0.0f && y != 0.0f;
    }
 
    bool isUnit(float variance=CU_MATH_EPSILON) const {
        float dot = lengthSquared()-1;
        return dot < variance && dot > -variance;
    }
    
    float distance(const Vec2& v) const {
        return sqrt(distanceSquared(v));
    }
    
    float distanceSquared(const Vec2& v) const {
        return (x-v.x)*(x-v.x)+(y-v.y)*(y-v.y);
    }
    
    float length() const {
        return sqrt(lengthSquared());
    }
    
    float lengthSquared() const {
        return x*x+y*y;
    }
    
    
#pragma mark -
#pragma mark Linear Algebra
 
    float dot(const Vec2& v) const { return (x * v.x + y * v.y); }
 
    float cross(const Vec2& other) const {
        return x*other.y - y*other.x;
    }
    
    Vec2& normalize();
    
    Vec2 getNormalization() const {
        Vec2 result(*this);
        return result.normalize();
    }
 
    Vec2& rotate(float angle);
    
    Vec2& rotate(float angle, const Vec2& point);
    
    Vec2& rotate(const Vec2& other) {
        // The const is more of a guideline than a rule.  Must bullet-proof.
        float tx = x; float ty = y;
        float ox = other.x; float oy = other.y;
        x = tx*ox - ty*oy; y = tx*oy + ty*ox;
        return *this;
    }
    
    Vec2& unrotate(const Vec2& other) {
        float tx = x; float ty = y;
        float ox = other.x; float oy = other.y;
        x = tx*ox + ty*oy; y = -tx*oy + ty*ox;
        return *this;
    }
    
    Vec2 getRotation(float angle);
    
    Vec2 getRotation(float angle, const Vec2& point);
    
    Vec2 getRotation(const Vec2& other) {
        return Vec2(x*other.x - y*other.y, x*other.y + y*other.x);
    }
    
    Vec2 getUnrotation(const Vec2& other) {
        return Vec2(x*other.x + y*other.y, y*other.x - x*other.y);
    }
    
    Vec2& perp() {
        float a = x; x = -y; y = a;
        return *this;
    }
 
    Vec2& rperp() {
        float a = x; x = y; y = -a;
        return *this;
    }
    
    Vec2 getPerp() const {
        return Vec2(-y, x);
    }
    
    Vec2 getRPerp() const {
        return Vec2(y, -x);
    }
    
    Vec2 getMidpoint(const Vec2& other) const {
        return Vec2((x + other.x) / 2.0f, (y + other.y) / 2.0f);
    }
 
    Vec2& project(const Vec2& other) {
        *this = getProjection(other);
        return *this;
    }
 
    Vec2 getProjection(const Vec2& other) const {
        return other * (dot(other)/other.dot(other));
    }
 
 
    Vec2& lerp(const Vec2& other, float alpha) {
        *this *= (1.f - alpha);
        return *this += other * alpha;
    }
 
    Vec2 getLerp(const Vec2& other, float alpha) {
        return *this * (1.f - alpha) + other * alpha;
    }
 
 
#pragma mark -
#pragma mark Static Linear Algebra
    
    static float dot(const Vec2& v1, const Vec2& v2);
    
    static float cross(const Vec2& v1, const Vec2& v2);
    
    static Vec2* normalize(const Vec2& v, Vec2* dst);
    
    static Vec2* midpoint(const Vec2& v1, const Vec2& v2, Vec2* dst);
    
    static Vec2* project(const Vec2& v1, const Vec2& v2, Vec2* dst);
    
    static Vec2* lerp(const Vec2& v1, const Vec2& v2, float alpha, Vec2* dst);
    
    static bool doesLineIntersect(const Vec2& A, const Vec2& B,
                                  const Vec2& C, const Vec2& D,
                                  float *S = nullptr, float *T = nullptr);
    
    static bool doesLineOverlap(const Vec2& A, const Vec2& B,
                                const Vec2& C, const Vec2& D);
    
    static bool isLineParallel(const Vec2& A, const Vec2& B,
                               const Vec2& C, const Vec2& D);
    
    static bool doesSegmentIntersect(const Vec2& A, const Vec2& B, const Vec2& C, const Vec2& D);
    
    static bool doesSegmentOverlap(const Vec2& A, const Vec2& B,
                                   const Vec2& C, const Vec2& D,
                                   Vec2* S = nullptr, Vec2* E = nullptr);
    
    static Vec2 getIntersection(const Vec2& A, const Vec2& B, const Vec2& C, const Vec2& D);
 
    
#pragma mark -
#pragma mark Conversion Methods
public:
    std::string toString(bool verbose = false) const;
    
    operator std::string() const { return toString(); }
    
    operator Size() const;
    
    explicit Vec2(const Size& size);
    
    Vec2& operator= (const Size& size);
 
    Vec2& operator+=(const Size& right);
    
    Vec2& operator-=(const Size& right);
 
    const Vec2 operator+(const Size& right) const {
        Vec2 result(*this);
        return result += right;
    }
    
    const Vec2 operator-(const Size& right) const {
        Vec2 result(*this);
        return result -= right;
    }
    
    operator Vec3() const;
    
    explicit Vec2(const Vec3& v);
    
    Vec2& operator= (const Vec3& size);
 
    operator Vec4() const;
    
    explicit Vec2(const Vec4& v);
    
    Vec2& operator= (const Vec4& size);
};
 
 
#pragma mark -
#pragma mark Friend Operations
    
inline const Vec2 operator*(float x, const Vec2& v) {
    Vec2 result(v);
    return result.scale(x);
}
 
typedef Vec2 Point2;
 
}
 
#endif /* __CU_VEC2_H__ */