Material.h

#pragma once
 
#include "ResourceBase.h"
 
#include "MaterialDefinition.h"
#include "MaterialPropertyBuffer.h"
#include "MaterialProperty.h"
#include "MaterialOptions.h"
#include "ConstantBuffers.h"
#include "MeshStreamsLayout.h"
 
#include "Rendering/SamplerState.h"
 
#include "Foundation/StringView.h"
 
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
#include <glm/gtc/type_ptr.hpp>
 
#include <vector>
#include <string>
 
namespace Cogs
{
  namespace Core
  {
    struct EnginePermutation;
    struct MaterialInstance;
    struct RenderPassOptions;
    enum struct ClipShapeType : uint32_t;
 
    void COGSCORE_DLL_API enforcePropertyFlags(const MaterialProperty & prop, MaterialPropertyFlags flags, void * data);
 
    struct MaterialFlags
    {
      enum EMaterialFlags
      {
        None = 0x0000,
        Default = 0x0001,
        MasterTransparency = 0x0002,
        Backdrop = 0x0004,
        OverrideColor = 0x0008,
        OverrideAlpha = 0x0010,
        OverrideTextures = 0x0020,
        OverrideProperties = 0x0040,
        Override = OverrideTextures | OverrideColor | OverrideAlpha | OverrideProperties | 0x0080,
        Sprite = 0x0100,
        CustomBucket = 0x0200
      };
    };
 
    struct COGSCORE_DLL_API Material : public ResourceBase
    {
      static const constexpr size_t NoVariantIndex = size_t(-1);
 
      Material() = default;
 
      Material(Material && other) noexcept = default;
 
      Material & operator=(Material && other) noexcept = default;
 
      void setMaterialFlag(MaterialFlags::EMaterialFlags flag) { this->materialFlags |= flag; }
 
      void unsetMaterialFlag(MaterialFlags::EMaterialFlags flag) { this->materialFlags &= ~flag; }
 
      bool isDefaultMaterial() const { return materialFlags & MaterialFlags::Default ? true : false; }
 
      VariableKey addTextureProperty(const PropertyName & name,
                                     TextureHandle defaultValue,
                                     TextureDimensions dimensions = TextureDimensions::Texture2D,
                                     SamplerState::AddressMode addressMode = SamplerState::Wrap,
                                     SamplerState::FilterMode filterMode = SamplerState::FilterMode::MinMagMipLinear,
                                     bool isPerInstance = true,
                                     bool isArray = false, uint32_t arraySize = 0)
      {
        TextureWithSampler texture;
        texture.handle = defaultValue;
        texture.sMode = addressMode;
        texture.tMode = addressMode;
        texture.uMode = addressMode;
        texture.filterMode = filterMode;
        texture.dimensions = dimensions;
 
        const VariableKey key = static_cast<VariableKey>(textureProperties.size());
        auto & textureProperty = textureProperties.emplace_back();
 
        textureProperty.key = key;
        textureProperty.isPerInstance = isPerInstance;
        textureProperty.name = name;
        textureProperty.texture = texture;
        textureProperty.isArray = isArray;
        textureProperty.arraySize = arraySize;
 
        return key;
      }
 
      MaterialDataType getPropertyDataType(const StringView& key);
 
      void setProperty(const StringView& name, const void* data, const size_t sizeInBytes);
 
      template<typename T>
      void setProperty(const VariableKey key, T value)
      {
        constantBuffers.setProperty(key, value);
 
        setChanged();
      }
 
      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 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);
 
      VariableKey getBoolKey(const StringView & name) const
      {
        return constantBuffers.getPropertyKey(name);
      }
 
      VariableKey getFloatKey(const StringView & name) const
      {
        return constantBuffers.getPropertyKey(name);
      }
 
      VariableKey getIntKey(const StringView & name) const
      {
        return constantBuffers.getPropertyKey(name);
      }
 
      VariableKey getUIntKey(const StringView & name) const
      {
        return constantBuffers.getPropertyKey(name);
      }
 
      VariableKey getVec3Key(const StringView & name) const
      {
        return constantBuffers.getPropertyKey(name);
      }
 
      VariableKey getVec4Key(const StringView & name) const
      {
        return constantBuffers.getPropertyKey(name);
      }
 
      VariableKey getInt4Key(const StringView& name) const
      {
        return constantBuffers.getPropertyKey(name);
      }
 
      VariableKey getMat4Key(const StringView & name) const
      {
        return constantBuffers.getPropertyKey(name);
      }
 
      VariableKey getVec2Key(const StringView & name) const
      {
        return constantBuffers.getPropertyKey(name);
      }
 
      VariableKey getTextureKey(const StringView & name) const
      {
        for (auto & prop : textureProperties) {
          if (name == prop.name) {
            return prop.key;
          }
        }
 
        return NoProperty;
      }
 
      size_t getVariantIndex(const StringView& key) const;
 
      void setVariant(size_t index, int value);
 
      void setVariant(const StringView& key, int value);
 
      MaterialDefinition definition;
 
      size_t variantGeneration = 0; // Changed when definition.variant default values change.
 
      std::vector<std::string> permutationKeys;
 
      struct EffectInstance
      {
        EffectHandle handle;
        size_t code;
      };
 
      EffectHandle getEffect(size_t code,
                             const MaterialInstance * materialInstance,
                             const MeshStreamsLayout* streamsLayout,
                             const EnginePermutation * enginePermutation,
                             const RenderPassOptions& passOptions,
                             const ClipShapeType clipShape);
 
      std::vector<EffectInstance> effects;
 
      ConstantBuffers constantBuffers;
      
      MaterialOptions options;
 
      uint16_t materialFlags = MaterialFlags::None;
 
      uint64_t enginePermutationMask = 0x1 | 0x2 | 0x3 | 0x4;
 
      std::vector<TextureProperty> textureProperties;
    };
  }
}
 
template<> inline Cogs::StringView getName<Cogs::Core::MaterialFlags::EMaterialFlags>() { return "MaterialFlags"; }