EffectsCommon.h

#pragma once
 
#include "../Common.h"
#include "../IEffects.h"
 
#include "ResourcePointer.h"
#include "ResourceMap.h"
 
#include "Foundation/StringView.h"
 
#include <memory>
#include <unordered_map>
 
#ifdef _WIN32
#include <d3dcommon.h>
#else
namespace Cogs
{
  struct IUnknown
  {
    void AddRef() {}
    int Release() { return 0; }
  };
 
  struct ID3DBlob : public IUnknown
  {
  };
}
using IUnknown = Cogs::IUnknown;
#endif
 
#ifdef COGS_VULKAN
#include "../Vulkan/CommonVK.h"
#else
using VkShaderModule = intptr_t;
#endif
 
namespace Cogs
{
  const static uint8_t NoBinding = 0xFF;
 
#ifdef COGSRENDERING_GFX_ANNOTATE
  StringView tryToName(const StringView filename);
#endif
 
  struct StringId
  {
    StringId(const StringView & str) : id(Cogs::hash(str))
    {
#ifdef _DEBUG
      name = std::string(str);
#endif
    }
    StringId(const char * str) : StringId(StringView(str)) {}
 
    operator size_t() { return id; }
 
    size_t id = 0;
#ifdef _DEBUG
    std::string name;
#endif
  };
 
  struct ShaderConstantBuffer
  {
    std::unordered_map<size_t, uint16_t> variables;
 
    BufferHandle buffer;
    std::vector<uint8_t> memoryBuffer;
 
    std::vector<size_t> offsets;
    std::vector<size_t> sizes;
 
    std::string name;
    uint32_t size = 0;
 
    uint32_t slot = 0;
    uint32_t binding = 0;
    uint32_t index = 0;
    bool dirty = false;
    bool manual = false;
  };
 
  struct InputAttribute
  {
    std::string semantic;
    uint32_t index = 0;
    uint32_t reg = 0;
  };
 
  struct ShaderReflectionInfo
  {
    std::unordered_map<size_t, uint32_t> slots;
    std::vector<ShaderConstantBuffer> constantBuffers;
 
    std::vector<InputAttribute> inputAttributes;
 
    std::unordered_map<size_t, uint32_t> samplers;
    std::unordered_map<size_t, uint32_t> textures;
 
    std::unordered_map<size_t, uint32_t> bufferUAVs;
    std::unordered_map<size_t, uint32_t> bufferSRVs;
 
    uint32_t srvSlots = 0;
  };
 
  struct Shader
  {
    ResourcePointer<ID3DBlob> byteCode; // Shader Compiler
    ResourcePointer<IUnknown> shader; // D3D
    VkShaderModule shaderModule = 0; // Vulkan
    ShaderHandle shaderHandle; // OpenGL20
    ShaderReflectionInfo reflection;
  };
 
  struct ConstantBufferVariable
  {
    ShaderConstantBuffer * buffer;
    size_t offset;
    size_t size;
  };
 
  struct EffectVariable
  {
    std::vector<ConstantBufferVariable> variables;
  };
 
  struct ShaderType
  {
    enum EShaderType : uint32_t
    {
      VertexShader = 0,
      HullShader = 1,
      DomainShader = 2,
      GeometryShader = 3,
      PixelShader = 4,
      ComputeShader = 5,
      LastShaderType = PixelShader,
      NumShaderTypes = PixelShader + 1,
      NumShaderSlots = ComputeShader + 1,
    };
  };
 
  struct SlotType
  {
    enum ESlotType : uint32_t
    {
      CBV = 0,
      SRV = 1,
      Sampler = 2,
      UAV = 3,
      NumSlotTypes = UAV + 1
    };
  };
 
  struct Bindings
  {
    uint32_t values[ShaderType::NumShaderTypes];
    uint32_t rangeIndex[ShaderType::NumShaderTypes];
  };
 
  struct Signature
  {
    Bindings slots[SlotType::NumSlotTypes];
  };
 
  struct RootSignature : public Signature
  {
 
  };
 
  struct EffectSignature : public Signature
  {
 
  };
 
  struct Effect
  {
    Effect() :
      vertexShader(shaders[ShaderType::VertexShader]),
      hullShader(shaders[ShaderType::HullShader]),
      domainShader(shaders[ShaderType::DomainShader]),
      geometryShader(shaders[ShaderType::GeometryShader]),
      pixelShader(shaders[ShaderType::PixelShader]),
      computeShader(shaders[ShaderType::ComputeShader])
    {
 
    }
 
    Effect & operator=(const Effect & other)
    {
      for (size_t i = 0; i < ShaderType::NumShaderSlots; ++i) {
        shaders[i] = other.shaders[i];
      }
 
      effectVariables = other.effectVariables;
      signature = other.signature;
 
      return *this;
    }
 
    Effect & operator=(Effect && other) noexcept
    {
      for (size_t i = 0; i < ShaderType::NumShaderSlots; ++i) {
        shaders[i] = std::move(other.shaders[i]);
      }
 
      effectVariables = std::move(other.effectVariables);
      signature = std::move(other.signature);
 
      return *this;
    }
 
    void buildSignature();
 
    EffectSignature signature;
 
    Shader shaders[ShaderType::NumShaderSlots];
 
    std::unordered_map<size_t, EffectVariable> effectVariables;
 
    Shader & vertexShader;
    Shader & hullShader;
    Shader & domainShader;
    Shader & geometryShader;
    Shader & pixelShader;
    Shader & computeShader;
  };
 
  struct BufferBinding
  {
    int64_t uavBindings;
    int64_t srvBindings;
  };
 
  struct EffectsCommon : public IEffects
  {
    EffectHandle loadEffect(const EffectDescription & description) final;
    EffectHandle loadEffectSource(const EffectDescription & description);
    EffectHandle loadEffectContents(const EffectDescription & description, const EffectContents & contents);
 
