CUColor4.h

//
//  CUColor4.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a standard colors.  It provides both a
//  float based color solution and a byte-based color solution.  The former
//  is better for blending and calculations.  The later is better for storage.
//
//  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_COLOR4_H__
#define __CU_COLOR4_H__

#include <math.h>
#include <functional>
#include "CUMathBase.h"
#include "../base/CUEndian.h"

#define COLOR_BYTE_TO_FLOAT(x)       ( static_cast<float>(x)/255.0f )

#define COLOR_FLOAT_TO_BYTE(x)       ( static_cast<int>(roundf(x*255.0f)) )

namespace cugl {
    
// Forward references to the classes we convert to
class Color4;
class Vec3;
class Vec4;
    
#pragma mark -
#pragma mark Color with Float Attributes
    
class Color4f {
        
#pragma mark Values
public:
    GLfloat r;
    GLfloat g;
    GLfloat b;
    GLfloat a;
    
    static const Color4f CLEAR;
    static const Color4f WHITE;
    static const Color4f BLACK;
    static const Color4f YELLOW;
    static const Color4f BLUE;
    static const Color4f GREEN;
    static const Color4f RED;
    static const Color4f MAGENTA;
    static const Color4f CYAN;
    static const Color4f ORANGE;
    static const Color4f GRAY;
    static const Color4f CORNFLOWER;
    static const Color4f PAPYRUS;
    
#pragma mark Constructors
public:
    Color4f() : r(0), g(0), b(0), a(0) {}
        
    Color4f(float r, float g, float b, float a = 1);
        
    Color4f(GLuint color);
    
    Color4f(const Color4f& copy) {
        r = copy.r; g = copy.g; b = copy.b; a = copy.a;
    }
        
    Color4f(const float* array);
        
    ~Color4f() {}
        
        
#pragma mark Setters

    Color4f& operator=(const Color4f& c) {
        return set(c);
    }
        
    Color4f& operator=(unsigned int color) {
        return set(color);
    }
        
    Color4f& operator=(const float* array) {
        return set(array);
    }
        
    Color4f& set(float r, float g, float b, float a = 1);
        
    Color4f& set(const float* array);
        
    Color4f& set(GLuint color);
    
    Color4f& set(const Color4f& c) {
        r = c.r; g = c.g; b = c.b; a = c.a;
        return *this;
    }
        
        
#pragma mark Arithmetic

    Color4f& clamp(const Color4f& min, const Color4f& max);
        
    Color4f getClamp(const Color4f& min, const Color4f& max) const {
        return Color4f(clampf(r,min.r,max.r), clampf(g,min.g,max.g),
                       clampf(b,min.b,max.b), clampf(a,min.a,max.a));
    }
        
    Color4f& add(const Color4f& c, bool alpha = false) {
        r = clampf(r+c.r,0.0,1.0);
        g = clampf(g+c.g,0.0,1.0);
        b = clampf(b+c.b,0.0,1.0);
        a = (alpha ? clampf(a+c.a,0.0,1.0) : a);
        return *this;
    }
        
    Color4f& add(float r, float g, float b, float a = 0) {
        this->r = clampf(this->r+r,0.0,1.0);
        this->g = clampf(this->g+g,0.0,1.0);
        this->b = clampf(this->b+b,0.0,1.0);
        this->a = clampf(this->a+a,0.0,1.0);
        return *this;
    }
        
    Color4f& subtract(const Color4f& c, bool alpha = false) {
        r = clampf(r-c.r,0.0,1.0);
        g = clampf(g-c.g,0.0,1.0);
        b = clampf(b-c.b,0.0,1.0);
        a = (alpha ? clampf(a-c.a,0.0,1.0) : a);
        return *this;
    }
        
    Color4f& subtract(float r, float g, float b, float a = 0) {
        this->r = clampf(this->r-r,0.0,1.0);
        this->g = clampf(this->g-g,0.0,1.0);
        this->b = clampf(this->b-b,0.0,1.0);
        this->a = clampf(this->a-a,0.0,1.0);
        return *this;
    }
        
