SColor.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
 
#ifndef __COLOR_H_INCLUDED__
#define __COLOR_H_INCLUDED__
 
#include "enumType.hpp"
#include "EPixelFormat.h"
#include "SagaConfig.h"
#include <glm/gtx/extended_min_max.hpp>
#include <glm/gtc/constants.hpp>
#include <glm/gtc/epsilon.hpp>
#include <glm/vec4.hpp>
 
namespace saga
{
namespace video
{
 
    const char* const ColorFormatNames[saga::core::enumToPOD(E_PIXEL_FORMAT::UNKNOWN)+2] =
  {
    "RGBA8",
    "RGB8",
    "RGBA4",
    "R5G6B5",
    "R5G5B5A1",
    "R10G10B10A2",
    "RGBA32F",
    "RGBA16F",
    "R32F",
    "R16F",
    "L8",
    "DXT1",
    "DXT3",
    "DXT5",
    "DEPTH",
    "DEPTH_STENCIL",
    "PVRTC2_RGB",
    "PVRTC4_RGB",
    "PVRTC2_RGBA",
    "PVRTC4_RGBA",
    "ETC2_RGB8",
    "ETC2_SRGB8",
    "UNKNOWN",
    0
  };
 
 
  inline std::uint16_t RGBA16(std::uint32_t r, std::uint32_t g, std::uint32_t b, std::uint32_t a= 0xFF)
  {
    return (std::uint16_t)((a & 0x80) << 8 |
      (r & 0xF8) << 7 |
      (g & 0xF8) << 2 |
      (b & 0xF8) >> 3);
  }
 
 
  inline std::uint16_t RGB16(std::uint32_t r, std::uint32_t g, std::uint32_t b)
  {
    return RGBA16(r,g,b);
  }
 
 
  inline std::uint16_t RGB16from16(std::uint16_t r, std::uint16_t g, std::uint16_t b)
  {
    return (0x8000 |
        (r & 0x1F) << 10 |
        (g & 0x1F) << 5  |
        (b & 0x1F));
  }
 
 
  inline std::uint16_t X8RGB8toA1R5G5B5(std::uint32_t color)
  {
    return (std::uint16_t)(0x8000 |
      (color & 0x00F80000) >> 9 |
      (color & 0x0000F800) >> 6 |
      (color & 0x000000F8) >> 3);
  }
 
 
  inline std::uint16_t A8RGB8toA1R5G5B5(std::uint32_t color)
  {
    return (std::uint16_t)((color & 0x80000000) >> 16|
      (color & 0x00F80000) >> 9 |
      (color & 0x0000F800) >> 6 |
      (color & 0x000000F8) >> 3);
  }
 
 
  inline std::uint16_t A8RGB8toR5G6B5(std::uint32_t color)
  {
    return (std::uint16_t)((color & 0x00F80000) >> 8 |
      (color & 0x0000FC00) >> 5 |
      (color & 0x000000F8) >> 3);
  }
 
 
 
  inline std::uint32_t A1R5G5B5toA8RGB8(std::uint16_t color)
  {
    return (((-((std::int32_t) color & 0x00008000) >> (std::int32_t) 31) & 0xFF000000) |
        ((color & 0x00007C00) << 9) | ((color & 0x00007000) << 4) |
        ((color & 0x000003E0) << 6) | ((color & 0x00000380) << 1) |
        ((color & 0x0000001F) << 3) | ((color & 0x0000001C) >> 2)
       );
  }
 
 
  inline std::uint32_t R5G6B5toA8RGB8(std::uint16_t color)
  {
    return 0xFF000000 |
      ((color & 0xF800) << 8)|
      ((color & 0x07E0) << 5)|
      ((color & 0x001F) << 3);
  }
 
 
  inline std::uint16_t R5G6B5toA1R5G5B5(std::uint16_t color)
  {
    return 0x8000 | (((color & 0xFFC0) >> 1) | (color & 0x1F));
  }
 
 
  inline std::uint16_t A1R5G5B5toR5G6B5(std::uint16_t color)
  {
    return (((color & 0x7FE0) << 1) | (color & 0x1F));
  }
 
 
 
 
  inline std::uint32_t getAlpha(std::uint16_t color)
  {
    return ((color >> 15)&0x1);
  }
 
 
 
