MaterialDefinition.h

#pragma once
 
#include <vector>
 
#include <glm/glm.hpp>
 
#include <unordered_map>
 
#include "MaterialTypes.h"
#include "EffectDefinition.h"
#include "MaterialProperty.h"
 
#include "Resources/VariantDefinition.h"
 
namespace Cogs
{
  namespace Core
  {
    struct ConstantBufferVariableDefinition : public ValueDefinition
    {
      ConstantBufferVariableDefinition() { float4x4Value = glm::mat4(0.0); }
      ConstantBufferVariableDefinition(const ConstantBufferVariableDefinition & other) : ValueDefinition(other) { float4x4Value = other.float4x4Value; flags = other.flags; }
      ConstantBufferVariableDefinition operator=(const ConstantBufferVariableDefinition & other) { float4x4Value = other.float4x4Value; ValueDefinition::operator=(other); flags = other.flags; return *this; }
      union
      {
        float floatValue;
        glm::vec2 float2Value;
        glm::vec3 float3Value;
        glm::vec4 float4Value;
        glm::mat4 float4x4Value;
        uint32_t uintValue;
        glm::uvec2 uint2Value;
        glm::uvec3 uint3Value;
        glm::uvec4 uint4Value;
        int intValue;
        glm::ivec2 int2Value;
        glm::ivec3 int3Value;
        glm::ivec4 int4Value;
        bool boolValue;
      };
      MaterialPropertyFlags flags = MaterialPropertyFlags::None;
    };
 
    struct ConstantBufferDefinition
    {
      std::string name;
 
      std::vector<ConstantBufferVariableDefinition> values;
 
      bool isPerInstance = false;
    };
 
    struct MaterialTextureDefinition
    {
      std::string name;
 
      bool isPerInstance;
      bool isSrgb;
      bool isArray;
 
      uint32_t arraySize;
 
      TextureDimensions dimensions;
      MaterialDataType format = MaterialDataType::Unknown;
    };
 
    struct MaterialProperties
    {
      std::vector<MaterialTextureDefinition> textures;
 
      std::vector<ConstantBufferDefinition> buffers;
    };
 
    enum class MaterialDefinitionFlags : uint32_t
    {
      None = 0,
      IsTemplate = 1 << 0,
    };
 
    ENABLE_ENUM_FLAGS(MaterialDefinitionFlags);
 
    struct MaterialDefinitionBase
    {
      std::string name;
 
      MaterialProperties properties;
 
      EffectDefinition effect;
 
      MaterialDefinitionFlags flags = MaterialDefinitionFlags::None;
 
      std::vector<ShaderVariantRequirement> requirements;
 
      std::unordered_map<std::string, std::string> options;
      
      std::vector<ShaderVariantDefinition> variants;
 
      size_t permutationIndex = 0;
      std::string permutationName;
 
      size_t enginePermutationMask = 0x1 | 0x2 | 0x4 | 0x8;
    };
 
    struct MaterialDefinition : public MaterialDefinitionBase
    {
      std::string inherits;
 
      std::vector<MaterialDefinition> permutations;
 
      bool isTemplate() const { return (flags & MaterialDefinitionFlags::IsTemplate) != 0; }
    };
  }
}