opengl_gal.h

Go to the documentation of this file.

/*
 * This program source code file is part of KICAD, a free EDA CAD application.
 *
 * Copyright (C) 2012 Torsten Hueter, torstenhtr <at> gmx.de
 * Copyright (C) 2020-2024 KiCad Developers, see AUTHORS.txt for contributors.
 * Copyright (C) 2013-2017 CERN
 * @author Maciej Suminski <[email protected]>
 *
 * Graphics Abstraction Layer (GAL) for OpenGL
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#ifndef OPENGLGAL_H_
#define OPENGLGAL_H_
 
// GAL imports
#include <gal/gal.h>
#include <gal/graphics_abstraction_layer.h>
#include <gal/gal_display_options.h>
#include <gal/opengl/shader.h>
#include <gal/opengl/vertex_manager.h>
#include <gal/opengl/vertex_item.h>
#include <gal/opengl/cached_container.h>
#include <gal/opengl/noncached_container.h>
#include <gal/opengl/opengl_compositor.h>
#include <gal/hidpi_gl_canvas.h>
 
#include <unordered_map>
#include <memory>
#include <wx/event.h>
 
#ifndef CALLBACK
#define CALLBACK
#endif
 
#define SEG_PER_CIRCLE_COUNT  64
 
struct bitmap_glyph;
 
namespace KIGFX
{
class SHADER;
class GL_BITMAP_CACHE;
 
 
class GAL_API OPENGL_GAL : public GAL, public HIDPI_GL_CANVAS
{
public:
    OPENGL_GAL( const KIGFX::VC_SETTINGS& aVcSettings, GAL_DISPLAY_OPTIONS& aDisplayOptions,
                wxWindow* aParent,
                wxEvtHandler* aMouseListener = nullptr, wxEvtHandler* aPaintListener = nullptr,
                const wxString& aName = wxT( "GLCanvas" ) );
 
    ~OPENGL_GAL();
 
    static wxString CheckFeatures( GAL_DISPLAY_OPTIONS& aOptions );
 
    bool IsOpenGlEngine() override { return true; }
 
    bool IsInitialized() const override
    {
        // is*Initialized flags, but it is enough for OpenGL to show up
        return IsShownOnScreen() && !GetClientRect().IsEmpty();
    }
 
    bool IsVisible() const override
    {
        return IsShownOnScreen() && !GetClientRect().IsEmpty();
    }
 
    // ---------------
    // Drawing methods
    // ---------------
 
    void DrawLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override;
 
    void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint,
                              double aWidth ) override;
 
    void DrawSegmentChain( const std::vector<VECTOR2D>& aPointList, double aWidth ) override;
    void DrawSegmentChain( const SHAPE_LINE_CHAIN& aLineChain, double aWidth ) override;
 
    void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ) override;
 
    void DrawArc( const VECTOR2D& aCenterPoint, double aRadius, const EDA_ANGLE& aStartAngle,
                  const EDA_ANGLE& aAngle ) override;
 
    void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius, const EDA_ANGLE& aStartAngle,
                         const EDA_ANGLE& aAngle, double aWidth, double aMaxError ) override;
 
    void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override;
 
    void DrawPolyline( const std::deque<VECTOR2D>& aPointList ) override;
    void DrawPolyline( const std::vector<VECTOR2D>& aPointList ) override;
    void DrawPolyline( const VECTOR2D aPointList[], int aListSize ) override;
    void DrawPolyline( const SHAPE_LINE_CHAIN& aLineChain ) override;
 
    void DrawPolylines( const std::vector<std::vector<VECTOR2D>>& aPointLists ) override;
 
    void DrawPolygon( const std::deque<VECTOR2D>& aPointList ) override;
    void DrawPolygon( const VECTOR2D aPointList[], int aListSize ) override;
    void DrawPolygon( const SHAPE_POLY_SET& aPolySet, bool aStrokeTriangulation = false ) override;
    void DrawPolygon( const SHAPE_LINE_CHAIN& aPolySet ) override;
 
    virtual void DrawGlyph( const KIFONT::GLYPH& aGlyph, int aNth, int aTotal ) override;
 
    virtual void DrawGlyphs( const std::vector<std::unique_ptr<KIFONT::GLYPH>>& aGlyphs ) override;
 
    void DrawCurve( const VECTOR2D& startPoint, const VECTOR2D& controlPointA,
                            const VECTOR2D& controlPointB, const VECTOR2D& endPoint,
                            double aFilterValue = 0.0 ) override;
 
    void DrawBitmap( const BITMAP_BASE& aBitmap, double alphaBlend = 1.0 ) override;
 
    void BitmapText( const wxString& aText, const VECTOR2I& aPosition,
                     const EDA_ANGLE& aAngle ) override;
 
    void DrawGrid() override;
 
    // --------------
    // Screen methods
    // --------------
 
    void ResizeScreen( int aWidth, int aHeight ) override;
 
    bool Show( bool aShow ) override;
 
    int GetSwapInterval() const override { return m_swapInterval; };
 
    void Flush() override;
 
    void ClearScreen( ) override;
 
    // --------------
    // Transformation
    // --------------
 
    void Transform( const MATRIX3x3D& aTransformation ) override;
 
    void Rotate( double aAngle ) override;
 
    void Translate( const VECTOR2D& aTranslation ) override;
 
    void Scale( const VECTOR2D& aScale ) override;
 
    void Save() override;
 
    void Restore() override;
 
    // --------------------------------------------
    // Group methods
    // ---------------------------------------------
 
    int BeginGroup() override;
 
    void EndGroup() override;
 
    void DrawGroup( int aGroupNumber ) override;
 
    void ChangeGroupColor( int aGroupNumber, const COLOR4D& aNewColor ) override;
 
    void ChangeGroupDepth( int aGroupNumber, int aDepth ) override;
 
    void DeleteGroup( int aGroupNumber ) override;
 
    void ClearCache() override;
 
    // --------------------------------------------------------
    // Handling the world <-> screen transformation
    // --------------------------------------------------------
 
    void SetTarget( RENDER_TARGET aTarget ) override;
 
    RENDER_TARGET GetTarget() const override;
 
    void ClearTarget( RENDER_TARGET aTarget ) override;
 
    virtual bool HasTarget( RENDER_TARGET aTarget ) override;
 
    void SetNegativeDrawMode( bool aSetting ) override {}
 
    void StartDiffLayer() override;
    //
    void EndDiffLayer() override;
 
    void ComputeWorldScreenMatrix() override;
 
    // -------
    // Cursor
    // -------
 
    bool SetNativeCursorStyle( KICURSOR aCursor, bool aHiDPI ) override;
 
    void DrawCursor( const VECTOR2D& aCursorPosition ) override;
 
    void PostPaint( wxPaintEvent& aEvent );
 
    void SetMouseListener( wxEvtHandler* aMouseListener )
    {
        m_mouseListener = aMouseListener;
    }
 
    void SetPaintListener( wxEvtHandler* aPaintListener )
    {
        m_paintListener = aPaintListener;
    }
 
    void EnableDepthTest( bool aEnabled = false ) override;
 
    bool IsContextLocked() override
    {
        return m_isContextLocked;
    }
 
    void LockContext( int aClientCookie ) override;
 
    void UnlockContext( int aClientCookie ) override;
 
    void BeginDrawing() override;
 
    void EndDrawing() override;
 
    struct TessParams
    {
        VERTEX_MANAGER* vboManager;
 
        std::deque<std::shared_ptr<GLdouble>>& intersectPoints;
    };
 
private:
    typedef GAL super;
 
    static wxGLContext*     m_glMainContext;    
    wxGLContext*            m_glPrivContext;    
    int                     m_swapInterval;     
    static int              m_instanceCounter;  
    wxEvtHandler*           m_mouseListener;
    wxEvtHandler*           m_paintListener;
 
    static GLuint           g_fontTexture;      
 
    // Vertex buffer objects related fields
    typedef std::unordered_map< unsigned int, std::shared_ptr<VERTEX_ITEM> > GROUPS_MAP;
 
    GROUPS_MAP              m_groups;           
    unsigned int            m_groupCounter;     
    VERTEX_MANAGER*         m_currentManager;   
    VERTEX_MANAGER*         m_cachedManager;    
    VERTEX_MANAGER*         m_nonCachedManager; 
    VERTEX_MANAGER*         m_overlayManager;   
    VERTEX_MANAGER*         m_tempManager;      
 
    // Framebuffer & compositing
    OPENGL_COMPOSITOR*      m_compositor;       
    unsigned int            m_mainBuffer;       
    unsigned int            m_overlayBuffer;    
    unsigned int            m_tempBuffer;       
    RENDER_TARGET           m_currentTarget;    
 
    // Shader
    SHADER*                 m_shader;           
 
    // Internal flags
    bool                    m_isFramebufferInitialized; 
    static bool             m_isBitmapFontLoaded;       
    bool                    m_isBitmapFontInitialized;  
    bool                    m_isInitialized;            
    bool                    m_isGrouping;               
    bool                    m_isContextLocked;          
    int                     m_lockClientCookie;
    GLint                   ufm_worldPixelSize;
    GLint                   ufm_screenPixelSize;
    GLint                   ufm_pixelSizeMultiplier;
    GLint                   ufm_antialiasingOffset;
 
    wxCursor                m_currentwxCursor;          
 
    std::unique_ptr<GL_BITMAP_CACHE>            m_bitmapCache;
 
    // Polygon tesselation
    GLUtesselator*                        m_tesselator;
    std::deque<std::shared_ptr<GLdouble>> m_tessIntersects;
 
    void beginUpdate() override;
 
    void endUpdate() override;
 
    bool updatedGalDisplayOptions( const GAL_DISPLAY_OPTIONS& aOptions ) override;
 
    void drawLineQuad( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint,
                       bool aReserve = true );
 
    void reserveLineQuads( const int aLineCount );
 
    void drawSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle );
 
    void drawFilledSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle );
 
    void drawStrokedSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle,
                                bool aReserve = true );
 
    void drawCircle( const VECTOR2D& aCenterPoint, double aRadius, bool aReserve = true );
 
    void drawPolyline( const std::function<VECTOR2D( int )>& aPointGetter, int aPointCount,
                       bool aReserve = true );
 
    void drawSegmentChain( const std::function<VECTOR2D( int )>& aPointGetter, int aPointCount,
                           double aWidth, bool aReserve = true );
 
    void drawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint, double aWidth,
                      bool aReserve = true );
 
    void drawPolygon( GLdouble* aPoints, int aPointCount );
 
    void drawTriangulatedPolyset( const SHAPE_POLY_SET& aPoly, bool aStrokeTriangulation );
 
    int drawBitmapChar( unsigned long aChar, bool aReserve = true );
 
    void drawBitmapOverbar( double aLength, double aHeight, bool aReserve = true );
 
    std::pair<VECTOR2D, float> computeBitmapTextSize( const UTF8& aText ) const;
 
    // Event handling
    void onPaint( wxPaintEvent& aEvent );
 
    void skipMouseEvent( wxMouseEvent& aEvent );
 
    void skipGestureEvent( wxGestureEvent& aEvent );
 
    void onSetNativeCursor( wxSetCursorEvent& aEvent );
 
    void blitCursor();
 
    unsigned int getNewGroupNumber();
 
    double calcAngleStep( double aRadius ) const
    {
        // Bigger arcs need smaller alpha increment to make them look smooth
        return std::min( 1e6 / aRadius, 2.0 * M_PI / SEG_PER_CIRCLE_COUNT );
    }
 
    double getWorldPixelSize() const;
 
    VECTOR2D getScreenPixelSize() const;
 
    void init();
};
} // namespace KIGFX
 
#endif  // OPENGLGAL_H_