MaterialProperty.h

#pragma once
 
#include "MaterialPropertyBuffer.h"
#include "Resources/MaterialTypes.h"
 
#include "Rendering/SamplerState.h"
 
#include "Foundation/HashFunctions.h"
 
namespace Cogs::Core
{
  enum struct MaterialPropertyFlags : uint8_t
  {
    None = 0,
    sRGB = 1 << 0,
    Normalized = 1 << 1,
    PartitionOfUnity = 1 << 2
  };
 
  ENABLE_ENUM_FLAGS(MaterialPropertyFlags);
 
  struct MaterialProperty
  {
    PropertyName name;
 
    VariableKey key = NoProperty;
 
    ConstantBufferKey buffer = NoProperty;
 
    MaterialPropertyDescriptor descriptor;
 
    MaterialDataType type = MaterialDataType::Unknown;
 
    glm::mat4 storage;
 
    template<typename T>
    void setDefault(T & t) {
      static_assert(sizeof(T) <= sizeof(storage));
      *reinterpret_cast<T *>(&storage) = t;
    }
 
    float defaultFloat() const { return *reinterpret_cast<const float *>(&storage); }
    int defaultInt() const { return *reinterpret_cast<const int *>(&storage); }
    uint32_t defaultUInt() const { return *reinterpret_cast<const uint32_t *>(&storage); }
    bool defaultBool() const { return *reinterpret_cast<const bool *>(&storage); }
 
    glm::vec2 defaultVec2() const { return *reinterpret_cast<const glm::vec2 *>(&storage); }
    glm::vec3 defaultVec3() const { return *reinterpret_cast<const glm::vec3 *>(&storage); }
    glm::vec4 defaultVec4() const { return *reinterpret_cast<const glm::vec4 *>(&storage); }
 
    bool dirty = false;
 
    bool isPerInstance = true;
 
    bool isArray = false;
 
    uint32_t arraySize = 0;
 
    MaterialPropertyFlags flags = MaterialPropertyFlags::None;
  };
 
  enum class TextureDimensions
  {
    Texture2D = 0,
    TexureCube = 1,
    Texture3D = 2,
    Texture2DArray = 3,
  };
 
  struct TextureWithSampler
  {
    TextureHandle handle = TextureHandle::NoHandle;
 
    SamplerState::AddressMode sMode = SamplerState::Wrap;
    SamplerState::AddressMode tMode = SamplerState::Wrap;
    SamplerState::AddressMode uMode = SamplerState::Wrap;
 
    SamplerState::FilterMode filterMode = SamplerState::FilterMode::MinMagMipLinear;
 
    TextureDimensions dimensions = TextureDimensions::Texture2D;
 
    size_t hash(size_t hashValue = Cogs::hash()) const {
      hashValue = handle.hash(hashValue);
      hashValue = Cogs::hash(sMode, hashValue);
      hashValue = Cogs::hash(tMode, hashValue);
      hashValue = Cogs::hash(uMode, hashValue);
      hashValue = Cogs::hash(filterMode, hashValue);
      hashValue = Cogs::hash(dimensions, hashValue);
 
      return hashValue;
    }
  };
 
  struct TextureProperty : MaterialProperty
  {
    TextureWithSampler texture;
  };
 
  struct TextureValue
  {
    const TextureProperty * property = nullptr;
 
    VariableKey key = {};
 
    TextureWithSampler texture;
 
    bool dirty = true;
 
    size_t hash(size_t hashValue = Cogs::hash()) const {
      hashValue = Cogs::hash(reinterpret_cast<intptr_t>(property), hashValue);
      hashValue = Cogs::hash(key, hashValue);
      hashValue = texture.hash(hashValue);
      hashValue = Cogs::hash(dirty, hashValue);
 
      return hashValue;
    }
  };
}