MRRenderGLHelpers.h

Go to the documentation of this file.

#pragma once
#include "MRMesh/MRIRenderObject.h"
#include "MRGladGlfw.h"
#include "exports.h"
#include "MRMesh/MRColor.h"
#include "MRMesh/MRVector2.h"
#include "MRGLTexture.h"
#include "MRGLMacro.h"
#include <cassert>
 
namespace MR
{
 
 
class GlBuffer
{
    constexpr static GLuint NO_BUF = 0;
public:
    GlBuffer() = default;
    GlBuffer( const GlBuffer & ) = delete;
    GlBuffer( GlBuffer && r ) : bufferID_( r.bufferID_ ), size_( r.size_ ) { r.detach_(); }
    ~GlBuffer() { del(); }
 
    GlBuffer& operator =( const GlBuffer & ) = delete;
    GlBuffer& operator =( GlBuffer && r ) { del(); bufferID_ = r.bufferID_; size_ = r.size_; r.detach_(); return * this; }
 
    auto getId() const { return bufferID_; }
    bool valid() const { return bufferID_ != NO_BUF; }
    size_t size() const { return size_; }
 
    MRVIEWER_API void gen();
 
    MRVIEWER_API void del();
 
    MRVIEWER_API void bind( GLenum target );
 
    MRVIEWER_API void loadData( GLenum target, const char * arr, size_t arrSize );
    template<typename T>
    void loadData( GLenum target, const T * arr, size_t arrSize ) { loadData( target, (const char *)arr, sizeof( T ) * arrSize ); }
    template<typename C>
    void loadData( GLenum target, const C & cont ) { loadData( target, cont.data(), cont.size() ); }
 
    MRVIEWER_API void loadDataOpt( GLenum target, bool refresh, const char * arr, size_t arrSize );
    template<typename T>
    void loadDataOpt( GLenum target, bool refresh, const T * arr, size_t arrSize ) { loadDataOpt( target, refresh, (const char *)arr, sizeof( T ) * arrSize ); }
    template<typename C>
    void loadDataOpt( GLenum target, bool refresh, const C & cont ) { loadDataOpt( target, refresh, cont.data(), cont.size() ); }
 
private:
    void detach_() { bufferID_ = NO_BUF; size_ = 0; }
 
private:
    GLuint bufferID_ = NO_BUF;
    size_t size_ = 0;
};
 
class GlTexture2 : public GlTexture
{
public:
    GlTexture2() : GlTexture( GL_TEXTURE_2D ){}
 
