fx serialization shit

template <typename T>
concept C_IsIntType = C_IsAnyOf<T, int16, uint16, int32, uint32, int64, uint64>;

template <typename T>
concept C_IsFloatType = std::is_same_v<T, float32>;

template <typename T>
concept C_IsSerializable = C_IsIntType<T> || C_IsFloatType<T>;


struct FxSerializerValue
{
public:
    enum Type
    {
        eInt,
        eFloat,
    };

public:
    FxSerializerValue() = delete;

    template <typename T>
        requires C_IsIntType<T>
    explicit FxSerializerValue(T value) : Type(eInt), IntValue(value)
    {
    }

    template <typename T>
        requires C_IsFloatType<T>
    explicit FxSerializerValue(T value) : Type(eFloat), FloatValue(value)
    {
    }

public:
    Type Type;

    union
    {
        int64 IntValue;
        float32 FloatValue;
    };
};

class FxSerializer
{
public:
    FxSerializer() { Values.Create(16); }

    FxSerializer(const FxSerializer& other) = delete;


    template <typename T>
        requires C_IsSerializable<T>
    FxSerializer& operator<<(T value)
    {
        Values.Insert(FxSerializerValue { value });
        return *this;
    }

    template <typename T>
        requires C_IsSerializable<T>
    FxSerializer& Add(T& member)
    {
        if (bInWriteMode) {
            (*this) << member;
        }
        else {
            (*this) >> member;
        }

        return *this;
    }

    void SetWriteMode() { bInWriteMode = true; }
    void SetReadMode() { bInWriteMode = false; }

    template <typename T>
        requires C_IsSerializable<T>
    FxSerializer& operator>>(T& value)
    {
        if (WriteIndex > Values.Size()) {
            return *this;
        }

        FxSerializerValue& stored_value = Values[WriteIndex++];

        if constexpr (C_IsIntType<T>) {
            value = stored_value.IntValue;
        }
        else if constexpr (C_IsFloatType<T>) {
            value = stored_value.FloatValue;
        }

        return *this;
    }


    void Rewind() { WriteIndex = 0; }

public:
    int WriteIndex = 0;
    FxPagedArray<FxSerializerValue> Values;

    bool bInWriteMode = true;
};

#define FX_SERIALIZABLE_MEMBERS(...)                                                                                   \
    template <typename... TMemberTypes>                                                                                \
    void SerializerDefineRecursive(FxSerializer& s, TMemberTypes&... types)                                            \
    {                                                                                                                  \
        (s.Add(types), ...);                                                                                           \
    }                                                                                                                  \
    void SerializeNow(FxSerializer& s) { SerializerDefineRecursive(s, __VA_ARGS__); }                                  \
    void Serialize(FxSerializer& s)                                                                                    \
    {                                                                                                                  \
        s.SetWriteMode();                                                                                              \
        SerializeNow(s);                                                                                               \
    }                                                                                                                  \
    void Deserialize(FxSerializer& s)                                                                                  \
    {                                                                                                                  \
        s.SetReadMode();                                                                                               \
        SerializeNow(s);                                                                                               \
    }


struct SerializeTest
{
    FX_SERIALIZABLE_MEMBERS(X, Y);

    void Print() { FxLogInfo("Object: [{}, {}]", X, Y); }

    float X = 0;
    int Y = 0;
};