Types.h

Go to the documentation of this file.

/*
    Enki - a fast 2D robot simulator
    Copyright (C) 1999-2016 Stephane Magnenat <stephane at magnenat dot net>
    Copyright (C) 2004-2005 Markus Waibel <markus dot waibel at epfl dot ch>
    Copyright (c) 2004-2005 Antoine Beyeler <abeyeler at ab-ware dot com>
    Copyright (C) 2005-2006 Laboratory of Intelligent Systems, EPFL, Lausanne
    Copyright (C) 2006-2008 Laboratory of Robotics Systems, EPFL, Lausanne
    See AUTHORS for details

    This program is free software; the authors of any publication 
    arising from research using this software are asked to add the 
    following reference:
    Enki - a fast 2D robot simulator
    http://home.gna.org/enki
    Stephane Magnenat <stephane at magnenat dot net>,
    Markus Waibel <markus dot waibel at epfl dot ch>
    Laboratory of Intelligent Systems, EPFL, Lausanne.

    You can redistribute this program and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef __ENKI_TYPES_H
#define __ENKI_TYPES_H

#include <vector>
#include <sstream>
#include <string>
#include <cassert>
#include <stdint.h> // C99 in waiting for widespread C++11 support

namespace Enki
{
    struct Color
    {
        double components[4];
        
        Color(double r = 0.0, double g = 0.0, double b = 0.0, double a = 1.0)
        {
            components[0] = r;
            components[1] = g;
            components[2] = b;
            components[3] = a;
        }
        
        const double& operator[](size_t i) const { assert((i >= 0) && (i < 4)); return components[i]; }
        double& operator[](size_t i) { assert((i >= 0) && (i < 4)); return components[i]; }
        
        // operations with scalar
        void operator +=(double d) { for (size_t i=0; i<3; i++) components[i] += d; }
        Color operator +(double d) const { Color c; for (size_t i=0; i<3; i++) c.components[i] = components[i] + d; return c; }
        
        void operator -=(double d) { for (size_t i=0; i<3; i++) components[i] -= d; }
        Color operator -(double d) const { Color c; for (size_t i=0; i<3; i++) c.components[i] = components[i] - d; return c; }
        
        void operator *=(double d) { for (size_t i=0; i<3; i++) components[i] *= d; }
        Color operator *(double d) const { Color c; for (size_t i=0; i<3; i++) c.components[i] = components[i] * d; return c; }
        
        void operator /=(double d) { for (size_t i=0; i<3; i++) components[i] /= d; }
        Color operator /(double d) const { Color c; for (size_t i=0; i<3; i++) c.components[i] = components[i] / d; return c; }
        
        // operation with another color
        void operator +=(const Color &oc) { for (size_t i=0; i<3; i++) components[i] += oc.components[i]; }
        Color operator +(const Color &oc) const { Color c; for (size_t i=0; i<3; i++) c.components[i] = components[i] + oc.components[i]; return c; }
        
        void operator -=(const Color &oc) { for (size_t i=0; i<3; i++) components[i] -= oc.components[i]; }
        Color operator -(const Color &oc) const { Color c; for (size_t i=0; i<3; i++) c.components[i] = components[i] - oc.components[i]; return c; }
        
        bool operator ==(const Color &c) const { for (size_t i=0; i<4; i++) if (components[i] != c.components[i]) return false; return true; }
        bool operator !=(const Color &c) const { return !(*this == c); }
        void threshold(const Color &limit) { for (size_t i=0; i<3; i++) components[i] = components[i] > limit.components[i] ? components[i] : 0; }
        double toGray() const { return (components[0] + components[1] + components[2]) / 3; }
        
        std::string toString() const { std::ostringstream oss; oss << *this; return oss.str(); }
        
        double r() const { return components[0]; }
        
        void setR(double value) { components[0] = value; }
        
        double g() const { return components[1]; }
        
        void setG(double value) { components[1] = value; }
        
        double b() const { return components[2]; }
        
        void setB(double value) { components[2] = value; }
        
        double a() const { return components[3]; }
        
        void setA(double value) { components[3] = value; }
        
        static Color fromARGB(uint32_t color);
        static Color fromABGR(uint32_t color);
        static uint32_t toARGB(Color color);
        
        static const Color black;
        static const Color white;
        static const Color gray;
        static const Color red;
        static const Color green;
        static const Color blue;
        
        friend std::ostream & operator<<(std::ostream &os, const Color& c);
    };
    
    typedef std::vector<Color> Texture;
    
    typedef std::vector<Texture> Textures;
}

#endif