MaterialInstance.h

#pragma once
#include "Material.h"
 
#include "Foundation/StringView.h"
 
namespace Cogs
{
  namespace Core
  {
    struct COGSCORE_DLL_API MaterialInstance : public ResourceBase
    {
      MaterialInstance() = default;
 
      MaterialInstance(MaterialInstance && other) noexcept = default;
 
      MaterialInstance & operator=(MaterialInstance && other) noexcept = default;
 
      void setupInstance(Material * material);
 
      void clone(MaterialInstance * instance);
 
      int cloneMatchingProperties(MaterialInstance * instance);
 
      void cloneMatchingVariants(MaterialInstance * instance);
 
      void reset();
 
      void setMaterialFlag(MaterialFlags::EMaterialFlags flag) { this->instanceFlags |= flag; }
 
      void setMaterialFlag(MaterialFlags::EMaterialFlags flag, bool status) { instanceFlags = (instanceFlags & ~flag) | (-static_cast<int>(status) & flag); }
 
      void unsetMaterialFlag(MaterialFlags::EMaterialFlags flag) { this->instanceFlags &= ~flag; }
 
      uint16_t getMaterialFlags() const { return (material->materialFlags & instanceFlags) | instanceFlags; }
 
      void setBackdrop() { setMaterialFlag(MaterialFlags::Backdrop); options.depthWriteEnabled = false; }
 
      void unsetBackdrop() { unsetMaterialFlag(MaterialFlags::Backdrop); options.depthWriteEnabled &= true; }
 
      bool isBackdrop() const { return instanceFlags & MaterialFlags::Backdrop ? true : false; }
 
      void setTransparent();
 
      void setOpaque();
 
      bool hasTransparency() const;
 
      bool isDefaultMaterial() const { return material->isDefaultMaterial(); }
 
      void setOption(const StringView & key, const StringView & value);
 
      void setProperty(const StringView & key, const void * value, const size_t sizeInBytes);
      void setProperty(VariableKey key, const void * value, const size_t sizeInBytes);
 
      bool getProperty(const StringView & key, void * value, const size_t sizeInBytes) const;
      bool getProperty(VariableKey key, void * value, const size_t sizeInBytes) const;
 
      void setTextureAddressMode(const StringView & key, const StringView & addressMode);
 
      void setTextureFilterMode(const StringView& key, const StringView& filterMode);
 
      template<typename T>
      void setProperty(const VariableKey key, T value)
      {
        auto & materialProperty = material->constantBuffers.variables[key];
        if (!materialProperty.isPerInstance)
        {
          material->setProperty(key, value);
          return;
        }
        if (materialProperty.flags != MaterialPropertyFlags::None) {
          enforcePropertyFlags(materialProperty, materialProperty.flags, &value);
        }
 
        buffers[materialProperty.buffer].setValue(materialProperty.descriptor.offset, value);
 
        setChanged();
      }
 
      template<typename T>
      T getProperty(const VariableKey key) const
      {
        T t;
        getProperty(key, &t, sizeof(T));
        return t;
      }
 
      void setVec2Property(const VariableKey key, glm::vec2 value)
      {
        setProperty(key, value);
      }
 
      void setVec3Property(const VariableKey key, glm::vec3 value)
      {
        setProperty(key, value);
      }
 
      void setVec4Property(const VariableKey key, glm::vec4 value)
      {
        setProperty(key, value);
      }
 
      void setInt4Property(const VariableKey key, glm::ivec4 value)
      {
        setProperty(key, value);
      }
 
      void setMat4Property(const VariableKey key, glm::mat4 value)
      {
        setProperty(key, value);
      }
 
      void setFloatProperty(const VariableKey key, float value)
      {
        setProperty(key, value);
      }
 
      void setIntProperty(const VariableKey key, int value)
      {
        setProperty(key, value);
      }
 
      void setUIntProperty(const VariableKey key, uint32_t value)
      {
        setProperty(key, value);
      }
 
      void setBoolProperty(const VariableKey key, bool value)
      {
        setProperty(key, value);
      }
 
      void setTextureProperty(const StringView & key, TextureHandle value);
      void setTextureProperty(const VariableKey key, TextureHandle value);
 
      void setTextureAddressMode(const VariableKey key, SamplerState::AddressMode mode);
      void setTextureAddressMode(const VariableKey key, SamplerState::AddressMode sMode, SamplerState::AddressMode tMode, SamplerState::AddressMode uMode);
 
      void setTextureFilterMode(const VariableKey key, SamplerState::FilterMode filterMode);
 
      glm::vec2 getVec2Property(const VariableKey key) const
      {
        return getProperty<glm::vec2>(key);
      }
 
      glm::vec3 getVec3Property(const VariableKey key) const
      {
        return getProperty<glm::vec3>(key);
      }
 
      glm::vec4 getVec4Property(const VariableKey key) const
      {
        return getProperty<glm::vec4>(key);
      }
 
      glm::mat4 getMat4Property(const VariableKey key) const
      {
        return getProperty<glm::mat4>(key);
      }
 
      bool getBoolProperty(const VariableKey key) const
      {
        return getProperty<bool>(key);
      }
 
      float getFloatProperty(const VariableKey key) const
      {
        return getProperty<float>(key);
      }
 
      TextureValue getTextureProperty(const VariableKey key) const
      {
        if (key != NoProperty) {
          return textureVariables[key];
        }
        return TextureValue();
      }
 
      size_t getPermutationIndex(const StringView & key) const;
 
      void setPermutation(const StringView & key);
 
      StringView getPermutation() const;
 
      void setVariant(size_t index, int value);
      void setVariant(size_t index, bool value);
      void setVariant(size_t index, const StringView & value);
 
      void setVariant(const StringView & key, const StringView & value);
      void setVariant(const StringView & key, const char* value) { setVariant(key, StringView(value)); }
      void setVariant(const StringView & key, bool value);
      void setVariant(const StringView & key, int value);
 
      std::string getVariant(const StringView & key) const;
 
      Material * material = nullptr;
 
      MaterialInstanceHandle masterInstance;
 
      std::vector<MaterialPropertyBufferInstance> buffers;
 
      std::vector<TextureValue> textureVariables;
 
      uint16_t instanceFlags = MaterialFlags::None;
 
      MaterialOptions options;
 
      ShaderVariantSelectors variantSelectors;
 
      std::vector<std::string> variantStrings;
 
      size_t permutationIndex = 0;
 
      size_t variantGeneration = 0;
 
      uint16_t buffersGeneration = 1;
    };
  }
}