Added SetColorTint to GFxValue and GFxMovie. Added constructors to GColor.

Author: adya

include/RE/G/GColor.h

@@ -21,6 +21,32 @@ namespace RE
 		};
 		static_assert(sizeof(ColorData) == 0x4);
 
+		constexpr GColor() noexcept :
+			colorData{}
+		{}
+
+		constexpr GColor(std::uint8_t a_red, std::uint8_t a_green, std::uint8_t a_blue, std::uint8_t a_alpha = 255) noexcept :
+			colorData{}
+		{
+			colorData.channels.red = a_red;
+			colorData.channels.green = a_green;
+			colorData.channels.blue = a_blue;
+			colorData.channels.alpha = a_alpha;
+
+			colorData.raw = (static_cast<std::uint32_t>(a_alpha) << 24) | (static_cast<std::uint32_t>(a_red) << 16) | (static_cast<std::uint32_t>(a_green) << 8) | a_blue;
+		}
+
+		constexpr GColor(std::uint32_t a_raw) noexcept :
+			colorData{}
+		{
+			colorData.raw = a_raw;
+
+			colorData.channels.alpha = (a_raw >> 24) & 0xFF;
+			colorData.channels.red = (a_raw >> 16) & 0xFF;
+			colorData.channels.green = (a_raw >> 8) & 0xFF;
+			colorData.channels.blue = a_raw & 0xFF;
+		}
+
 		// members
 		ColorData colorData;  // 0
 	};

include/RE/G/GFxMovie.h

@@ -2,6 +2,7 @@
 
 #include "RE/G/GFxPlayerStats.h"
 #include "RE/G/GRefCountBase.h"
+#include "RE/G/GColor.h"
 
 namespace RE
 {
@@ -74,6 +75,24 @@ namespace RE
 		double                      GetVariableDouble(const char* a_pathToVar) const;
 		bool                        SetVariableArray(const char* a_pathToVar, std::uint32_t a_index, const GFxValue* a_data, std::uint32_t a_count, SetVarType a_setType = SetVarType::kSticky);
 		bool                        GetVariableArray(const char* a_pathToVar, std::uint32_t a_index, GFxValue* a_data, std::uint32_t a_count);
+		
+		/// <summary>
+		/// Applies a color tint to a display object at the specified path.
+		/// This is a convenience method that retrieves the display object and calls SetColorTint on it.
+		/// The alpha channel of the color determines the intensity of the tint (0 = no tint, 255 = full tint).
+		/// </summary>
+		/// <param name="a_pathToVar">Path to the display object (e.g. "_root.MyObject")</param>
+		/// <param name="a_tint">The color to tint toward. Alpha channel determines intensity (0-255)</param>
+		/// <returns>True if the display object was found and tinted successfully, false otherwise</returns>
+		bool SetColorTint(const char* a_pathToVar, const GColor& a_tint);
+
+		/// <summary>
+		/// Removes any color tint from a display object at the specified path.
+		/// This is a convenience method that retrieves the display object and calls RemoveColorTint on it.
+		/// </summary>
+		/// <param name="a_pathToVar">Path to the display object (e.g. "_root.MyObject")</param>
+		/// <returns>True if the display object was found and the tint was removed successfully, false otherwise</returns>
+		bool RemoveColorTint(const char* a_pathToVar);
 	};
 	static_assert(sizeof(GFxMovie) == 0x10);
 }

include/RE/G/GFxValue.h

@@ -404,6 +404,22 @@ namespace RE
 		bool GotoAndPlay(const char* a_frame);
 		bool GotoAndStop(const char* a_frame);
 
+		/// <summary>
+		/// Applies a color tint to this display object by modifying its color transform.
+		/// The tint is applied by blending the object's colors toward the specified tint color.
+		/// The alpha channel of the color determines the intensity of the tint (0 = no tint, 255 = full tint).
+		/// </summary>
+		/// <param name="a_tint">The color to tint toward. Alpha channel determines intensity (0-255)</param>
+		/// <returns>True if the color transform was successfully applied, false otherwise</returns>
+		bool SetColorTint(const GColor& a_tint);
+
+		/// <summary>
+		/// Removes any color tint from this display object by resetting its color transform to identity.
+		/// This restores the original colors of the display object.
+		/// </summary>
+		/// <returns>True if the color transform was successfully reset, false otherwise</returns>
+		bool RemoveColorTint();
+
 		GFC_MEMORY_REDEFINE_NEW(GFxValue, GStatGroups::kGStatGroup_Default);
 
 	protected:

