Add toRgba() method to Value

Author: adazem009

include/scratchcpp/value.h

@@ -139,6 +139,9 @@ class LIBSCRATCHCPP_EXPORT Value
             return ret;
         }
 
+        /*! Converts the value to an RGBA quadruplet. */
+        Rgb toRgba() { return value_toRgba(&m_data); }
+
         /*! Adds the given value to the value. */
         void add(const Value &v) { value_add(&m_data, &v.m_data, &m_data); }
 

include/scratchcpp/value_functions.h

@@ -5,6 +5,45 @@
 namespace libscratchcpp
 {
 
+/*! A typedef for unsigned int. Holds the RGBA values. */
+using Rgb = unsigned int;
+
+/*! Returns the red component of the quadruplet rgb. */
+inline constexpr int red(Rgb rgb)
+{
+    return ((rgb >> 16) & 0xff);
+}
+
+/*! Returns the green component of the quadruplet rgb. */
+inline constexpr int green(Rgb rgb)
+{
+    return ((rgb >> 8) & 0xff);
+}
+
+/*! Returns the blue component of the quadruplet rgb. */
+inline constexpr int blue(Rgb rgb)
+{
+    return (rgb & 0xff);
+}
+
+/*! Returns the alpha component of the quadruplet rgb. */
+inline constexpr int alpha(Rgb rgb)
+{
+    return rgb >> 24;
+}
+
+/*! Creates an RGB triplet from the given color components. */
+inline constexpr Rgb rgb(int r, int g, int b)
+{
+    return (0xffu << 24) | ((r & 0xffu) << 16) | ((g & 0xffu) << 8) | (b & 0xffu);
+}
+
+/*! Creates an RGBA quadruplet from the given color components. */
+inline constexpr Rgb rgba(int r, int g, int b, int a)
+{
+    return ((a & 0xffu) << 24) | ((r & 0xffu) << 16) | ((g & 0xffu) << 8) | (b & 0xffu);
+}
+
 extern "C"
 {
     LIBSCRATCHCPP_EXPORT void value_free(ValueData *v);
@@ -33,6 +72,7 @@ extern "C"
     LIBSCRATCHCPP_EXPORT void value_toString(const ValueData *v, std::string *dst);
     LIBSCRATCHCPP_EXPORT char *value_toCString(const ValueData *v);
     LIBSCRATCHCPP_EXPORT void value_toUtf16(const ValueData *v, std::u16string *dst);
+    LIBSCRATCHCPP_EXPORT Rgb value_toRgba(const ValueData *v);
 
     LIBSCRATCHCPP_EXPORT bool value_doubleIsInt(double v);
 

src/scratch/value_functions.cpp

@@ -288,6 +288,63 @@ extern "C"
         dst->assign(utf8::utf8to16(s));
     }
 
+    /*! Returns the RGBA quadruplet from the given color value. */
+    Rgb value_toRgba(const ValueData *v)
+    {
+        // https://github.com/scratchfoundation/scratch-vm/blob/112989da0e7306eeb405a5c52616e41c2164af24/src/util/cast.js#L92-L103
+        char *string = nullptr;
+        size_t stringLen = 0;
+
+        if (v->type == ValueType::Number)
+            return v->numberValue;
+        else if (v->type == ValueType::String) {
+            string = value_toCString(v);
+            stringLen = strlen(string);
+        } else if (v->type == ValueType::Bool)
+            return v->boolValue;
+
+        if (stringLen > 0 && string[0] == '#') {
+            // https://github.com/scratchfoundation/scratch-vm/blob/a4f095db5e03e072ba222fe721eeeb543c9b9c15/src/util/color.js#L60-L69
+            // (this implementation avoids regex)
+
+            // Handle shorthand hex (e.g., "abc" -> "aabbcc")
+            char expandedHex[7] = { 0 };
+            char *ptr;
+
+            if (stringLen == 4) {
+                expandedHex[0] = string[1];
+                expandedHex[1] = string[1];
+                expandedHex[2] = string[2];
+                expandedHex[3] = string[2];
+                expandedHex[4] = string[3];
+                expandedHex[5] = string[3];
+                ptr = expandedHex;
+            } else if (stringLen == 7)
+                ptr = string + 1; // skip '#'
+            else {
+                free(string);
+                return rgb(0, 0, 0);
+            }
+
+            // Convert hex components to integers
+            int r, g, b;
+
+            if (std::sscanf(ptr, "%2x%2x%2x", &r, &g, &b) == 3) {
+                free(string);
+                return rgb(r, g, b);
+            }
+
+            free(string);
+        } else if (stringLen > 0) {
+            const double ret = value_stringToDouble(string);
+            free(string);
+            return ret;
+        } else if (string)
+            free(string);
+
+        return rgb(0, 0, 0);
+    }
+
     /*! Returns true if the given number represents a round integer. */
     bool value_doubleIsInt(double v)
     {

test/scratch_classes/value_test.cpp

@@ -1616,6 +1616,60 @@ TEST(ValueTest, ToString)
         free(s);
 }
 
+TEST(ValueTest, ToRgba)
+{
+    Value v = "#ff0000";
+    ASSERT_EQ(v.toRgba(), rgba(255, 0, 0, 255));
+
+    v = "#00ff00";
+    ASSERT_EQ(v.toRgba(), rgba(0, 255, 0, 255));
+
+    v = "#0000ff";
+    ASSERT_EQ(v.toRgba(), rgba(0, 0, 255, 255));
+
+    v = "#800000";
+    ASSERT_EQ(v.toRgba(), rgba(128, 0, 0, 255));
+
+    v = "#008000";
+    ASSERT_EQ(v.toRgba(), rgba(0, 128, 0, 255));
+
+    v = "#000080";
+    ASSERT_EQ(v.toRgba(), rgba(0, 0, 128, 255));
+
+    v = "#FF0080FF";
+    ASSERT_EQ(v.toRgba(), rgba(0, 0, 0, 255));
+
+    v = "#abc";
+    ASSERT_EQ(v.toRgba(), rgba(170, 187, 204, 255));
+
+    v = "00ff00";
+    ASSERT_EQ(v.toRgba(), 0);
+
+    v = "123";
+    ASSERT_EQ(v.toRgba(), 123);
+
+    v = "#12345";
+    ASSERT_EQ(v.toRgba(), rgba(0, 0, 0, 255));
+
+    v = "";
+    ASSERT_EQ(v.toRgba(), rgba(0, 0, 0, 255));
+
+    v = "#gggggg";
+    ASSERT_EQ(v.toRgba(), rgba(0, 0, 0, 255));
+
+    v = 2164195583;
+    ASSERT_EQ(v.toRgba(), 2164195583);
+
+    v = 0;
+    ASSERT_EQ(v.toRgba(), 0);
+
+    v = true;
+    ASSERT_EQ(v.toRgba(), 1);
+
+    v = false;
+    ASSERT_EQ(v.toRgba(), 0);
+}
+
 TEST(ValueTest, AddFunction)
 {
     Value v = 50;
@@ -3121,3 +3175,39 @@ TEST(ValueTest, StringToBool)
     ASSERT_TRUE(value_stringToBool("0b100112001"));
     ASSERT_TRUE(value_stringToBool("0b10011001.1"));
 }
+
+TEST(ValueTest, RedComponent)
+{
+    Rgb color = rgba(255, 100, 50, 255);
+    ASSERT_EQ(red(color), 255);
+}
+
+TEST(ValueTest, GreenComponent)
+{
+    Rgb color = rgba(255, 100, 50, 255);
+    ASSERT_EQ(green(color), 100);
+}
+
+TEST(ValueTest, BlueComponent)
+{
+    Rgb color = rgba(255, 100, 50, 255);
+    ASSERT_EQ(blue(color), 50);
+}
+
+TEST(ValueTest, AlphaComponent)
+{
+    Rgb color = rgba(255, 100, 50, 128);
+    ASSERT_EQ(alpha(color), 128);
+}
+
+TEST(ValueTest, RGB)
+{
+    Rgb color = rgb(255, 100, 50);
+    ASSERT_EQ(color, 0xFFFF6432);
+}
+
+TEST(ValueTest, RGBA)
+{
+    Rgb color = rgba(255, 100, 50, 128);
+    ASSERT_EQ(color, 0x80FF6432);
+}