pipeline.h

Go to the documentation of this file.

// Luanti
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2022 x2048, Dmitry Kostenko <codeforsmile@gmail.com>
#pragma once
 
#include "irrlichttypes_extrabloated.h"
#include <IrrlichtDevice.h> // used in all render/*.cpp
#include <IVideoDriver.h> // used in all render/*.cpp
 
#include <vector>
#include <memory>
#include <string>
 
class RenderSource;
class RenderTarget;
class RenderStep;
class Client;
class Hud;
class ShadowRenderer;
 
namespace irr::video
{
        class IRenderTarget;
}
 
struct PipelineContext
{
        PipelineContext(IrrlichtDevice *_device, Client *_client, Hud *_hud, ShadowRenderer *_shadow_renderer, video::SColor _color, v2u32 _target_size)
                : device(_device), client(_client), hud(_hud), shadow_renderer(_shadow_renderer), clear_color(_color), target_size(_target_size)
        {
        }
 
        IrrlichtDevice *device;
        Client *client;
        Hud *hud;
        ShadowRenderer *shadow_renderer;
        video::SColor clear_color;
        v2u32 target_size;
 
        bool show_hud {true};
        bool draw_wield_tool {true};
        bool draw_crosshair {true};
};
 
class RenderPipelineObject
{
public:
        virtual ~RenderPipelineObject() = default;
        virtual void reset(PipelineContext &context) {}
};
 
class RenderSource : virtual public RenderPipelineObject
{
public:
        virtual u8 getTextureCount() = 0;
 
        virtual video::ITexture *getTexture(u8 index) = 0;
};
 
class RenderTarget : virtual public RenderPipelineObject
{
public:
        virtual void activate(PipelineContext &context)
        {
                m_clear = false;
        }
 
        virtual void reset(PipelineContext &context) override
        {
                m_clear = true;
        }
 
protected:
        bool m_clear {true};
};
 
class TextureBuffer : public RenderSource
{
public:
        virtual ~TextureBuffer() override;
 
        void setTexture(u8 index, core::dimension2du size, const std::string& name, video::ECOLOR_FORMAT format, bool clear = false);
 
        void setTexture(u8 index, v2f scale_factor, const std::string& name, video::ECOLOR_FORMAT format, bool clear = false);
 
        virtual u8 getTextureCount() override { return m_textures.size(); }
        virtual video::ITexture *getTexture(u8 index) override;
        virtual void reset(PipelineContext &context) override;
        void swapTextures(u8 texture_a, u8 texture_b);
private:
        static const u8 NO_DEPTH_TEXTURE = 255;
 
        struct TextureDefinition
        {
                bool valid { false };
                bool fixed_size { false };
                bool dirty { false };
                bool clear { false };
                v2f scale_factor;
                core::dimension2du size;
                std::string name;
                video::ECOLOR_FORMAT format;
        };
 
        bool ensureTexture(video::ITexture **textureSlot, const TextureDefinition& definition, PipelineContext &context);
 
        video::IVideoDriver *m_driver { nullptr };
        std::vector<TextureDefinition> m_definitions;
        core::array<video::ITexture *> m_textures;
};
 
class TextureBufferOutput : public RenderTarget
{
public:
        TextureBufferOutput(TextureBuffer *buffer, u8 texture_index);
        TextureBufferOutput(TextureBuffer *buffer, const std::vector<u8> &texture_map);
        TextureBufferOutput(TextureBuffer *buffer, const std::vector<u8> &texture_map, u8 depth_stencil);
        virtual ~TextureBufferOutput() override;
        void activate(PipelineContext &context) override;
private:
        static const u8 NO_DEPTH_TEXTURE = 255;
 
        TextureBuffer *buffer;
        std::vector<u8> texture_map;
        u8 depth_stencil { NO_DEPTH_TEXTURE };
        video::IRenderTarget* render_target { nullptr };
        video::IVideoDriver* driver { nullptr };
};
 
class RemappingSource : RenderSource
{
public:
        RemappingSource(RenderSource *source)
                        : m_source(source)
        {}
 