src/RE/G/GFxMovie.cpp

@@ -1,5 +1,6 @@
 #include "RE/G/GFxMovie.h"
 
+#include "RE/G/GColor.h"
 #include "RE/G/GFxMovieDef.h"
 #include "RE/G/GFxValue.h"
 
@@ -54,4 +55,32 @@ namespace RE
 	{
 		return GetVariableArray(SetArrayType::kValue, a_pathToVar, a_index, a_data, a_count);
 	}
+
+	bool GFxMovie::SetColorTint(const char* a_pathToVar, const GColor& a_tint)
+	{
+		GFxValue object;
+		if (!GetVariable(&object, a_pathToVar)) {
+			return false;
+		}
+
+		if (!object.IsDisplayObject()) {
+			return false;
+		}
+
+		return object.SetColorTint(a_tint);
+	}
+
+	bool GFxMovie::RemoveColorTint(const char* a_pathToVar)
+	{
+		GFxValue object;
+		if (!GetVariable(&object, a_pathToVar)) {
+			return false;
+		}
+
+		if (!object.IsDisplayObject()) {
+			return false;
+		}
+
+		return object.RemoveColorTint();
+	}
 }

src/RE/G/GFxValue.cpp

@@ -1,5 +1,7 @@
 #include "RE/G/GFxValue.h"
 
+#include "RE/G/GColor.h"
+
 namespace RE
 {
 	GFxValue::DisplayInfo::DisplayInfo(double a_x, double a_y) :
@@ -992,6 +994,54 @@ namespace RE
 		return _objectInterface->GotoAndPlay(_value.obj, a_frame, true);
 	}
 
+	bool GFxValue::SetColorTint(const GColor& a_tint)
+	{
+		assert(IsDisplayObject());
+		
+		using Cxform = GRenderer::Cxform;
+
+		Cxform colorTransform;
+		if (!GetCxform(&colorTransform)) {
+			return false;
+		}
+
+		// Normalize color values from 0-255 to 0-1
+		float normalizedRed = a_tint.colorData.channels.red / 255.0f;
+		float normalizedGreen = a_tint.colorData.channels.green / 255.0f;
+		float normalizedBlue = a_tint.colorData.channels.blue / 255.0f;
+		
+		// Use alpha channel as intensity (0-255 -> 0-1)
+		float intensity = a_tint.colorData.channels.alpha / 255.0f;
+
+		// Apply color transform
+		// Multiply: reduce the original color channels that aren't the tint color
+		colorTransform.matrix[Cxform::kR][Cxform::kMult] = 1.0f - (intensity * (1.0f - normalizedRed));  
+		colorTransform.matrix[Cxform::kG][Cxform::kMult] = 1.0f - (intensity * (1.0f - normalizedGreen));
+		colorTransform.matrix[Cxform::kB][Cxform::kMult] = 1.0f - (intensity * (1.0f - normalizedBlue)); 
+		colorTransform.matrix[Cxform::kA][Cxform::kMult] = 1.0f;                                         
+
+		// Add: boost the tint color channels
+		colorTransform.matrix[Cxform::kR][Cxform::kAdd] = intensity * normalizedRed * 0.5f;  
+		colorTransform.matrix[Cxform::kG][Cxform::kAdd] = intensity * normalizedGreen * 0.5f;
+		colorTransform.matrix[Cxform::kB][Cxform::kAdd] = intensity * normalizedBlue * 0.5f; 
+		colorTransform.matrix[Cxform::kA][Cxform::kAdd] = 0.0f;                              
+
+		return SetCxform(colorTransform);
+	}
+
+	bool GFxValue::RemoveColorTint()
+	{		
+		assert(IsDisplayObject());
+		
+		GRenderer::Cxform colorTransform;
+		if (!GetCxform(&colorTransform)) {
+			return false;
+		}
+		colorTransform.SetIdentity();
+
+		return SetCxform(colorTransform);
+	}
+
 	bool GFxValue::IsManagedValue() const
 	{
 		return _type.all(ValueType::kManagedBit);