    Color4f& scale(float s, bool alpha = false) {
        r = clampf(r*s,0.0,1.0);
        g = clampf(g*s,0.0,1.0);
        b = clampf(b*s,0.0,1.0);
        a = (alpha ? clampf(a*s,0.0,1.0) : a);
        return *this;
    }
        
    Color4f& scale(float sr, float sg, float sb, float sa = 1) {
            r = clampf(r*sr,0.0,1.0);
            g = clampf(g*sg,0.0,1.0);
            b = clampf(b*sb,0.0,1.0);
            a = clampf(a*sa,0.0,1.0);
            return *this;
        }
        
    Color4f& scale(const Color4f& c, bool alpha = false) {
        r *= c.r; g *= c.g; b *= c.b;
        a = (alpha ? a*c.a : a);
        return *this;
    }
        
    Color4f& map(std::function<float(float)> func, bool alpha = false) {
        r = clampf(func(r),0,1); g = clampf(func(g),0,1); b = clampf(func(b),0,1);
        a = (alpha ? clampf(func(a),0,1) : a);
        return *this;
    }
        
    Color4f getMap(std::function<float(float)> func, bool alpha = false) const {
        return Color4f(clampf(func(r),0,1), clampf(func(g),0,1),
                       clampf(func(b),0,1), (alpha ? clampf(func(a),0,1) : a));
    }

    
#pragma mark Color Operations

    Color4f& complement(bool alpha = false) {
        r = 1-r; g = 1-g; b = 1-b; a = (alpha ? 1-a : a);
        return *this;
    }
    
    Color4f getComplement(bool alpha = false) const {
        return Color4f(1-r, 1-g, 1-b, (alpha ? 1-a : a));
    }
    
    Color4f& lerp(const Color4f& other, float alpha) {
        float x = clampf(alpha,0,1);
        *this *= (1.f - x);
        return *this += other * x;
    }
    
    Color4f& blend(const Color4f& other) {
        float a1 = a*(1-other.a);
        float a2 = other.a+a1;
        r = (other.r*other.a+r*a1)/a2;
        g = (other.g*other.a+g*a1)/a2;
        b = (other.b*other.a+b*a1)/a2;
        a = a2;
        return *this;
    }
    
    Color4f& blendPre(const Color4f& other) {
        a = other.a+a*(1-other.a);
        r = other.r+r*(1-other.a);
        g = other.g+g*(1-other.a);
        b = other.b+b*(1-other.a);
        return *this;
    }
    
    Color4f& premultiply() {
        r *= a; g *= a; b *= a;
        return *this;
    }

    Color4f& unpremultiply() {
        if (a > 0) {
            r /= a; g /= a; b /= a;
        }
        return *this;
    }
    
    Color4f getLerp(const Color4f& other, float alpha) const {
        float x = clampf(alpha,0,1);
        return *this * (1.f - x) + other * x;
    }

    Color4f getBlend(const Color4f& other) const {
        float a1 = a*(1-other.a);
        float a2 = other.a+a1;
        return Color4f((other.r*other.a+r*a1)/a2,
                       (other.g*other.a+g*a1)/a2,
                       (other.b*other.a+b*a1)/a2,
                       a2);
    }
    
    Color4f getBlendPre(const Color4f& other) const {
        float oa = other.a+a*(1-other.a);
        return Color4f((other.r+r*(1-other.a)), (other.g+g*(1-other.a)),
                       (other.b+b*(1-other.a)), oa);
    }
    
    Color4f getPremultiplied() const {
        return Color4f(r*a,g*a,b*a,a);
    }
    
    Color4f getUnpremultiplied() const {
        if (a > 0) {
            return Color4f(r/a,g/a,b/a,a);
        }
        return *this;
    }
    
