pipeline.h

Go to the documentation of this file.

/*
Minetest
Copyright (C) 2022 x2048, Dmitry Kostenko <codeforsmile@gmail.com>
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#pragma once
 
#include "irrlichttypes_extrabloated.h"
 
#include <vector>
#include <memory>
#include <string>
 
class RenderSource;
class RenderTarget;
class RenderStep;
class Client;
class Hud;
class ShadowRenderer;
 
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 };
};