ColorL8.hpp

//============================================================================
//
// This file is part of the Thea toolkit.
//
// This software is distributed under the BSD license, as detailed in the
// accompanying LICENSE.txt file. Portions are derived from other works:
// their respective licenses and copyright information are reproduced in
// LICENSE.txt and/or in the relevant source files.
//
// Author: Siddhartha Chaudhuri
// First version: 2013
//
//============================================================================

/*
 ORIGINAL HEADER

  @file Color1uint8uint8.h

  @maintainer Morgan McGuire, graphics3d.com

  @created 2007-01-30
  @edited  2007-01-30

  Copyright 2000-2007, Morgan McGuire.
  All rights reserved.
 */

#ifndef __Thea_ColorL8_hpp__
#define __Thea_ColorL8_hpp__

#include "Common.hpp"
#include "Math.hpp"

namespace Thea {

// Forward declarations
class ColorL;
class ColorRgba;

THEA_BEGIN_PACKED_CLASS(1)
class THEA_API ColorL8
{
  private:
    uint8 val;  

  public:
    typedef uint8 value_type;  

    ColorL8() : val(0) {}

    explicit ColorL8(uint8 v) : val(v) {}

    ColorL8(ColorRgba const & other);

    ColorL8(ColorL const & other);

    uint8 value() const { return val; }

    uint8 & value() { return val; }

    uint8 const * data() const { return &val; }

    uint8 * data() { return &val; }

    template <typename IntegerT> uint8 const & operator[](IntegerT channel) const
    {
      debugAssertM(channel == 0, "ColorL8: Channel must be 0");
      return val;
    }

    template <typename IntegerT> uint8 & operator[](IntegerT channel)
    {
      debugAssertM(channel == 0, "ColorL8: Channel must be 0");
      return val;
    }

    void fill(uint8 v) { val = v; }

    ColorL8 operator+(ColorL8 const & other) const
    {
      return ColorL8((uint8)std::min(255, (int)val + (int)other.val));
    }

    ColorL8 operator-(ColorL8 const & other) const
    {
      return ColorL8((uint8)std::max(0, (int)val - (int)other.val));
    }

    ColorL8 operator*(Real other) const
    {
      return ColorL8((uint8)Math::clamp((Real)Math::round(val * other), (Real)0, (Real)255));
    }

    ColorL8 operator/(Real other) const
    {
      return ColorL8((uint8)Math::clamp((Real)Math::round(val / other), (Real)0, (Real)255));
    }

    ColorL8 & operator+=(ColorL8 const & other)
    {
      *this = *this + other;
      return *this;
    }

    ColorL8 & operator-=(ColorL8 const & other)
    {
      *this = *this - other;
      return *this;
    }

    ColorL8 & operator*=(Real other)
    {
      *this = *this * other;
      return *this;
    }

    ColorL8 & operator/=(Real other)
    {
      *this = *this / other;
      return *this;
    }

    ColorL8 max(ColorL8 const & other) const
    {
      return ColorL8(std::max(val, other.val));
    }

    ColorL8 min(ColorL8 const & other) const
    {
      return ColorL8(std::min(val, other.val));
    }

    static ColorL8 const & zero() { static ColorL8 const col(0); return col; }

    std::string toString() const;

} THEA_END_PACKED_CLASS(1)  // class ColorL8


inline ColorL8
operator*(Real lhs, ColorL8 const & rhs)
{
  return rhs * lhs;
}

} // namespace Thea

#endif