    static Color4f* lerp(const Color4f& c1, const Color4f& c2, float alpha, Color4f* dst);
    
    static Color4f* blend(const Color4f& c1, const Color4f& c2, Color4f* dst);
    
    static Color4f* blendPre(const Color4f& c1, const Color4f& c2, Color4f* dst);
    
    GLuint getRGBA() const;
    
#pragma mark Operators

    Color4f& operator+=(const Color4f& c) {
        r = clampf(r+c.r,0.0,1.0);
        g = clampf(g+c.g,0.0,1.0);
        b = clampf(b+c.b,0.0,1.0);
        a = clampf(a+c.a,0.0,1.0);
        return *this;
    }
        
    Color4f& operator-=(const Color4f& c) {
        r = clampf(r-c.r,0.0,1.0);
        g = clampf(g-c.g,0.0,1.0);
        b = clampf(b-c.b,0.0,1.0);
        a = clampf(a-c.a,0.0,1.0);
        return *this;
    }
        
    Color4f& operator*=(float s) {
        r = clampf(r*s,0.0,1.0);
        g = clampf(g*s,0.0,1.0);
        b = clampf(b*s,0.0,1.0);
        a = clampf(a*s,0.0,1.0);
        return *this;
    }
        
    Color4f& operator*=(const Color4f& c) {
        r *= c.r; g *= c.g; b *= c.b; a *= c.a;
        return *this;
    }
        
    const Color4f operator+(const Color4f& c) const {
        Color4f result(*this);
        return result += c;
    }
        
    const Color4f operator-(const Color4f& c) const  {
        Color4f result(*this);
        return result -= c;
    }
    
    const Color4f operator*(float s) const {
        Color4f result(*this);
        return result *= s;
    }
    
    const Color4f operator*(const Color4f& c) const {
        Color4f result(*this);
        return result *= c;
    }
        
        
#pragma mark Comparisons

    bool operator<(const Color4f& c) const;
        
    bool operator<=(const Color4f& c) const {
        return *this < c || *this == c;
    }
        
    bool operator>(const Color4f& c) const;
        
    bool operator>=(const Color4f& c) const {
        return *this > c || *this == c;
    }
        
    bool operator==(const Color4f& c) const {
        return r == c.r && g == c.g && b == c.b && a == c.a;
    }
        
    bool operator!=(const Color4f& c) const {
        return r != c.r || g != c.g || b != c.b || a != c.a;
    }
        
    bool darkerThan(const Color4f& c) const {
        return r <= c.r &&  g <= c.g && b <= c.b && c.a <= a;
    }
        
    bool lighterThan(const Color4f& c) const {
        return r >= c.r && g >= c.g && b >= c.b && c.a >= a;
    }
        
    bool equals(const Color4f& color, float variance=CU_MATH_EPSILON) const {
        return (fabsf(r-color.r) < variance && fabsf(g-color.g) < variance &&
                fabsf(b-color.b) < variance && fabsf(a-color.a) < variance);
    }
        
        
#pragma mark Conversion Methods
public:
    std::string toString(bool verbose = false) const;
        
    operator std::string() const { return toString(); }
        
    operator Vec4() const;
        
    explicit Color4f(const Vec4& vector);
        
    Color4f& operator= (const Vec4& vector);
    
    operator Vec3() const;
    
    explicit Color4f(const Vec3& vector);
    
    Color4f& operator= (const Vec3& vector);
    
    operator Color4() const;
        
    explicit Color4f(Color4 color);
        
    Color4f& operator= (Color4 color);
};
  

#pragma mark -
#pragma mark Color with Byte Attributes
    
class Color4 {
        
#pragma mark Values
public:
union {
    struct {
        GLubyte r;
        GLubyte g;
        GLubyte b;
        GLubyte a;
    };
    Uint32 rgba;
};
    