    static Vector3i ToResolution( const Vector2i& value )
    {
        return Vector3i( value.x, value.y, 1 );
    }
private:
    MRVIEWER_API virtual void texImage_( const Settings& settings, const char* arr ) override;
};
 
class GlTexture3 : public GlTexture
{
public:
    GlTexture3() : GlTexture( GL_TEXTURE_3D ){}
private:
    MRVIEWER_API virtual void texImage_( const Settings& settings, const char* arr ) override;
};
 
class GlTexture2DArray : public GlTexture
{
public:
    GlTexture2DArray() : GlTexture( GL_TEXTURE_2D_ARRAY ){}
private:
    MRVIEWER_API virtual void texImage_( const Settings& settings, const char* arr ) override;
};
 
struct BindVertexAttribArraySettings
{
    GLuint program_shader = 0;
    const char * name = nullptr;
    GlBuffer & buf;
    const char * arr = nullptr;
    size_t arrSize = 0;
    int baseTypeElementsNumber = 0;
    bool refresh = false;
    bool forceUse = false;
    bool isColor = false;
};
 
MRVIEWER_API GLint bindVertexAttribArray( const BindVertexAttribArraySettings & settings );
 
template<typename T, template<typename, typename...> class C, typename... args>
inline GLint bindVertexAttribArray(
    const GLuint program_shader,
    const char * name,
    GlBuffer & buf,
    const C<T, args...>& V,
    int baseTypeElementsNumber,
    bool refresh,
    bool forceUse = false )
{
    BindVertexAttribArraySettings settings =
    {
        .program_shader = program_shader,
        .name = name,
        .buf = buf,
        .arr = (const char*)V.data(),
        .arrSize = sizeof(T) * V.size(),
        .baseTypeElementsNumber = baseTypeElementsNumber,
        .refresh = refresh,
        .forceUse = forceUse,
        .isColor = std::is_same_v<Color, T>
    };
    return bindVertexAttribArray( settings );
}
 
template <typename T, std::size_t N>
inline GLint bindVertexAttribArray(
    const GLuint program_shader,
    const char * name,
    GlBuffer & buf,
    const std::array<T, N>& V,
    int baseTypeElementsNumber,
    bool refresh,
    bool forceUse = false )
{
    BindVertexAttribArraySettings settings =
    {
        .program_shader = program_shader,
        .name = name,
        .buf = buf,
        .arr = (const char*)V.data(),
        .arrSize = sizeof(T) * N,
        .baseTypeElementsNumber = baseTypeElementsNumber,
        .refresh = refresh,
        .forceUse = forceUse,
        .isColor = std::is_same_v<Color, T>
    };
    return bindVertexAttribArray( settings );
}
 
inline int getDepthFunctionLess( DepthFunction funcType )
{
    switch ( funcType )
    {
    case DepthFunction::Default:
    case DepthFunction::Less:
        return GL_LESS;
    case DepthFunction::Never:
        return GL_NEVER;
    case DepthFunction::LessOrEqual:
        return GL_LEQUAL;
    case DepthFunction::Equal:
        return GL_EQUAL;
    case DepthFunction::GreaterOrEqual:
        return GL_GEQUAL;
    case DepthFunction::Greater:
        return GL_GREATER;
    case DepthFunction::Always:
        return GL_ALWAYS;
    case DepthFunction::NotEqual:
        return GL_NOTEQUAL;
    default:
        return 0;
    }
}
 
inline int getDepthFunctionLEqual( DepthFunction funcType )
{
    if ( funcType == DepthFunction::Default )
        return GL_LEQUAL;
    return getDepthFunctionLess( funcType );
}
 
class MRVIEWER_CLASS QuadTextureVertexObject
{
public:
    MRVIEWER_API void gen();
    MRVIEWER_API void bind();
    MRVIEWER_API void del();
private:
    unsigned vao_{ 0 };
    unsigned vbo_{ 0 };
};
 
class MRVIEWER_CLASS FramebufferData
{
public:
    MRVIEWER_API void gen( const Vector2i& size, bool copyDepth, int msaaPow, bool highPrecisionDepth = false );
    MRVIEWER_API void bind( bool clear = true, float clearDepth = 1.0f );
    MRVIEWER_API void bindDefault();
    MRVIEWER_API void bindTexture( bool color = true, bool depth = true );
    MRVIEWER_API void copyTextureBindDef();
    MRVIEWER_API void del();
    unsigned getColorTexture() const { return resColorTexture_.getId(); }
    unsigned getDepthTexture() const { return resDepthTexture_.getId(); }
 
    const Vector2i& getSize() const { return size_; }
    bool isBound() const { return isBound_; }
 
    struct DrawParams
    {
        Vector2i size; 
        WrapType wrap{ WrapType::Clamp }; 
        FilterType filter{ FilterType::Linear }; 
        bool forceSimpleDepthDraw = false; 
        float simpleDepth = 0.5f; 
    };
    MRVIEWER_API void draw( QuadTextureVertexObject& quadObject, const DrawParams& params ) const;
private:
    void resize_( const Vector2i& size, int msaaPow );
 
    bool isBound_{ false };
    bool highPrecisionDepth_{ false };
    unsigned mainFramebuffer_{ 0 };
    unsigned colorRenderbuffer_{ 0 };
    unsigned depthRenderbuffer_{ 0 };
    unsigned copyFramebuffer_{ 0 };
    GlTexture2 resColorTexture_;
    GlTexture2 resDepthTexture_;
    Vector2i size_;
};
 
MRVIEWER_API void bindDepthPeelingTextures( GLuint shaderId, const TransparencyMode& tMode, GLenum startGLTextureIndex );
 
MRVIEWER_API void objectPreRenderSetup( const TransparencyMode& tMode, RenderModelPassMask desiredPass, bool deptTesting );
MRVIEWER_API void objectPostRenderSetup( const TransparencyMode& tMode, RenderModelPassMask desiredPass, bool deptTesting );
 
}