EnginePermutations.h

#pragma once
 
#include "Base.h"
 
#include "Resources/VariantDefinition.h"
#include "Resources/MaterialPropertyBuffer.h"
#include "Resources/MaterialProperty.h"
#include "Resources/MaterialDefinition.h"
#include "Resources/ConstantBuffers.h"
 
#include "Components/Core/RenderComponent.h"
 
#include "Utilities/Parsing.h"
 
#include "Rendering/IEffects.h"
 
#include "Foundation/StringView.h"
#include "Foundation/Collections/Pool.h"
 
#include "Renderer/RenderList.h"
 
 
namespace Cogs::Core
{
  class Context;
 
  enum class EnginePermutationFlags
  {
    None = 0,
    DepthOnly = 1 << 0,
    NoShading = 1 << 1,
    ReverseDepth = 1 << 2,
    HasBuiltins = 1 << 3,
  };
  ENABLE_ENUM_FLAGS(EnginePermutationFlags);
 
  struct EnginePermutationDefinition
  {
    EnginePermutationDefinition* next = nullptr;
 
    std::string name;
    std::string inherits;
 
    std::string vertexShader;
    std::string geometryShader;
    std::string pixelShader;
 
    ShaderVariants variants;
 
    RenderFlags requiredFlags = RenderFlags::None;
 
    EnginePermutationFlags flags = EnginePermutationFlags::None;
 
    MaterialProperties properties;
    PreprocessorDefinitions definitions;
  };
 
  struct COGSCORE_DLL_API EnginePermutation
  {
    void initialize(Context * context, EnginePermutationDefinition * definition);
 
    const EnginePermutationDefinition * getDefinition() const { return definition; }
    EnginePermutationDefinition * getDefinition() { return definition; }
 
    std::span<const ShaderVariantDefinition> getVariants() const { return definition->variants; }
    std::span<const ShaderVariantSelector> getSelectors() const { return selectors; }
 
    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);
 
    bool hasVariant(const StringView & key);
 
    void setProperty(const StringView & name, const void * value, int valueSize);
 
    bool isDirty() const { return dirty; }
    bool isDepthOnly() const { return (flags & EnginePermutationFlags::DepthOnly) != 0; }
    bool isShadowPass() const { return isDepthOnly(); }
    bool isShadingPass() const { return (flags & EnginePermutationFlags::NoShading) == 0; }
    bool hasBuiltins() const { return (flags & EnginePermutationFlags::HasBuiltins) != 0; }
    bool isReverseDepth() const { return (flags & EnginePermutationFlags::ReverseDepth) != 0; }
 
    size_t getCode() const;
    size_t getNameHash() const { return nameHash; }
    size_t getIndex() const { return index; }
 
    const std::string & getName() const { return definition->name; }
 
    void updateFlags();
 
  public:
    RenderItemFlags requiredFlags = RenderItemFlags::None;
    size_t permutationMask = 0;
 
    ConstantBuffers constantBuffers;
    std::vector<Cogs::BufferHandle> bufferHandles;
 
  private:
    mutable size_t code = 0;        // is updated by getCode if dirty is true.
    mutable bool dirty = false;     // triggers update of code.
    size_t nameHash = 0;
    size_t index = 0;
    EnginePermutationFlags flags = EnginePermutationFlags::None;
    EnginePermutationDefinition * definition = nullptr;
    ShaderVariantSelectors selectors;
 
    friend struct EnginePermutations;
  };
 
  struct COGSCORE_DLL_API EnginePermutations
  {
    EnginePermutations(Context * context);
 
    ~EnginePermutations();
 
    void initialize(Context * context);
 
    EnginePermutation * create(const StringView & name, EnginePermutation * base = nullptr);
 
    const EnginePermutation * get(size_t index) const;
    const EnginePermutation * get(const StringView & name) const;
 
    EnginePermutation * get(size_t index);
    EnginePermutation * get(const StringView & name);
 
    EnginePermutation * getInternal(size_t index);
    EnginePermutation * getInternal(const StringView & name);
 
    bool exists(const StringView & name) const;
 
    size_t size() const { return enginePermutations.size(); }
    size_t getIndex(const StringView & name) const;
 
    bool load(const StringView & resource, bool isContent = false);
    EnginePermutationFlags getFlag(const StringView & name);
 
  protected:
    std::vector<EnginePermutation> enginePermutations;
    Collections::Pool<EnginePermutationDefinition> permutationDefinitions;
 
    [[nodiscard]] bool inherit(EnginePermutation* enginePermutation, const EnginePermutation* base);
 
    EnginePermutation* create(EnginePermutationDefinition* definition, EnginePermutation* base = nullptr);
 
    EnginePermutationDefinition* createDefinition();
 
    // List of engine permutation definitions to free when engine shuts down.
    EnginePermutationDefinition* firstDefinition = nullptr;
 
    Context * mContext;
  };
}