    static const Color4 CLEAR;
    static const Color4 WHITE;
    static const Color4 BLACK;
    static const Color4 YELLOW;
    static const Color4 BLUE;
    static const Color4 GREEN;
    static const Color4 RED;
    static const Color4 MAGENTA;
    static const Color4 CYAN;
    static const Color4 ORANGE;
    static const Color4 GRAY;
    static const Color4 CORNFLOWER;
    static const Color4 PAPYRUS;
    
        
#pragma mark Constructors
public:
    Color4() : rgba(0) {}
        
    Color4(GLubyte r, GLubyte g, GLubyte b, GLubyte a = 255) {
        this->r = r; this->g = g; this->b = b; this->a = a;
    }
        
    Color4(GLuint color) { set(color); }
        
    Color4(const float* array);
        
    ~Color4() {}
        
        
#pragma mark Setters        

    Color4& operator=(GLuint color) {
        return set(color);
    }
        
    Color4& operator=(const float* array) {
        return set(array);
    }
        
    Color4& set(GLubyte r, GLubyte g, GLubyte b, GLubyte a = 255) {
        this->r = r; this->g = g; this->b = b; this->a = a;
        return *this;
    }
        
    Color4& set(const float* array);
        
    Color4& set(GLuint color) {
        rgba = marshall(color);
        return *this;
    }
        
    Color4& set(const Color4& c) {
        rgba = c.rgba;
        return *this;
    }
        
        
#pragma mark Arithmetic

    Color4& clamp(Color4 min, Color4 max);
        
    Color4 getClamp(Color4 min, Color4 max) const {
        return Color4(clampb(r,min.r,max.r), clampb(g,min.g,max.g),
                     clampb(b,min.b,max.b), clampb(a,min.a,max.a));
    }
        
    
    Color4& add(Color4 c, bool alpha = false) {
        r = clampb(r+c.r,0,255);
        g = clampb(g+c.g,0,255);
        b = clampb(b+c.b,0,255);
        a = (alpha ? clampb(a+c.a,0,255) : a);
        return *this;
    }
        
    Color4& add(GLubyte r, GLubyte g, GLubyte b, GLubyte a = 0) {
        this->r = clampb(this->r+r,0,255);
        this->g = clampb(this->g+g,0,255);
        this->b = clampb(this->b+b,0,255);
        this->a = clampb(this->a+a,0,255);
        return *this;
    }
        
    Color4& subtract(Color4 c, bool alpha = false) {
        r = clampb(r-c.r,0,255);
        g = clampb(g-c.g,0,255);
        b = clampb(b-c.b,0,255);
        a = (alpha ? clampb(a-c.a,0,255) : a);
        return *this;
    }
        
    Color4& subtract(GLubyte r, GLubyte g, GLubyte b, GLubyte a = 0) {
        this->r = clampb(this->r-r,0,255);
        this->g = clampb(this->g-g,0,255);
        this->b = clampb(this->b-b,0,255);
        this->a = clampb(this->a-a,0,255);
        return *this;
    }
    
    Color4& scale(float s, bool alpha = false) {
        r = clampb(static_cast<GLubyte>(r*s),0,255);
        g = clampb(static_cast<GLubyte>(g*s),0,255);
        b = clampb(static_cast<GLubyte>(b*s),0,255);
        a = (alpha ? clampb(static_cast<GLubyte>(a*s),0,255) : a);
        return *this;
    }
        
    Color4& scale(float sr, float sg, float sb, float sa = 1) {
        r = clampb(static_cast<GLuint>(r*sr),0,255);
        g = clampb(static_cast<GLuint>(g*sg),0,255);
        b = clampb(static_cast<GLuint>(b*sb),0,255);
        a = clampb(static_cast<GLuint>(a*sa),0,255);
        return *this;
    }
    