  inline std::uint32_t getRed(std::uint16_t color)
  {
    return ((color >> 10)&0x1F);
  }
 
 
 
  inline std::uint32_t getGreen(std::uint16_t color)
  {
    return ((color >> 5)&0x1F);
  }
 
 
 
  inline std::uint32_t getBlue(std::uint16_t color)
  {
    return (color & 0x1F);
  }
 
 
  inline std::int32_t getAverage(std::int16_t color)
  {
    return ((getRed(color)<<3) + (getGreen(color)<<3) + (getBlue(color)<<3)) / 3;
  }
 
 
 
  class SColor
  {
  public:
 
 
    SColor() {}
 
 
    SColor (std::uint32_t a, std::uint32_t r, std::uint32_t g, std::uint32_t b)
      : color(((a & 0xff)<<24) | ((r & 0xff)<<16) | ((g & 0xff)<<8) | (b & 0xff)) {}
 
    SColor(std::uint32_t clr)
      : color(clr) {}
 
 
    std::uint32_t getAlpha() const { return color>>24; }
 
 
    std::uint32_t getRed() const { return (color>>16) & 0xff; }
 
 
    std::uint32_t getGreen() const { return (color>>8) & 0xff; }
 
 
    std::uint32_t getBlue() const { return color & 0xff; }
 
    float getLightness() const
    {
      return 0.5f*(glm::max(glm::max(getRed(),getGreen()),getBlue())+glm::min(glm::min(getRed(),getGreen()),getBlue()));
    }
 
    float getLuminance() const
    {
      return 0.3f*getRed() + 0.59f*getGreen() + 0.11f*getBlue();
    }
 
    std::uint32_t getAverage() const
    {
      return (getRed() + getGreen() + getBlue()) / 3;
    }
 
 
    void setAlpha(std::uint32_t a) { color = ((a & 0xff)<<24) | (color & 0x00ffffff); }
 
 
    void setRed(std::uint32_t r) { color = ((r & 0xff)<<16) | (color & 0xff00ffff); }
 
 
    void setGreen(std::uint32_t g) { color = ((g & 0xff)<<8) | (color & 0xffff00ff); }
 
 
    void setBlue(std::uint32_t b) { color = (b & 0xff) | (color & 0xffffff00); }
 
 
    std::uint16_t toA1R5G5B5() const { return A8RGB8toA1R5G5B5(color); }
 
 
    void toOpenGLColor(std::uint8_t* dest) const
    {
      *dest =   (std::uint8_t)getRed();
      *++dest = (std::uint8_t)getGreen();
      *++dest = (std::uint8_t)getBlue();
      *++dest = (std::uint8_t)getAlpha();
    }
 
