From 839f63d78fde46eee660ce3f7e2c23f959109fb4 Mon Sep 17 00:00:00 2001
From: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date: Mon, 9 May 2022 10:07:45 -0700
Subject: [PATCH] color: minor refactor

---
 app/render/color.cpp | 104 +++++++++++++++++++------------------------
 app/render/color.h   | 103 +++++++++++++++++++++++++++++-------------
 2 files changed, 119 insertions(+), 88 deletions(-)

diff --git a/app/render/color.cpp b/app/render/color.cpp
index bbf9a9601..ea00896d4 100644
--- a/app/render/color.cpp
+++ b/app/render/color.cpp
@@ -27,12 +27,12 @@
 
 namespace olive {
 
-Color Color::fromHsv(const float &h, const float &s, const float &v)
+Color Color::fromHsv(const DataType &h, const DataType &s, const DataType &v)
 {
-  float C = s * v;
-  float X = C * (1.0 - abs(fmod(h / 60.0, 2.0) - 1.0));
-  float m = v - C;
-  float Rs, Gs, Bs;
+  DataType C = s * v;
+  DataType X = C * (1.0 - abs(fmod(h / 60.0, 2.0) - 1.0));
+  DataType m = v - C;
+  DataType Rs, Gs, Bs;
 
   if(h >= 0.0 && h < 60.0) {
     Rs = C;
@@ -81,11 +81,11 @@ Color::Color(const QColor &c)
   set_alpha(c.alphaF());
 }
 
-void Color::toHsv(float *hue, float *sat, float *val) const
+void Color::toHsv(DataType *hue, DataType *sat, DataType *val) const
 {
-  float fCMax = qMax(qMax(red(), green()), blue());
-  float fCMin = qMin(qMin(red(), green()), blue());
-  float fDelta = fCMax - fCMin;
+  DataType fCMax = qMax(qMax(red(), green()), blue());
+  DataType fCMin = qMin(qMin(red(), green()), blue());
+  DataType fDelta = fCMax - fCMin;
 
   if(fDelta > 0) {
     if(fCMax == red()) {
@@ -114,31 +114,31 @@ void Color::toHsv(float *hue, float *sat, float *val) const
   }
 }
 
-float Color::hsv_hue() const
+Color::DataType Color::hsv_hue() const
 {
-  float h, s, v;
+  DataType h, s, v;
   toHsv(&h, &s, &v);
   return h;
 }
 
-float Color::hsv_saturation() const
+Color::DataType Color::hsv_saturation() const
 {
-  float h, s, v;
+  DataType h, s, v;
   toHsv(&h, &s, &v);
   return s;
 }
 
-float Color::value() const
+Color::DataType Color::value() const
 {
-  float h, s, v;
+  DataType h, s, v;
   toHsv(&h, &s, &v);
   return v;
 }
 
-void Color::toHsl(float *hue, float *sat, float *lightness) const
+void Color::toHsl(DataType *hue, DataType *sat, DataType *lightness) const
 {
-  float fCMin = qMin(red(), qMin(green(), blue()));
-  float fCMax = qMax(red(), qMax(green(), blue()));
+  DataType fCMin = qMin(red(), qMin(green(), blue()));
+  DataType fCMax = qMax(red(), qMax(green(), blue()));
 
   *lightness = 0.5 * (fCMin + fCMax);
 
@@ -176,23 +176,23 @@ void Color::toHsl(float *hue, float *sat, float *lightness) const
   }
 }
 
-float Color::hsl_hue() const
+Color::DataType Color::hsl_hue() const
 {
-  float h, s, l;
+  DataType h, s, l;
   toHsl(&h, &s, &l);
   return h;
 }
 
-float Color::hsl_saturation() const
+Color::DataType Color::hsl_saturation() const
 {
-  float h, s, l;
+  DataType h, s, l;
   toHsl(&h, &s, &l);
   return s;
 }
 
-float Color::lightness() const
+Color::DataType Color::lightness() const
 {
-  float h, s, l;
+  DataType h, s, l;
   toHsl(&h, &s, &l);
   return l;
 }
@@ -232,12 +232,12 @@ QColor Color::toQColor() const
   return c;
 }
 
-float Color::GetRoughLuminance() const
+Color::DataType Color::GetRoughLuminance() const
 {
   return (2*red()+blue()+3*green())/6.0;
 }
 
-const Color &Color::operator+=(const Color &rhs)
+Color &Color::operator+=(const Color &rhs)
 {
   for (int i=0;i<VideoParams::kRGBAChannelCount;i++) {
     data_[i] += rhs.data_[i];
@@ -246,7 +246,7 @@ const Color &Color::operator+=(const Color &rhs)
   return *this;
 }
 
-const Color &Color::operator-=(const Color &rhs)
+Color &Color::operator-=(const Color &rhs)
 {
   for (int i=0;i<VideoParams::kRGBAChannelCount;i++) {
     data_[i] -= rhs.data_[i];
@@ -255,7 +255,25 @@ const Color &Color::operator-=(const Color &rhs)
   return *this;
 }
 
-const Color &Color::operator*=(const float &rhs)
+Color &Color::operator+=(const DataType &rhs)
+{
+  for (int i=0;i<VideoParams::kRGBAChannelCount;i++) {
+    data_[i] += rhs;
+  }
+
+  return *this;
+}
+
+Color &Color::operator-=(const DataType &rhs)
+{
+  for (int i=0;i<VideoParams::kRGBAChannelCount;i++) {
+    data_[i] -= rhs;
+  }
+
+  return *this;
+}
+
+Color &Color::operator*=(const DataType &rhs)
 {
   for (int i=0;i<VideoParams::kRGBAChannelCount;i++) {
     data_[i] *= rhs;
@@ -264,7 +282,7 @@ const Color &Color::operator*=(const float &rhs)
   return *this;
 }
 
-const Color &Color::operator/=(const float &rhs)
+Color &Color::operator/=(const DataType &rhs)
 {
   for (int i=0;i<VideoParams::kRGBAChannelCount;i++) {
     data_[i] /= rhs;
@@ -273,34 +291,6 @@ const Color &Color::operator/=(const float &rhs)
   return *this;
 }
 
-Color Color::operator+(const Color &rhs) const
-{
-  Color c(*this);
-  c += rhs;
-  return c;
-}
-
-Color Color::operator-(const Color &rhs) const
-{
-  Color c(*this);
-  c -= rhs;
-  return c;
-}
-
-Color Color::operator*(const float &rhs) const
-{
-  Color c(*this);
-  c *= rhs;
-  return c;
-}
-
-Color Color::operator/(const float &rhs) const
-{
-  Color c(*this);
-  c /= rhs;
-  return c;
-}
-
 }
 
 QDebug operator<<(QDebug debug, const olive::Color &r)
diff --git a/app/render/color.h b/app/render/color.h
index 5147e01d9..1d76f4ca0 100644
--- a/app/render/color.h
+++ b/app/render/color.h
@@ -30,11 +30,13 @@
 namespace olive {
 
 /**
- * @brief High precision 32-bit float based RGBA color value
+ * @brief High precision 32-bit DataType based RGBA color value
  */
 class Color
 {
 public:
+  using DataType = float;
+
   Color()
   {
     for (int i=0;i<VideoParams::kRGBAChannelCount;i++) {
@@ -42,7 +44,7 @@ public:
     }
   }
 
-  Color(const float& r, const float& g, const float& b, const float& a = 1.0f)
+  Color(const DataType& r, const DataType& g, const DataType& b, const DataType& a = 1.0f)
   {
     data_[0] = r;
     data_[1] = g;
@@ -59,30 +61,30 @@ public:
    *
    * Hue expects a value between 0.0 and 360.0. Saturation and Value expect a value between 0.0 and 1.0.
    */
-  static Color fromHsv(const float& h, const float& s, const float &v);
+  static Color fromHsv(const DataType& h, const DataType& s, const DataType &v);
 
-  const float& red() const {return data_[0];}
-  const float& green() const {return data_[1];}
-  const float& blue() const {return data_[2];}
-  const float& alpha() const {return data_[3];}
+  const DataType& red() const {return data_[0];}
+  const DataType& green() const {return data_[1];}
+  const DataType& blue() const {return data_[2];}
+  const DataType& alpha() const {return data_[3];}
 
-  void toHsv(float* hue, float* sat, float* val) const;
-  float hsv_hue() const;
-  float hsv_saturation() const;
-  float value() const;
+  void toHsv(DataType* hue, DataType* sat, DataType* val) const;
+  DataType hsv_hue() const;
+  DataType hsv_saturation() const;
+  DataType value() const;
 
-  void toHsl(float* hue, float* sat, float* lightness) const;
-  float hsl_hue() const;
-  float hsl_saturation() const;
-  float lightness() const;
+  void toHsl(DataType* hue, DataType* sat, DataType* lightness) const;
+  DataType hsl_hue() const;
+  DataType hsl_saturation() const;
+  DataType lightness() const;
 
-  void set_red(const float& red) {data_[0] = red;}
-  void set_green(const float& green) {data_[1] = green;}
-  void set_blue(const float& blue) {data_[2] = blue;}
-  void set_alpha(const float& alpha) {data_[3] = alpha;}
+  void set_red(const DataType& red) {data_[0] = red;}
+  void set_green(const DataType& green) {data_[1] = green;}
+  void set_blue(const DataType& blue) {data_[2] = blue;}
+  void set_alpha(const DataType& alpha) {data_[3] = alpha;}
 
-  float* data() {return data_;}
-  const float* data() const {return data_;}
+  DataType* data() {return data_;}
+  const DataType* data() const {return data_;}
 
   void toData(char* data, const VideoParams::Format& format, int ch_layout) const;
 
@@ -92,22 +94,61 @@ public:
 
   // Suuuuper rough luminance value mostly used for UI (determining whether to overlay with black
   // or white text)
-  float GetRoughLuminance() const;
+  DataType GetRoughLuminance() const;
 
   // Assignment math operators
-  const Color& operator+=(const Color& rhs);
-  const Color& operator-=(const Color& rhs);
-  const Color& operator*=(const float& rhs);
-  const Color& operator/=(const float& rhs);
+  Color& operator+=(const Color& rhs);
+  Color& operator-=(const Color& rhs);
+  Color& operator+=(const DataType& rhs);
+  Color& operator-=(const DataType& rhs);
+  Color& operator*=(const DataType& rhs);
+  Color& operator/=(const DataType& rhs);
 
   // Binary math operators
-  Color operator+(const Color& rhs) const;
-  Color operator-(const Color& rhs) const;
-  Color operator*(const float& rhs) const;
-  Color operator/(const float& rhs) const;
+  Color operator+(const Color& rhs) const
+  {
+    Color c(*this);
+    c += rhs;
+    return c;
+  }
+
+  Color operator-(const Color& rhs) const
+  {
+    Color c(*this);
+    c -= rhs;
+    return c;
+  }
+
+  Color operator+(const DataType& rhs) const
+  {
+    Color c(*this);
+    c += rhs;
+    return c;
+  }
+
+  Color operator-(const DataType& rhs) const
+  {
+    Color c(*this);
+    c -= rhs;
+    return c;
+  }
+
+  Color operator*(const DataType& rhs) const
+  {
+    Color c(*this);
+    c *= rhs;
+    return c;
+  }
+
+  Color operator/(const DataType& rhs) const
+  {
+    Color c(*this);
+    c /= rhs;
+    return c;
+  }
 
 private:
-  float data_[VideoParams::kRGBAChannelCount];
+  DataType data_[VideoParams::kRGBAChannelCount];
 
 };