    Color4& scale(Color4 c, bool alpha = false) {
         r = clampb(static_cast<GLuint>(COLOR_BYTE_TO_FLOAT(c.r)*r),0,255);
         g = clampb(static_cast<GLuint>(COLOR_BYTE_TO_FLOAT(c.g)*g),0,255);
         b = clampb(static_cast<GLuint>(COLOR_BYTE_TO_FLOAT(c.b)*b),0,255);
         a = (alpha ?  clampb(static_cast<GLuint>(COLOR_BYTE_TO_FLOAT(c.a)*a),0,255) : a);
         return *this;
    }

    Color4& map(std::function<GLubyte(GLubyte)> func, bool alpha = false) {
        r = func(r); g = func(g); b = func(b);
        a = (alpha ? func(a) : a);
        return *this;
    }
    
    Color4 getMap(std::function<GLubyte(GLubyte)> func, bool alpha = false) const {
        return Color4(func(r),func(g),func(b),(alpha ? func(a) : a));
    }

    
#pragma mark Color4 Operations

    Color4& complement(bool alpha = false) {
        r = 255-r; g = 255-g; b = 255-b; a = (alpha ? 255-a : a);
        return *this;
    }
    
    Color4 getComplement(bool alpha = false) const {
        return Color4(255-r, 255-g, 255-b, (alpha ? 255-a : a));
    }
    
    Color4& lerp(const Color4f& other, float alpha) {
        float x = clampf(alpha,0,1);
        *this *= (1.f - x);
        return *this += other * x;
    }
    
    Color4& blend(Color4 other) {
        float srca = COLOR_BYTE_TO_FLOAT(other.a);
        float a1 = COLOR_BYTE_TO_FLOAT(a)*(1-srca);
        float a2 = srca+a1;
        r = clampb((GLubyte)((other.r*srca+r*a1)/a2),0,255);
        g = clampb((GLubyte)((other.g*srca+g*a1)/a2),0,255);
        b = clampb((GLubyte)((other.b*srca+b*a1)/a2),0,255);
        a = COLOR_FLOAT_TO_BYTE(a2);
        return *this;
    }
    
    Color4& blendPre(Color4 other) {
        float srca = COLOR_BYTE_TO_FLOAT(other.a);
        float a1 = srca+COLOR_BYTE_TO_FLOAT(a)*(1-srca);
        r = clampb((GLubyte)(other.r+r*(1-srca)),0,255);
        g = clampb((GLubyte)(other.g+g*(1-srca)),0,255);
        b = clampb((GLubyte)(other.b+b*(1-srca)),0,255);
        a = COLOR_FLOAT_TO_BYTE(a1);
        return *this;
    }
    
    Color4& premultiply() {
        scale(COLOR_BYTE_TO_FLOAT(a),false);
        return *this;
    }
    
    Color4& unpremultiply() {
        if (a > 0) {
            float a1 = 1/COLOR_BYTE_TO_FLOAT(a);
            scale(a1,false);
        }
        return *this;
    }
    
    Color4 getLerp(Color4 other, float alpha) const {
        float x = clampf(alpha,0,1);
        return *this * (1.f - x) + other * x;
    }
    
    Color4 getBlend(Color4 other) const {
        float srca = COLOR_BYTE_TO_FLOAT(other.a);
        float a1 = COLOR_BYTE_TO_FLOAT(a)*(1-srca);
        float a2 = srca+a1;
        return Color4(clampb((GLubyte)((other.r*srca+r*a1)/a2), 0, 255),
                      clampb((GLubyte)((other.g*srca+g*a1)/a2), 0, 255),
                      clampb((GLubyte)((other.b*srca+b*a1)/a2), 0, 255),
                      COLOR_FLOAT_TO_BYTE(a2));
    }
    
    Color4f getBlendPre(Color4 other) const {
        float srca = COLOR_BYTE_TO_FLOAT(other.a);
        float dsta = COLOR_BYTE_TO_FLOAT(a);
        float a1 = srca+dsta*(1-srca);
        return Color4(clampb((GLubyte)(other.r+r*(1-srca)),0,255),
                      clampb((GLubyte)(other.g+g*(1-srca)),0,255),
                      clampb((GLubyte)(other.b+b*(1-srca)),0,255),
                      COLOR_FLOAT_TO_BYTE(a1));
    }
    