    glm::uvec4 toGLM() const { return {getRed(), getGreen(), getBlue(), getAlpha()}; }
 
 
    void set(std::uint32_t a, std::uint32_t r, std::uint32_t g, std::uint32_t b)
    {
      color = (((a & 0xff)<<24) | ((r & 0xff)<<16) | ((g & 0xff)<<8) | (b & 0xff));
    }
    void set(std::uint32_t col) { color = col; }
 
 
    bool operator==(const SColor& other) const { return other.color == color; }
 
 
    bool operator!=(const SColor& other) const { return other.color != color; }
 
 
    bool operator<(const SColor& other) const { return (color < other.color); }
 
 
    SColor operator+(const SColor& other) const
    {
      return SColor(glm::min(getAlpha() + other.getAlpha(), 255u),
          glm::min(getRed() + other.getRed(), 255u),
          glm::min(getGreen() + other.getGreen(), 255u),
          glm::min(getBlue() + other.getBlue(), 255u));
    }
 
 
    SColor getInterpolated(const SColor &other, float d) const
    {
      d = glm::clamp(d, 0.f, 1.f);
      const float inv = 1.0f - d;
      return SColor((std::uint32_t)glm::round(other.getAlpha()*inv + getAlpha()*d),
        (std::uint32_t)glm::round(other.getRed()*inv + getRed()*d),
        (std::uint32_t)glm::round(other.getGreen()*inv + getGreen()*d),
        (std::uint32_t)glm::round(other.getBlue()*inv + getBlue()*d));
    }
 
 
    SColor getInterpolated_quadratic(const SColor& c1, const SColor& c2, float d) const
    {
      // this*(1-d)*(1-d) + 2 * c1 * (1-d) + c2 * d * d;
      d = glm::clamp(d, 0.f, 1.f);
      const float inv = 1.f - d;
      const float mul0 = inv * inv;
      const float mul1 = 2.f * d * inv;
      const float mul2 = d * d;
 
      return SColor(
                    glm::clamp((int) glm::floor(
              getAlpha() * mul0 + c1.getAlpha() * mul1 + c2.getAlpha() * mul2), 0, 255),
                    glm::clamp((int) glm::floor(
                            getRed() * mul0 + c1.getRed() * mul1 + c2.getRed() * mul2), 0, 255),
                    glm::clamp((int) glm::floor(
              getGreen() * mul0 + c1.getGreen() * mul1 + c2.getGreen() * mul2), 0, 255),
                    glm::clamp((int) glm::floor(
                            getBlue() * mul0 + c1.getBlue() * mul1 + c2.getBlue() * mul2), 0, 255));
    }
 
 
    void setData(const void* data, E_PIXEL_FORMAT format)
    {
      switch (format)
      {
          case E_PIXEL_FORMAT::R5G6B5:
          color = R5G6B5toA8RGB8(*(std::uint16_t*)data);
          break;
          case E_PIXEL_FORMAT::RGBA8:
          color = *(std::uint32_t*)data;
          break;
          case E_PIXEL_FORMAT::RGB8:
          {
            std::uint8_t* p = (std::uint8_t*)data;
            set(255, p[0],p[1],p[2]);
          }
          break;
        default:
          color = 0xffffffff;
        break;
      }
    }
 
 
    void getData(void* data, E_PIXEL_FORMAT format) const
    {
      switch(format)
      {
        case E_PIXEL_FORMAT::R5G6B5:
        {
          std::uint16_t * dest = (std::uint16_t*)data;
          *dest = video::A8RGB8toR5G6B5(color);
        }
        break;
 
        case E_PIXEL_FORMAT::RGB8:
        {
          std::uint8_t* dest = (std::uint8_t*)data;
          dest[0] = (std::uint8_t)getRed();
          dest[1] = (std::uint8_t)getGreen();
          dest[2] = (std::uint8_t)getBlue();
        }
        break;
 
        case E_PIXEL_FORMAT::RGBA8:
        {
          std::uint32_t * dest = (std::uint32_t*)data;
          *dest = color;
        }
        break;
 
        default:
        break;
      }
    }
 
    std::uint32_t color;
  };
 
 
 
  class SColorf
  {
  public:
 
    SColorf() : r(0.0f), g(0.0f), b(0.0f), a(1.0f) {}
 
 
    SColorf(float r, float g, float b, float a = 1.0f) : r(r), g(g), b(b), a(a) {}
 
 
    SColorf(SColor c)
    {
      const float inv = 1.0f / 255.0f;
      r = c.getRed() * inv;
      g = c.getGreen() * inv;
      b = c.getBlue() * inv;
      a = c.getAlpha() * inv;
    }
 
    SColor toSColor() const
    {
      return SColor((std::uint32_t)glm::round(a*255.0f), (std::uint32_t)glm::round(r*255.0f), (std::uint32_t)glm::round(g*255.0f), (std::uint32_t)glm::round(b*255.0f));
    }
 
 
    void set(float rr, float gg, float bb) {r = rr; g =gg; b = bb; }
 
 
    void set(float aa, float rr, float gg, float bb) {a = aa; r = rr; g =gg; b = bb; }
 
 
    SColorf getInterpolated(const SColorf &other, float d) const
    {
      d = glm::clamp(d, 0.f, 1.f);
      const float inv = 1.0f - d;
      return SColorf(other.r*inv + r*d,
        other.g*inv + g*d, other.b*inv + b*d, other.a*inv + a*d);
    }
 
 
    inline SColorf getInterpolated_quadratic(const SColorf& c1, const SColorf& c2,
        float d) const
    {
      d = glm::clamp(d, 0.f, 1.f);
      // this*(1-d)*(1-d) + 2 * c1 * (1-d) + c2 * d * d;
      const float inv = 1.f - d;
      const float mul0 = inv * inv;
      const float mul1 = 2.f * d * inv;
      const float mul2 = d * d;
 
      return SColorf (r * mul0 + c1.r * mul1 + c2.r * mul2,
          g * mul0 + c1.g * mul1 + c2.g * mul2,
          b * mul0 + c1.b * mul1 + c2.b * mul2,
          a * mul0 + c1.a * mul1 + c2.a * mul2);
    }
 
 
    void setColorComponentValue(std::int32_t index, float value)
    {
      switch(index)
      {
      case 0: r = value; break;
      case 1: g = value; break;
      case 2: b = value; break;
      case 3: a = value; break;
      }
    }
 
