EntityDefinition.h

#pragma once
 
/*
 * Include this header to access struct EntityDefinition and struct FieldValue.
 * Common usage is to define custom entities in extensions.
 *
 * Alternative is defining the entity in JSON and adding to Store using Cogs::Core::readEntityDefinition.
 */
#include "Base.h"
 
#include "ComponentFunctions.h"
#include "Types.h"
 
#include "Foundation/Reflection/Type.h"
 
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
#include <glm/ext/quaternion_float.hpp>
 
#include <vector>
#include <functional>
#include <span>
#include <unordered_map>
 
namespace Cogs
{
  namespace Core
  {
    enum class DefaultValueType
    {
      Unknown = 0,
      Bool,
      Float,
      Int,
      Enum,
      Vec2,
      Vec3,
      Vec4,
      Mat4,
      DVec2,
      DVec3,
      DVec4,
      Quaternion,
      MaterialInstance,
      Model,
      Asset,
      Mesh,
      Texture,
      Gui,
      String,
      MultiString,
      IntArray,
      FloatArray,
      Vec2Array,
      Vec3Array,
      Vec4Array,
      Entity,
      EntityArray,
      Extension,
    };
 
    struct ResourceDefinition;
    using MaterialInstanceDefinition = ResourceDefinition;
 
    struct FieldValue
    {
      FieldValue() {}
 
      FieldValue(const FieldValue& original) {
        componentId = original.componentId;
        fieldId = original.fieldId;
        type = original.type;
 
        std::memcpy(storage, original.storage, sizeof(storage));
 
        value = original.value;
        values = original.values;
        intValues = original.intValues;
        floatValues = original.floatValues;
        vec3Values = original.vec3Values;
        vec2Values = original.vec2Values;
        vec4Values = original.vec4Values;
      }
 
      Reflection::TypeId componentId = Reflection::NoType;
 
      Reflection::FieldId fieldId = Reflection::NoField;
 
      DefaultValueType type = DefaultValueType::Unknown;
 
      union
      {
        bool boolValue;
        float floatValue;
        double doubleValue;
        int intValue;
        glm::vec2 float2;
        glm::vec3 float3;
        glm::vec4 float4;
        glm::quat quat;
        glm::dvec2 double2;
        glm::dvec3 double3;
        glm::dvec4 double4;
        glm::mat4x4 mat4;
#ifdef DEBUG
        // Odd size because we must accommodate MaterialInstanceDefinition in debug mode.
        char storage[512+32] = { 0 };
#else
        char storage[512] = { 0 };
#endif
      };
 
      std::string value;
      std::vector<std::string> values;
      std::vector<int> intValues;
      std::vector<float> floatValues;
      std::vector<glm::vec3> vec3Values;
      std::vector<glm::vec2> vec2Values;
      std::vector<glm::vec4> vec4Values;
 
      const MaterialInstanceDefinition * asMaterialInstance() const { return reinterpret_cast<const MaterialInstanceDefinition *>(storage); }
 
      FieldValue& operator =(const FieldValue& rhs) {
        componentId = rhs.componentId;
        fieldId = rhs.fieldId;
        type = rhs.type;
 
        std::memcpy(storage, rhs.storage, sizeof(storage));
 
        value = rhs.value;
        values = rhs.values;
        intValues = rhs.intValues;
        floatValues = rhs.floatValues;
        vec3Values = rhs.vec3Values;
        vec2Values = rhs.vec2Values;
        vec4Values = rhs.vec4Values;
 
        return *this;
      }
    };
 
    struct EntityDefinition
    {
      EntityDefinition() = default;
 
      std::string name;
 
      std::string description;
 
      std::vector<std::string> components;
 
      bool compiled = false;
 
      std::vector<ComponentCreator *> creators;
 
      std::vector<FieldValue> defaultValues;
    };
 
    void applyFieldValues(class Context * context, std::span<FieldValue> entityDefinition, ComponentModel::Entity * entity);
 
    struct MaterialInstance;
 
    void updateMaterialInstance(Context * context, MaterialInstance * materialInstance, const MaterialInstanceDefinition & value);
  }
}