color.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*********************************************************************************/
 
#pragma once
 
//! \file color.h
//! \brief Provides color representation and manipulation functionality
 
#include "vreUtil/export.h"
 
namespace makVre
{
 
//! \brief Class for representing and manipulating RGBA colors
//!
//! This class provides functionality for working with colors in RGBA format.
//! It includes methods for creating common colors and converting between
//! different color representations.
class UTIL_DLL DtColor
{
public:
   //! \brief Fill mode enumeration for rendering
   enum Fill
   {
      FILL_SOLID,       //!< Solid fill mode
      FILL_TRANSPARENT, //!< Transparent fill mode
      FILL_WIREFRAME,   //!< Wireframe fill mode
      FILL_NONE         //!< No fill mode
   };
 
   //! \brief Default constructor
   //!
   //! Creates a white opaque color (RGBA: 1,1,1,1)
   DtColor() { r = g = b = a = 1.0; }
 
   //! \brief Constructor with RGBA components
   //!
   //! \param rr Red component (0.0 to 1.0)
   //! \param gg Green component (0.0 to 1.0)
   //! \param bb Blue component (0.0 to 1.0)
   //! \param aa Alpha component (0.0 to 1.0, where 1.0 is fully opaque)
   DtColor(float rr, float gg, float bb, float aa)
      : r(rr)
      , g(gg)
      , b(bb)
      , a(aa)
   {
   }
 
   //! \brief Destructor
   ~DtColor() {}
 
   //! \brief Converts the color to an unsigned integer representation
   //!
   //! The color is packed as 0xRRGGBBAA with 8 bits per channel
   //!
   //! \return The color as a 32-bit unsigned integer
   unsigned int toUInt() const;
 
   //! \brief Creates a white color (RGBA: 1,1,1,1)
   //!
   //! \return A white color
   static DtColor white() { return DtColor(1, 1, 1, 1); }
 
   //! \brief Creates a black color (RGBA: 0,0,0,1)
   //!
   //! \return A black color
   static DtColor black() { return DtColor(0, 0, 0, 1); }
 
   //! \brief Creates a blue color (RGBA: 0,0,1,1)
   //!
   //! \return A blue color
   static DtColor blue() { return DtColor(0, 0, 1, 1); }
 
   //! \brief Creates a green color (RGBA: 0,1,0,1)
   //!
   //! \return A green color
   static DtColor green() { return DtColor(0, 1, 0, 1); }
 
   //! \brief Creates a red color (RGBA: 1,0,0,1)
   //!
   //! \return A red color
   static DtColor red() { return DtColor(1, 0, 0, 1); }
 
   //! \brief Creates an orange color (RGBA: 1,0.5,0,1)
   //!
   //! \return An orange color
   static DtColor orange() { return DtColor(1, 0.5, 0, 1); }
 
   //! \brief Creates a yellow color (RGBA: 1,1,0,1)
   //!
   //! \return A yellow color
   static DtColor yellow() { return DtColor(1, 1, 0, 1); }
 
   //! \brief Equality comparison operator
   //!
   //! \param other The color to compare with
   //! \return true if the colors are identical, false otherwise
   bool operator==(const DtColor& other) const;
 
   //! \brief Red component (0.0 to 1.0)
   float r;
 
   //! \brief Green component (0.0 to 1.0)
   float g;
 
   //! \brief Blue component (0.0 to 1.0)
   float b;
 
   //! \brief Alpha component (0.0 to 1.0, where 1.0 is fully opaque)
   float a;
};
 
} // namespace makVre