    Color4 getPremultiplied() const {
        Color4 result(r,g,b,255);
        result *= COLOR_BYTE_TO_FLOAT(a);
        return result;
    }
    
    Color4 getUnpremultiplied() const {
        if (a > 0) {
            float a1 = 1/COLOR_BYTE_TO_FLOAT(a);
            Color4 result(*this);
            return result.scale(a1,false);
        }
        return *this;
    }
    
    static Color4* lerp(Color4 c1, Color4 c2, float alpha, Color4* dst);
    
    static Color4* blend(Color4 c1, Color4 c2, Color4* dst);
    
    static Color4* blendPre(Color4 c1, Color4 c2, Color4* dst);
    
    GLuint getRGBA() const {
        return marshall(rgba);
    }
    
#pragma mark Operators

    Color4& operator+=(Color4 c) {
        r = clampb(r+c.r,0,255);
        g = clampb(g+c.g,0,255);
        b = clampb(b+c.b,0,255);
        a = clampb(a+c.a,0,255);
        return *this;
    }
        
    Color4& operator-=(Color4 c) {
        r = clampb(r-c.r,0,255);
        g = clampb(g-c.g,0,255);
        b = clampb(b-c.b,0,255);
        a = clampb(a-c.a,0,255);
        return *this;
    }
        
    Color4& operator*=(float s) {
        r = clampb(static_cast<GLubyte>(r*s),0,255);
        g = clampb(static_cast<GLubyte>(g*s),0,255);
        b = clampb(static_cast<GLubyte>(b*s),0,255);
        a = clampb(static_cast<GLubyte>(a*s),0,255);
        return *this;
    }
        
    Color4& operator*=(Color4 c) {
        r = clampb(static_cast<GLuint>(COLOR_BYTE_TO_FLOAT(c.r)*r),0,255);
        g = clampb(static_cast<GLuint>(COLOR_BYTE_TO_FLOAT(c.g)*g),0,255);
        b = clampb(static_cast<GLuint>(COLOR_BYTE_TO_FLOAT(c.b)*b),0,255);
        a = clampb(static_cast<GLuint>(COLOR_BYTE_TO_FLOAT(c.a)*a),0,255);
        return *this;
    }
        
    const Color4 operator+(Color4 c) const {
        Color4 result(*this);
        return result += c;
    }
        
    const Color4 operator-(Color4 c) const  {
        Color4 result(*this);
        return result -= c;
    }
        
    const Color4 operator*(float s) const {
        Color4 result(*this);
        return result *= s;
    }
        
    const Color4 operator*(Color4 c) const {
        Color4 result(*this);
        return result *= c;
    }
        
        
#pragma mark Comparisons

    bool operator<(Color4 c) const;
    
    bool operator<=(Color4 c) const {
        return *this < c || rgba == c.rgba;
    }
        
    bool operator>(Color4 c) const;
    
    bool operator>=(Color4 c) const {
        return *this > c || rgba == c.rgba;
    }
        
    bool operator==(Color4 c) const {
        return rgba == c.rgba;
    }
        
    bool operator!=(Color4 c) const {
        return rgba != c.rgba;
    }
        
    bool darkerThan(Color4 c) const {
        return r <= c.r &&  g <= c.g && b <= c.b && c.a <= a;
    }
    
    bool lighterThan(Color4 c) const {
        return r >= c.r && g >= c.g && b >= c.b && c.a >= a;
    }

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

#pragma mark -
#pragma mark Friend Operations
    
inline const Color4f operator*(float s, const Color4f& c) {
    Color4f result(c);
    return result *= s;
}
    
inline const Color4 operator*(float s, Color4 c) {
    Color4 result(c);
    return result *= s;
}
    
}

#endif /* __CU_COLOR4_H__ */