        void setMapping(u8 index, u8 target_index)
        {
                if (index >= m_mappings.size()) {
                        u8 start = m_mappings.size();
                        m_mappings.resize(index);
                        for (u8 i = start; i < m_mappings.size(); ++i)
                                m_mappings[i] = i;
                }
 
                m_mappings[index] = target_index;
        }
 
        virtual u8 getTextureCount() override
        {
                return m_mappings.size();
        }
 
        virtual video::ITexture *getTexture(u8 index) override
        {
                if (index < m_mappings.size())
                        index = m_mappings[index];
 
                return m_source->getTexture(index);
        }
public:
        RenderSource *m_source;
        std::vector<u8> m_mappings;
};
 
class DynamicSource : public RenderSource
{
public:
        bool isConfigured() { return upstream != nullptr; }
        void setRenderSource(RenderSource *value) { upstream = value; }
 
        virtual u8 getTextureCount() override;
 
        virtual video::ITexture *getTexture(u8 index) override;
private:
        RenderSource *upstream { nullptr };
};
 
class ScreenTarget : public RenderTarget
{
public:
        virtual void activate(PipelineContext &context) override;
        virtual void reset(PipelineContext &context) override;
private:
        core::dimension2du size;
};
 
class DynamicTarget : public RenderTarget
{
public:
        bool isConfigured() { return upstream != nullptr; }
        void setRenderTarget(RenderTarget *value) { upstream = value; }
        virtual void activate(PipelineContext &context) override;
private:
        RenderTarget *upstream { nullptr };
};
 
class RenderStep : virtual public RenderPipelineObject
{
public:
        virtual void setRenderSource(RenderSource *source) = 0;
 
        virtual void setRenderTarget(RenderTarget *target) = 0;
 
        virtual void run(PipelineContext &context) = 0;
};
 
class TrivialRenderStep : public RenderStep
{
public:
        virtual void setRenderSource(RenderSource *source) override {}
        virtual void setRenderTarget(RenderTarget *target) override {}
        virtual void reset(PipelineContext &) override {}
};
 
class SetRenderTargetStep : public TrivialRenderStep
{
public:
        SetRenderTargetStep(RenderStep *step, RenderTarget *target);
        virtual void run(PipelineContext &context) override;
private:
        RenderStep *step;
        RenderTarget *target;
};
 
class SwapTexturesStep : public TrivialRenderStep
{
public:
        SwapTexturesStep(TextureBuffer *buffer, u8 texture_a, u8 texture_b);
        virtual void run(PipelineContext &context) override;
private:
        TextureBuffer *buffer;
        u8 texture_a;
        u8 texture_b;
};
 
class RenderPipeline : public RenderStep
{
public:
        RenderStep *addStep(RenderStep *step)
        {
                m_pipeline.push_back(step);
                return step;
        }
 
        template<typename T>
        T *own(std::unique_ptr<T> &&object)
        {
                T* result = object.release();
                m_objects.push_back(std::unique_ptr<RenderPipelineObject>(result));
                return result;
        }
 
        template<typename T, typename... Args>
        T *createOwned(Args&&... args) {
                return own(std::make_unique<T>(std::forward<Args>(args)...));
        }
 
        template<typename T, typename... Args>
        T *addStep(Args&&... args) {
                T* result = own(std::make_unique<T>(std::forward<Args>(args)...));
                addStep(result);
                return result;
        }
 
        RenderSource *getInput();
        RenderTarget *getOutput();
 
        v2f getScale() { return scale; }
        void setScale(v2f value) { scale = value; }
 
        virtual void reset(PipelineContext &context) override {}
        virtual void run(PipelineContext &context) override;
 
        virtual void setRenderSource(RenderSource *source) override;
        virtual void setRenderTarget(RenderTarget *target) override;
private:
        std::vector<RenderStep *> m_pipeline;
        std::vector< std::unique_ptr<RenderPipelineObject> > m_objects;
        DynamicSource m_input;
        DynamicTarget m_output;
        v2f scale { 1.0f, 1.0f };
};