IRenderer.h

#pragma once
 
#include <glm/vec2.hpp>
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
 
#include "Rendering/Common.h"
#include "Rendering/IGraphicsDevice.h"
 
#include "Resources/Resources.h"
#include "Resources/ResourceBase.h"
#include "Rendering/IEffects.h"
 
#include "Services/Variables.h"
#include <span>
 
namespace Cogs
{
  class IGraphicsDevice;
 
  namespace Core
  {
    class Context;
    class LightComponent;
 
    struct ScreenshotSettings
    {
      int width;
      int height;
      int numSamples;
      int flags;
    };
 
    enum class RenderMode
    {
      Normal = 0,
      Wireframe = 1,
      Box = 3,
    };
 
    struct ActiveLights {
      std::vector<const LightComponent*> lights;
      uint32_t numDirectionalShadowLights = 0;
      uint32_t numDirectionalLights = 0;
      uint32_t numPointShadowLights = 0;
      uint32_t numPointLights = 0;
    };
 
    class IRenderResources
    {
    public:
      virtual ~IRenderResources() = default;
 
      virtual ActivationResult updateResource(const TextureHandle & texture) = 0;
      virtual ActivationResult updateResource(const MeshHandle & mesh) = 0;
      virtual ActivationResult updateResource(const EffectHandle & effect) = 0;
      virtual ActivationResult updateResource(const MaterialHandle & material) = 0;
      virtual ActivationResult updateResource(const MaterialInstanceHandle & materialInstance) = 0;
 
      virtual void releaseResource(Texture * texture) = 0;
      virtual void releaseResource(Mesh * mesh) = 0;
      virtual void releaseResource(Effect * effect) = 0;
      virtual void releaseResource(Material * material) = 0;
      virtual void releaseResource(MaterialInstance * materialInstance) = 0;
 
      virtual std::string getReport() const = 0;
 
    };
 
    struct RenderingEvent
    {
      enum ERenderingEvent : uint32_t
      {
        None = 0,
        PreRender,
        RenderSolid,
        RenderTransparent,
        RenderGui,
        PostRender,
      };
    };
 
    struct DrawContext;
    struct RenderTaskContext;
    struct RenderList;
    struct EnginePermutation;
    struct EnginePermutations;
    struct RenderSettings;
    struct RenderStates;
    struct EffectCache;
    struct EffectBindings;
    struct EngineBuffers;
 
    class IRendererExtension
    {
    public:
      virtual ~IRendererExtension() = default;
 
      virtual void initialize(class Context * context, IGraphicsDevice * device) = 0;
 
      virtual void handleEvent(uint32_t eventId, const DrawContext * renderingContext) = 0;
 
      virtual void generateCommands(const RenderTaskContext * renderingContext, RenderList * renderList) = 0;
    };
 
    class IRenderer
    {
    public:
      virtual ~IRenderer() = default;
 
      virtual void initialize(IGraphicsDevice * device) = 0;
 
      virtual void cleanup() = 0;
 
      virtual glm::vec2 getSize() const = 0;
 
      virtual IGraphicsDevice* getDevice() = 0;
 
      virtual void setMode(RenderMode mode) = 0;
 
      virtual RenderMode getMode() const = 0;
 
      virtual void setBackgroundColor(const glm::vec4 & color) = 0;
 
      virtual glm::vec4 getBackgroundColor() const = 0;
 
      virtual void beginFrame() = 0;
 
      virtual void endFrame(uint32_t syncInterval = 0, uint32_t presentFlags = Cogs::PresentFlags::None) = 0;
 
      virtual void render() = 0;
 
      virtual glm::mat4 getProjectionMatrix(const glm::mat4 projectionMatrix) = 0;
 
      virtual glm::mat4 getViewFromViewportMatrix(const glm::mat4 inverseProjectionMatrix) = 0;
 
 
      virtual float getClearDepth() = 0;
 
      virtual float getNearDepth() = 0;
 
      virtual IRenderResources * getResources() = 0;
 
      virtual const RenderSettings & getSettings() const = 0;
 
      virtual void registerExtension(IRendererExtension * extension) = 0;
 
      virtual void unregisterExtension(IRendererExtension* extension) = 0;
 
      virtual std::span<IRendererExtension*> getExtensions() = 0;
 
      virtual void renderScreenshot(const ScreenshotSettings & settings, std::vector<uint8_t> & bytes, uint32_t * stride) = 0;
 
      virtual unsigned getMaxLights() const = 0;
 
      virtual EngineBuffers & getEngineBuffers() = 0;
 
      virtual RenderStates & getRenderStates() = 0;
 
      virtual EffectCache & getEffectCache() = 0;
 
      virtual EffectFlags::EEffectFlags getEffectFlags() const = 0;
 
      virtual EffectBindings & getEffectBindings() = 0;
 
      virtual ActiveLights & getActiveLights() = 0;
 
      virtual void updatePermutation(EnginePermutation* permutation) = 0;
 
      virtual EnginePermutations & getEnginePermutations() = 0;
 
      virtual COGSCORE_DLL_API class ImguiRenderer* getGuiRenderer() = 0;
      virtual COGSCORE_DLL_API class InspectorGuiRenderer* getInspectorGuiRenderer() = 0;
      virtual COGSCORE_DLL_API class InspectorGuiRenderer* getEngineInspectorGuiRenderer() = 0;
    };
  }
}