Add Color utilities

[AODQ]

TR could be improved with a color class that has many helpful constructors and utility functions. It should be compatible with multiple floating-point and integral data types

[DieSlower]

Can you list what kind of constructors you would like to see?

[AODQ]

Design Considerations:

• Can input/output several data types:
  • Vectors
  • Integrals
  • Floating points
• Supports different formats (there are multiple 'special' formats, like R10G10B10A2, but those aren't very useful, unless we plan to load/store compressed textures using this color class, in which case they're a must-have)
• Can convert colors from one format to the other (might not be important at all)
• Internally stores what makes most sense
• Probably no support for doubles, since values would have to be converted over to floats anyways for OpenGL (and most likely as normalized 16 bytes)

These are examples in what would make sense to me in pseudo-code

enum FormatChannelType {
  Red, 
  Green,
  Blue,
  Alpha
};

// https://www.khronos.org/opengl/wiki/Image_Format#Color_formats 
enum class FormatType {
  UnsignedNormalized,
  SignedNormalized,
  UnsignedIntegral,
  SignedIntegral,
  FloatingPoint
};

void test ( ) {
  static constexpr std::array<FormatChannelType> RgbaChannel
  {
      FormatChannelType::Red,
      FormatChannelType::Green,
      FormatChannelType::Blue,
      FormatChannelType::Alpha
  };

  static constexpr std::array<FormatChannelType> RedChannel
  {
    FormatChannelType::Red
  };

  using ColorRgba =
    Color<
      RgbaChannel,
      FormatType::UnsignedIntegral
    >;

  using ColorRgbaF =
    Color<
      RgbaChannel,
      FormatType::FloatingPoint
    >;

  using ColorR16 =
    Color<
      RedChannel,
      FormatType::UnsignedIntegral
    >;

  ColorRgba  bufferColor { vec3{1.0f}, 0.0f }  // {1, 1, 1, 0}
  ColorRgba  bufferColor { vec3ub{128}, 0.0f } // {0.5, 0.5, 0.5, 0}
  ColorRgbaF luminance   { 0.5f }              // {0.5, 0.5, 0.5, 0.5}
  ColorR16   luminance2  { 32767 }             // {32767} (ei 0.5)
  ColorR8    luminance2  { 127 }               // {127} (ei 0.5)
  ColorR8    luminance2  { 0.5f }              // approx {127} (ei 0.5)

  // -- to consider:

  // -- explicit integral/floating point conversions --

  uint32_t i = luminance.r();
  assert(i == 0);

  float f = luminance2.r();
  assert(i == 32767.0);

  i = luminance.asIntegral<uint32_t>().r();
  assert(i == 32767);

  f = luminance.asFloating<float>().r();
  assert(f == 0.5f);
}