GLRenderEngine.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <vector>
 
#include <RenderEngine.h>
 
#include "GraphicsObject/Buffer.h"
#include "GraphicsObject/Texture.h"
#include "GraphicsObject/Framebuffer.h"
#include "GraphicsObject/Shader.h"
#include "GraphicsObject/Mesh.h"
 
 
namespace dyno
{
    class SSAO;
    class FXAA;
    class Envmap;
    class ShadowMap;
    class GLRenderHelper;
    class GLVisualModule;
    class SceneGraph;
 
    class GLRenderEngine : public RenderEngine
    {
    public:
        GLRenderEngine();
        ~GLRenderEngine();
               
        virtual void initialize() override;
        virtual void terminate() override;
 
        virtual void draw(dyno::SceneGraph* scene, const RenderParams& rparams) override;
 
        virtual std::string name() const override;
 
        // get the selected nodes on given rect area
        Selection select(int x, int y, int w, int h) override;
 
        // use MSAA samples
        void setMSAA(int samples);
        int  getMSAA() const;
 
        void setFXAA(bool flag);
        int getFXAA() const;
 
        void setShadowMapSize(int size);
        int  getShadowMapSize() const;
 
        void setShadowBlurIters(int iters);
        int  getShadowBlurIters() const;
 
        void setDefaultEnvmap() override;
        void setEnvmap(const std::string& path);
 
        void setEnvStyle(EEnvStyle style) override;
 
        inline std::string getEnvmapFilePath() { return mEnvmapFilePath; }
 
    private:
        void createFramebuffer();
        void resizeFramebuffer(int w, int h, int samples);
        void setupTransparencyPass();
        void updateRenderItems(dyno::SceneGraph* scene);
 
    private:
 
        // objects to render
        struct RenderItem {
            std::shared_ptr<Node>           node;
            std::shared_ptr<GLVisualModule> visualModule;
 
            bool operator==(const RenderItem& item) {
                return node == item.node && visualModule == item.visualModule;
            }
        };
 
        std::vector<RenderItem> mRenderItems;
 
    private:
        // internal framebuffer
        Framebuffer              mFramebuffer;
        Texture2DMultiSample    mColorTex;
        Texture2DMultiSample    mDepthTex;
        Texture2DMultiSample    mIndexTex;         // indices for object/mesh/primitive etc.
 
        // non-multisample framebuffer for select
        Framebuffer              mSelectFramebuffer;
        Texture2D              mSelectIndexTex;
 
        // for linked-list OIT
        const int               MAX_OIT_NODES = 1024 * 1024 * 8;
        Buffer                    mFreeNodeIdx;
        Buffer                    mLinkedListBuffer;
        Texture2DMultiSample    mHeadIndexTex;
        Program*             mBlendProgram;
 
        GLRenderHelper*           mRenderHelper;
        ShadowMap*             mShadowMap;
 
        // anti-aliasing
        
        // MSAA samples
        int                     mMSAASamples = 4;
 
        // FXAA
        bool                    bEnableFXAA = false;
        FXAA*                   mFXAAFilter;
 
        // Envmap
        std::string             mEnvmapFilePath = getAssetPath() + "textures/hdr/venice_dawn_1_4k.hdr";
        Envmap*                   mEnvmap = 0;
        
        Mesh* mScreenQuad = 0;
    };
};