    float getAlpha() const { return a; }
 
    float getRed() const { return r; }
 
    float getGreen() const { return g; }
 
    float getBlue() const { return b; }
 
    float r;
 
    float g;
 
    float b;
 
    float a;
  };
 
 
 
  class SColorHSL
  {
  public:
    SColorHSL (float h = 0.f, float s = 0.f, float l = 0.f)
      : Hue (h), Saturation (s), Luminance (l) {}
 
    void fromRGB(const SColorf &color);
    void toRGB(SColorf &color) const;
 
    float Hue;
    float Saturation;
    float Luminance;
 
  private:
    inline float toRGB1(float rm1, float rm2, float rh) const;
 
  };
 
  inline void SColorHSL::fromRGB(const SColorf &color)
  {
        const float maxVal = glm::max(color.getRed(), color.getGreen(), color.getBlue());
        const float minVal = (float) glm::min(color.getRed(), color.getGreen(), color.getBlue());
    Luminance = (maxVal+minVal)*50;
        if (glm::epsilonEqual(maxVal, minVal, glm::epsilon<float>()))
    {
      Hue= 0.f;
      Saturation= 0.f;
      return;
    }
 
    const float delta = maxVal-minVal;
    if (Luminance <= 50)
    {
      Saturation = (delta)/(maxVal+minVal);
    }
    else
    {
      Saturation = (delta)/(2-maxVal-minVal);
    }
    Saturation *= 100;
 
        if (glm::epsilonEqual(maxVal, color.getRed(), glm::epsilon<float>()))
      Hue = (color.getGreen()-color.getBlue())/delta;
        else if (glm::epsilonEqual(maxVal, color.getGreen(), glm::epsilon<float>()))
      Hue = 2+((color.getBlue()-color.getRed())/delta);
    else // blue is max
      Hue = 4+((color.getRed()-color.getGreen())/delta);
 
    Hue *= 60.0f;
    while (Hue < 0.f)
      Hue += 360;
  }
 
 
  inline void SColorHSL::toRGB(SColorf &color) const
  {
    const float l = Luminance/100;
        if (glm::abs(Saturation)) // grey
    {
      color.set(l, l, l);
      return;
    }
 
    float rm2;
 
    if (Luminance <= 50)
    {
      rm2 = l + l * (Saturation/100);
    }
    else
    {
      rm2 = l + (1 - l) * (Saturation/100);
    }
 
    const float rm1 = 2.0f * l - rm2;
 
    const float h = Hue / 360.0f;
    color.set(toRGB1(rm1, rm2, h + 1.f/3.f),
      toRGB1(rm1, rm2, h),
      toRGB1(rm1, rm2, h - 1.f/3.f)
     );
  }
 
 
  // algorithm from Foley/Van-Dam
  inline float SColorHSL::toRGB1(float rm1, float rm2, float rh) const
  {
    if (rh<0)
      rh += 1;
    if (rh>1)
      rh -= 1;
 
    if (rh < 1.f/6.f)
      rm1 = rm1 + (rm2 - rm1) * rh*6.f;
    else if (rh < 0.5f)
      rm1 = rm2;
    else if (rh < 2.f/3.f)
      rm1 = rm1 + (rm2 - rm1) * ((2.f/3.f)-rh)*6.f;
 
    return rm1;
  }
 
} // namespace video
} // namespace saga
 
#endif