MRViewportGL.h

Go to the documentation of this file.

#pragma once
#include "MRViewerFwd.h"
#include "MRMesh/MRVector4.h"
#include "MRMesh/MRVector2.h"
#include "MRMesh/MRBox.h"
#include "MRMesh/MRPlane3.h"
#include "MRMesh/MRColor.h"
#include "MRMesh/MRViewportId.h"
#include "MRMesh/MRIRenderObject.h"
 
#include <span>
 
namespace MR
{
 
struct SegmEndColors
{
    Vector4f a, b;
};
 
inline bool operator==( const SegmEndColors& a, const SegmEndColors& b )
{
    return a.a == b.a && a.b == b.b;
}
 
struct ViewportPointsWithColors
{
    std::vector<Vector3f> points;
    std::vector<Vector4f> colors;
};
 
inline bool operator==( const ViewportPointsWithColors& a, const ViewportPointsWithColors& b )
{
    return a.points == b.points && a.colors == b.colors;
}
 
class ViewportGL
{
public:
    typedef unsigned int GLuint;
    typedef float GLfloat;
 
    ViewportGL() = default;
    ViewportGL( const ViewportGL& ) {}
    ViewportGL& operator = ( const ViewportGL& ) { return *this; }
 
    MRVIEWER_API ViewportGL( ViewportGL&& other ) noexcept;
    ViewportGL& operator = ( ViewportGL&& ) noexcept;
    ~ViewportGL();
 
    void init();
    void free();
 
    void drawBorder( const Box2f& rect, const Color& color ) const;
 
    void fillViewport( const Box2f& rect, const Color& color ) const;
 
    bool checkInit() const;
 
    struct PickParameters
    {
        std::span<VisualObject* const> renderVector;       
        BaseRenderParams baseRenderParams;                    
        Plane3f clippingPlane;                                
    };
    struct BasePickResult
    {
        unsigned geomId{ unsigned( -1 ) };  
        unsigned primId{ unsigned( -1 ) };  
    };
    struct PickResult : BasePickResult
    {
        float zBuffer{1.0f};  
    };
    using PickResults = std::vector<PickResult>;
    PickResults pickObjects( const PickParameters& params, const std::vector<Vector2i>& picks ) const;
    std::vector<unsigned> findUniqueObjectsInRect( const PickParameters& params, const Box2i& rect,
                                                   int maxRenderResolutionSide ) const;
 
    using BasePickResults = std::vector<BasePickResult>;
    struct ScaledPickRes
    {
        BasePickResults pickRes;
        Box2i updatedBox;
    };
    ScaledPickRes pickObjectsInRect( const PickParameters& params, const Box2i& rect,
        int maxRenderResolutionSide ) const;
 
private:
    struct PickColor
    {
        unsigned color[4];
    };
 
    struct PickTextureFrameBuffer
    {
        void resize( const Vector2i& size );
        void del();
        void bind( bool read );
    private:
        unsigned int framebuffer_{ 0 };
        unsigned int colorTexture_{ 0 };
        unsigned int renderbuffer_{ 0 };
        Vector2i size_;
    };
    mutable PickTextureFrameBuffer pickFBO_;
 
    std::vector<PickColor> pickObjectsInRect_( const PickParameters& params, const Box2i& rect ) const;
 
    bool inited_ = false;
 
    GLuint add_line_colors_vbo = 0;
    GLuint add_line_vbo = 0;
    GLuint add_line_vao = 0;
 
    GLuint add_point_colors_vbo = 0;
    GLuint add_point_vbo = 0;
    GLuint add_point_vao = 0;
 
    GLuint border_line_vbo = 0;
    GLuint border_line_vao = 0;
};
 
}