ValueVariant.h

#pragma once
 
#include "Base.h"
 
#include "Foundation/StringView.h"
 
#include <glm/glm.hpp>
 
namespace Cogs::Core
{
  enum class ParsedDataType
  {
    Unknown = 0,
    Object,
    String,
    Float,
    Float2,
    Float3,
    Float4,
    Float4x4,
    Int,
    Int2,
    Int3,
    Int4,
    UInt,
    UInt2,
    UInt3,
    UInt4,
    Bool,
    Double,
    Number = Double,
    Texture2D,
    ConstantBuffer,
    Buffer,
    Count
  };
 
  struct COGSCORE_DLL_API ValueVariant
  {
    ValueVariant() : float4x4Value(0.f) {};
    ValueVariant( const ValueVariant& original);
    explicit ValueVariant(float value) : floatValue(value), type(ParsedDataType::Float) {}
    explicit ValueVariant(bool value) : boolValue(value), type(ParsedDataType::Bool) {}
    explicit ValueVariant(double value) : doubleValue(value), type(ParsedDataType::Double) {}
    explicit ValueVariant(int value) : intValue(value), type(ParsedDataType::Int) {}
    explicit ValueVariant(const char * value) : float4x4Value(0.f), stringValue(value), type(ParsedDataType::String) {}
    explicit ValueVariant(const StringView & value) : float4x4Value(0.f), stringValue(value.to_string()), type(ParsedDataType::String) {}
    explicit ValueVariant(glm::vec2 value) : float2Value(value), type(ParsedDataType::Float2) {}
    explicit ValueVariant(glm::vec3 value) : float3Value(value), type(ParsedDataType::Float3) {}
    explicit ValueVariant(glm::vec4 value) : float4Value(value), type(ParsedDataType::Float4) {}
 
    bool isNumericType(ParsedDataType type) const;
    bool isNumeric() const { return isNumericType(type); }
    bool isFloat() const { return isNumeric(); }
 
    float getFloat(float defaultValue = 0.0f) const;
    double getDouble(double defaultValue = 0.0) const;
    bool getBool(bool defaultValue = false) const;
    int getInt(int defaultValue = false) const;
    glm::vec2 getVec2(glm::vec2 defaultValue = {}) const;
    glm::vec3 getVec3(glm::vec3 defaultValue = {}) const;
    glm::vec4 getVec4(glm::vec4 defaultValue = {}) const;
    StringView getString(StringView defaultValue) const;
 
    ParsedDataType getType() const { return type; }
 
    ValueVariant& operator =( const ValueVariant& rhs);
 
  private:
    union
    {
      float floatValue;
      glm::vec2 float2Value;
      glm::vec3 float3Value;
      glm::vec4 float4Value;
      glm::mat4 float4x4Value;
      int intValue;
      glm::ivec2 int2Value;
      glm::ivec3 int3Value;
      glm::ivec4 int4Value;
      uint32_t uintValue;
      glm::uvec2 uint2Value;
      glm::uvec3 uint3Value;
      glm::uvec4 uint4Value;
      bool boolValue;
      double doubleValue;
    };
    
    std::string stringValue;
 
    ParsedDataType type = ParsedDataType::Unknown;
  };
}