ReaderCommon.h

#pragma once
 
#include <glm/glm.hpp>
 
#include <algorithm>
 
#include "JsonParser.h"
 
#include "Utilities/Expressions.h"
 
namespace Cogs
{
  namespace Core
  {
    template<typename T>
    T readValue(const Value & value, T defaultValue, ExpressionContext * ev)
    {
      if (value.IsString()) {
        return ev->eval(value.GetString(), defaultValue);
      } else if (value.IsNumber()) {
        return static_cast<T>(value.GetDouble());
      }
 
      return defaultValue;
    }
 
    template<typename T>
    T readValue(const Value & value, ExpressionContext * ev)
    {
      return static_cast<T>(readValue(value, 0.0, ev));
    }
 
    inline uint32_t readArray(const Value& value, float* dst, unsigned N, ExpressionContext* ev)
    {
      if (!value.IsArray()) return 0;
 
      auto vectorValues = value.GetArray();
      const uint32_t length = std::min(N, vectorValues.Size());
 
      for (uint32_t el = 0; el < length; ++el) {
        dst[el] = readValue(vectorValues[el], 0.0f, ev);
      }
 
      return length;
    }
 
    template<int S, typename T, glm::precision P, template <int, typename, glm::precision> class vecType>
    uint32_t readArray(const Value & value, vecType<S, T, P> & result, ExpressionContext * ev)
    {
      if (!value.IsArray()) return 0;
 
      const size_t Size = result.length();
      auto vectorValues = value.GetArray();
      const uint32_t length = std::min(static_cast<uint32_t>(Size), vectorValues.Size());
 
      for (uint32_t el = 0; el < length; ++el) {
        result[el] = readValue(vectorValues[el], 0.0f, ev);
      }
 
      return length;
    }
  }
}