Renderer.h

#pragma once
 
#include "IRenderer.h"
 
#include "RenderResources.h"
#include "RenderSettings.h"
#include "RenderStates.h"
#include "EffectCache.h"
#include "EnginePermutations.h"
#include "EffectBindings.h"
#include "EngineBuffers.h"
#include "EngineBindGroups.h"
#include "Rendering/IEffects.h"
#include "../Context.h"
#include "../ViewContext.h"
#include "Tasks/RenderTask.h"
 
namespace Cogs
{
  struct WindowData;
 
  namespace Core
  {
    class Renderer : public IRenderer
    {
    public:
      Renderer(Context * context);
      ~Renderer();
 
      // IRenderer implementation
 
      void initialize(IGraphicsDevice * device) override;
      void cleanup() override;
 
      void setMode(RenderMode mode) override { this->mode = mode; }
      RenderMode getMode() const override { return mode; }
 
      void setBackgroundColor(const glm::vec4 & backgroundColor) override;
      glm::vec4 getBackgroundColor() const override { return backgroundColor; }
 
      glm::vec2 getSize() const override { return context->getDefaultView()->getSize(); }
      IGraphicsDevice * getDevice() override { return device; }
      const RenderSettings & getSettings() const override { return settings; }
 
      void beginFrame() override;
      void endFrame(uint32_t syncInterval = 0, Cogs::PresentFlags presentFlags = PresentFlags::None) override;
 
      void render() override;
 
      glm::mat4 getProjectionMatrix(const glm::mat4 projectionMatrix) override;
      glm::mat4 getViewFromViewportMatrix(glm::mat4 inverseProjectionMatrix) override;
      float getClearDepth() override;
      float getNearDepth() override;
 
      IRenderResources * getResources() override;
 
      void registerExtension(IRendererExtension * extension) override;
      void unregisterExtension(IRendererExtension* extension) override;
      std::span<IRendererExtension*> getExtensions() override { return extensions; }
 
      void renderScreenshot(const ScreenshotSettings & settings, std::vector<uint8_t> & bytes, uint32_t * stride = nullptr) override;
 
      EngineBuffers & getEngineBuffers() override { return engineBuffers; }
      EngineBindGroups & getEngineBindGroups() { return engineBindGroups; }
      RenderStates & getRenderStates() override { return renderStates; }
      EffectFlags::EEffectFlags getEffectFlags() const override { return effectFlags; }
      EffectCache & getEffectCache() override { return effectCache; }
      EffectBindings & getEffectBindings() override { return effectBindings; }
      ActiveLights & getActiveLights() override { return activeLights; }
      unsigned getMaxLights() const override { return maxLights; }
 
      void updatePermutation(EnginePermutation * permutation) override;
      EnginePermutations & getEnginePermutations() override { return enginePermutations; }
 
      COGSCORE_DLL_API class ImguiRenderer*         getGuiRenderer() override;
      COGSCORE_DLL_API class InspectorGuiRenderer*  getEngineInspectorGuiRenderer() override;
 
      // Renderer specific
 
      class RenderResources & getRenderResources() { return resources; }
      class RenderPipelineManager* getPipelineManager() { return pipelineManager.get(); }
      RenderTaskContext & getRenderContext() { return renderContext; }
 
      friend Cogs::Core::RenderTaskContext getRenderTaskContext(Renderer* renderer);
 
    protected:
      void updateSettings();
      void updateEffectFlags();
      void emitEvent(uint32_t eventId, const DrawContext* renderingContext);
 
    private:
      Context* context = nullptr;
      IGraphicsDevice* device = nullptr;
      RenderSettings settings;
      RenderMode mode = RenderMode::Normal;
      EngineBuffers engineBuffers = {};
      EngineBindGroups engineBindGroups = {};
      RenderStates renderStates;
      struct RenderTarget* defaultTarget = nullptr;
      EffectCache effectCache;
      EffectFlags::EEffectFlags effectFlags = EffectFlags::None;
 
      RenderResources resources;
      EnginePermutations enginePermutations;
      EffectBindings effectBindings;
      std::unique_ptr<struct Renderers> renderers;
      std::unique_ptr<class RenderPipelineManager> pipelineManager;
 
      ActiveLights activeLights;
      // Might be less than kMaxLights, updated in initalize
      unsigned maxLights = static_cast<unsigned>(kMaxLights);
      glm::vec4 backgroundColor;
      std::vector<IRendererExtension*> extensions;
 
      RenderTaskContext renderContext;
    };
  }
}