    EffectHandle loadEffect(const StringView & fileName, EffectFlags::EEffectFlags effectFlags = EffectFlags::None) final;
    EffectHandle loadEffect(const StringView & fileName, const PreprocessorDefinitions & defines, EffectFlags::EEffectFlags effectFlags = EffectFlags::None);
 
    EffectHandle loadEffect(const StringView & vsFileName, const StringView & psFileName, EffectFlags::EEffectFlags effectFlags = EffectFlags::None) final;
    EffectHandle loadEffect(const StringView & vsFileName, const StringView & psFileName, const PreprocessorDefinitions & defines, EffectFlags::EEffectFlags effectFlags = EffectFlags::None) final;
 
    EffectHandle loadEffectSource(const StringView & vsSource, const StringView & psSource, EffectFlags::EEffectFlags effectFlags = EffectFlags::None) final;
    EffectHandle loadEffectSource(const StringView & vsSource, const StringView & psSource, const PreprocessorDefinitions & defines, EffectFlags::EEffectFlags effectFlags = EffectFlags::None) final;
 
    EffectHandle loadEffectSource(const StringView & vsSource, const StringView & gsSource, const StringView & psSource, EffectFlags::EEffectFlags effectFlags = EffectFlags::None) final;
    EffectHandle loadEffectSource(const StringView & vsSource, const StringView & gsSource, const StringView & psSource, const PreprocessorDefinitions & defines, EffectFlags::EEffectFlags effectFlags = EffectFlags::None) final;
 
    EffectVariableHandle getEffectVariable(EffectHandle effectHandle, const StringView & name) override;
    ConstantBufferBindingHandle getConstantBufferBinding(EffectHandle effectHandle, const StringView & name) override;
    TextureBindingHandle getTextureBinding(EffectHandle effectHandle, const StringView & name, const unsigned int slot) override;
    SamplerStateBindingHandle getSamplerStateBinding(EffectHandle effectHandle, const StringView & name, const unsigned int slot) override;
    BufferBindingHandle getBufferBinding(EffectHandle effectHandle, const StringView & name) override;
    void releaseBufferBinding(BufferBindingHandle bufferBindingHandle) override;
 
    void setIOHandler(IIOHandler * handler) override { this->handler = handler; }
    IIOHandler * getIOHandler() override { return handler; }
 
    EffectHandle load(const ProcessedContent & vsSource,
      const ProcessedContent & psSource,
      const StringView & vsEntryPoint,
      const StringView & psEntryPoint,
      const EffectDescription & desc);
 
    EffectHandle load(const ProcessedContent & vsSource,
      const ProcessedContent & gsSource,
      const ProcessedContent & psSource,
      const StringView & vsEntryPoint,
      const StringView & gsEntryPoint,
      const StringView & psEntryPoint,
      const EffectDescription & desc);
 
    virtual EffectHandle load(const ProcessedContent & vsSource,
      const ProcessedContent & hsSource,
      const ProcessedContent & dsSource,
      const ProcessedContent & gsSource,
      const ProcessedContent & psSource,
      const StringView & vsEntryPoint,
      const StringView & hsEntryPoint,
      const StringView & dsEntryPoint,
      const StringView & gsEntryPoint,
      const StringView & psEntryPoint,
      const EffectDescription & desc) = 0;
 
    void initialize(struct IBuffers * buffers);
 
    SafeResourceMap<EffectHandle, Effect> effects;
 
    ResourceMap<BufferBindingHandle, BufferBinding> bufferBindings;
 
    IIOHandler * handler = nullptr;
    std::unique_ptr<IIOHandler> defaultHandler;
    struct IBuffers * buffers = nullptr;
  };
 
  template<typename StateVariableType, size_t Slots>
  struct Binding
  {
    Binding() = default;
 
    bool hasChanged() const
    {
      return changed != 0;
    }
 
    void setUnchanged()
    {
      changed = 0;
    }
 
    void setChanged()
    {
      changed = 0xFFFFFFFF;
    }
 
    void setChanged(size_t slot, StateVariableType variable, bool force = false)
    {
      if (variables[slot] == variable && !force) return;
 
      ++numChanged;
      variables[slot] = variable;
      changed |= 1 << slot;
    }
 
    void setAnyChanged(StateVariableType && variable)
    {
      for (size_t i = 0; i < Slots; ++i) {
        if (variables[i] == variable) {
          setChanged(i, std::forward<StateVariableType &&>(variable), true);
        }
      }
    }
 
    bool getChanged(size_t slot) const
    {
      return (changed & (1 << slot)) != 0;
    }
 
    size_t size() const { return Slots; }
 
    const StateVariableType & operator[](size_t index) const
    {
      return variables[index];
    }
 
  private:
    StateVariableType variables[Slots] = { 0 };
    uint32_t changed = 0xFFFFFFFF;
    uint32_t numChanged = 0;
  };
 
  template<typename T, size_t Size>
  inline void decode(int64_t handle, T(&slots)[Size])
  {
    uint64_t value = static_cast<uint64_t>(handle);
 
    if ((value == 0) || (value == ~0ull)) {
      value = ~0ull; // If NoHandle or IllegalHandle, all slots to NoSlot.
    }
 
    for (size_t i = 0; i < Size; ++i) {
      slots[i] = (value >> (i * 8)) & 0xFF;
    }
  }
 
  inline uint8_t decode(int64_t handle)
  {
    uint64_t value = static_cast<uint64_t>(handle);
 
    if ((value == 0) || (value == ~0ull)) {
      return NoBinding;
    } else {
      return static_cast<uint8_t>(value & 0xffu);
    }
  }
 
}