Merge pull request #4 from FOSSEE/develop

merging dev into master

1 files changed, 394 insertions, 0 deletions

diff --git a/include/gal/opengl/opengl_gal.h b/include/gal/opengl/opengl_gal.h
new file mode 100644
index 0000000..83598ba
--- /dev/null
+++ b/include/gal/opengl/opengl_gal.h
@@ -0,0 +1,394 @@
+/*
+ * 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) 2012 Kicad Developers, see change_log.txt for contributors.
+ * Copyright (C) 2013-2016 CERN
+ * @author Maciej Suminski <maciej.suminski@cern.ch>
+ *
+ * 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/graphics_abstraction_layer.h>
+#include <gal/opengl/shader.h>
+#include <gal/opengl/vertex_manager.h>
+#include <gal/opengl/vertex_item.h>
+#include <gal/opengl/noncached_container.h>
+#include <gal/opengl/opengl_compositor.h>
+
+#include <wx/glcanvas.h>
+
+#include <map>
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/shared_array.hpp>
+
+#ifndef CALLBACK
+#define CALLBACK
+#endif
+
+namespace KIGFX
+{
+class SHADER;
+
+/**
+ * @brief Class OpenGL_GAL is the OpenGL implementation of the Graphics Abstraction Layer.
+ *
+ * This is a direct OpenGL-implementation and uses low-level graphics primitives like triangles
+ * and quads. The purpose is to provide a fast graphics interface, that takes advantage of modern
+ * graphics card GPUs. All methods here benefit thus from the hardware acceleration.
+ */
+class OPENGL_GAL : public GAL, public wxGLCanvas
+{
+public:
+
+    /**
+     * @brief Constructor OPENGL_GAL
+     *
+     * @param aParent is the wxWidgets immediate wxWindow parent of this object.
+     *
+     * @param aMouseListener is the wxEvtHandler that should receive the mouse events,
+     *  this can be can be any wxWindow, but is often a wxFrame container.
+     *
+     * @param aPaintListener is the wxEvtHandler that should receive the paint
+     *  event.  This can be any wxWindow, but is often a derived instance
+     *  of this class or a containing wxFrame.  The "paint event" here is
+     *  a wxCommandEvent holding EVT_GAL_REDRAW, as sent by PostPaint().
+     *
+     * @param aName is the name of this window for use by wxWindow::FindWindowByName()
+     */
+    OPENGL_GAL( wxWindow* aParent, wxEvtHandler* aMouseListener = NULL,
+                wxEvtHandler* aPaintListener = NULL, const wxString& aName = wxT( "GLCanvas" ) );
+
+    virtual ~OPENGL_GAL();
+
+   /// @copydoc GAL::IsInitialized()
+    virtual bool IsInitialized() const { return IsShownOnScreen(); }
+
+    // ---------------
+    // Drawing methods
+    // ---------------
+
+    /// @copydoc GAL::BeginDrawing()
+    virtual void BeginDrawing();
+
+    /// @copydoc GAL::EndDrawing()
+    virtual void EndDrawing();
+
+    /// @copydoc GAL::DrawLine()
+    virtual void DrawLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
+
+    /// @copydoc GAL::DrawSegment()
+    virtual void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint,
+                              double aWidth );
+
+    /// @copydoc GAL::DrawCircle()
+    virtual void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius );
+
+    /// @copydoc GAL::DrawArc()
+    virtual void DrawArc( const VECTOR2D& aCenterPoint, double aRadius,
+                          double aStartAngle, double aEndAngle );
+
+    /// @copydoc GAL::DrawRectangle()
+    virtual void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
+
+    /// @copydoc GAL::DrawPolyline()
+    virtual void DrawPolyline( const std::deque<VECTOR2D>& aPointList );
+    virtual void DrawPolyline( const VECTOR2D aPointList[], int aListSize );
+
+    /// @copydoc GAL::DrawPolygon()
+    virtual void DrawPolygon( const std::deque<VECTOR2D>& aPointList );
+    virtual void DrawPolygon( const VECTOR2D aPointList[], int aListSize );
+
+    /// @copydoc GAL::DrawCurve()
+    virtual void DrawCurve( const VECTOR2D& startPoint, const VECTOR2D& controlPointA,
+                            const VECTOR2D& controlPointB, const VECTOR2D& endPoint );
+
+    // --------------
+    // Screen methods
+    // --------------
+
+    /// @brief Resizes the canvas.
+    virtual void ResizeScreen( int aWidth, int aHeight );
+
+    /// @brief Shows/hides the GAL canvas
+    virtual bool Show( bool aShow );
+
+    /// @copydoc GAL::Flush()
+    virtual void Flush();
+
+    /// @copydoc GAL::ClearScreen()
+    virtual void ClearScreen( const COLOR4D& aColor );
+
+    // --------------
+    // Transformation
+    // --------------
+
+    /// @copydoc GAL::Transform()
+    virtual void Transform( const MATRIX3x3D& aTransformation );
+
+    /// @copydoc GAL::Rotate()
+    virtual void Rotate( double aAngle );
+
+    /// @copydoc GAL::Translate()
+    virtual void Translate( const VECTOR2D& aTranslation );
+
+    /// @copydoc GAL::Scale()
+    virtual void Scale( const VECTOR2D& aScale );
+
+    /// @copydoc GAL::Save()
+    virtual void Save();
+
+    /// @copydoc GAL::Restore()
+    virtual void Restore();
+
+    // --------------------------------------------
+    // Group methods
+    // ---------------------------------------------
+
+    /// @copydoc GAL::BeginGroup()
+    virtual int BeginGroup();
+
+    /// @copydoc GAL::EndGroup()
+    virtual void EndGroup();
+
+    /// @copydoc GAL::DrawGroup()
+    virtual void DrawGroup( int aGroupNumber );
+
+    /// @copydoc GAL::ChangeGroupColor()
+    virtual void ChangeGroupColor( int aGroupNumber, const COLOR4D& aNewColor );
+
+    /// @copydoc GAL::ChangeGroupDepth()
+    virtual void ChangeGroupDepth( int aGroupNumber, int aDepth );
+
+    /// @copydoc GAL::DeleteGroup()
+    virtual void DeleteGroup( int aGroupNumber );
+
+    /// @copydoc GAL::ClearCache()
+    virtual void ClearCache();
+
+    // --------------------------------------------------------
+    // Handling the world <-> screen transformation
+    // --------------------------------------------------------
+
+    /// @copydoc GAL::SaveScreen()
+    virtual void SaveScreen();
+
+    /// @copydoc GAL::RestoreScreen()
+    virtual void RestoreScreen();
+
+    /// @copydoc GAL::SetTarget()
+    virtual void SetTarget( RENDER_TARGET aTarget );
+
+    /// @copydoc GAL::GetTarget()
+    virtual RENDER_TARGET GetTarget() const;
+
+    /// @copydoc GAL::ClearTarget()
+    virtual void ClearTarget( RENDER_TARGET aTarget );
+
+    // -------
+    // Cursor
+    // -------
+
+    /// @copydoc GAL::DrawCursor()
+    virtual void DrawCursor( const VECTOR2D& aCursorPosition );
+
+    /**
+     * @brief Function PostPaint
+     * posts an event to m_paint_listener.  A post is used so that the actual drawing
+     * function can use a device context type that is not specific to the wxEVT_PAINT event.
+     */
+    void PostPaint()
+    {
+        if( paintListener )
+        {
+            wxPaintEvent redrawEvent;
+            wxPostEvent( paintListener, redrawEvent );
+        }
+    }
+
+    void SetMouseListener( wxEvtHandler* aMouseListener )
+    {
+        mouseListener = aMouseListener;
+    }
+
+    void SetPaintListener( wxEvtHandler* aPaintListener )
+    {
+        paintListener = aPaintListener;
+    }
+
+    ///< Parameters passed to the GLU tesselator
+    typedef struct
+    {
+        /// Manager used for storing new vertices
+        VERTEX_MANAGER* vboManager;
+
+        /// Intersect points, that have to be freed after tessellation
+        std::deque< boost::shared_array<GLdouble> >& intersectPoints;
+    } TessParams;
+
+protected:
+    virtual void drawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
+
+private:
+    /// Super class definition
+    typedef GAL super;
+
+    static const int    CIRCLE_POINTS   = 64;   ///< The number of points for circle approximation
+    static const int    CURVE_POINTS    = 32;   ///< The number of points for curve approximation
+
+    wxClientDC*             clientDC;               ///< Drawing context
+    static wxGLContext*     glContext;              ///< OpenGL context of wxWidgets
+    wxEvtHandler*           mouseListener;
+    wxEvtHandler*           paintListener;
+
+    // Vertex buffer objects related fields
+    typedef std::map< unsigned int, boost::shared_ptr<VERTEX_ITEM> > GROUPS_MAP;
+    GROUPS_MAP              groups;                 ///< Stores informations about VBO objects (groups)
+    unsigned int            groupCounter;           ///< Counter used for generating keys for groups
+    VERTEX_MANAGER*         currentManager;         ///< Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
+    VERTEX_MANAGER          cachedManager;          ///< Container for storing cached VERTEX_ITEMs
+    VERTEX_MANAGER          nonCachedManager;       ///< Container for storing non-cached VERTEX_ITEMs
+    VERTEX_MANAGER          overlayManager;         ///< Container for storing overlaid VERTEX_ITEMs
+
+    // Framebuffer & compositing
+    OPENGL_COMPOSITOR       compositor;             ///< Handles multiple rendering targets
+    unsigned int            mainBuffer;             ///< Main rendering target
+    unsigned int            overlayBuffer;          ///< Auxiliary rendering target (for menus etc.)
+    RENDER_TARGET           currentTarget;          ///< Current rendering target
+
+    // Shader
+    SHADER                  shader;         ///< There is only one shader used for different objects
+
+    // Internal flags
+    bool                    isFramebufferInitialized;   ///< Are the framebuffers initialized?
+    bool                    isGrouping;                 ///< Was a group started?
+
+    // Polygon tesselation
+    /// The tessellator
+    GLUtesselator*          tesselator;
+    /// Storage for intersecting points
+    std::deque< boost::shared_array<GLdouble> > tessIntersects;
+
+    /**
+     * @brief Draw a quad for the line.
+     *
+     * @param aStartPoint is the start point of the line.
+     * @param aEndPoint is the end point of the line.
+     */
+    void drawLineQuad( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
+
+    /**
+     * @brief Draw a semicircle. Depending on settings (isStrokeEnabled & isFilledEnabled) it runs
+     * the proper function (drawStrokedSemiCircle or drawFilledSemiCircle).
+     *
+     * @param aCenterPoint is the center point.
+     * @param aRadius is the radius of the semicircle.
+     * @param aAngle is the angle of the semicircle.
+     *
+     */
+    void drawSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle );
+
+    /**
+     * @brief Draw a filled semicircle.
+     *
+     * @param aCenterPoint is the center point.
+     * @param aRadius is the radius of the semicircle.
+     * @param aAngle is the angle of the semicircle.
+     *
+     */
+    void drawFilledSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle );
+
+    /**
+     * @brief Draw a stroked semicircle.
+     *
+     * @param aCenterPoint is the center point.
+     * @param aRadius is the radius of the semicircle.
+     * @param aAngle is the angle of the semicircle.
+     *
+     */
+    void drawStrokedSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle );
+
+    // Event handling
+    /**
+     * @brief This is the OnPaint event handler.
+     *
+     * @param aEvent is the OnPaint event.
+     */
+    void onPaint( wxPaintEvent& aEvent );
+
+    /**
+     * @brief Skip the mouse event to the parent.
+     *
+     * @param aEvent is the mouse event.
+     */
+    void skipMouseEvent( wxMouseEvent& aEvent );
+
+    /**
+     * @brief Blits cursor into the current screen.
+     */
+    void blitCursor();
+
+    /**
+     * @brief Returns a valid key that can be used as a new group number.
+     *
+     * @return An unique group number that is not used by any other group.
+     */
+    unsigned int getNewGroupNumber();
+
+    /**
+     * @brief Checks if the required OpenGL version and extensions are supported.
+     * @return true in case of success.
+     */
+    bool runTest();
+
+    // Helper class to determine OpenGL capabilities
+    class OPENGL_TEST: public wxGLCanvas
+    {
+    public:
+        OPENGL_TEST( wxDialog* aParent, OPENGL_GAL* aGal );
+
+        void Render( wxPaintEvent& aEvent );
+        void OnTimeout( wxTimerEvent& aEvent );
+        void OnDialogPaint( wxPaintEvent& aEvent );
+
+        inline bool IsTested() const { return m_tested; }
+        inline bool IsOk() const { return m_result && m_tested; }
+        inline std::string GetError() const { return m_error; }
+
+    private:
+        void error( const std::string& aError );
+
+        wxDialog* m_parent;
+        OPENGL_GAL* m_gal;
+        bool m_tested;
+        bool m_result;
+        std::string m_error;
+        wxTimer m_timeoutTimer;
+    };
+
+    friend class OPENGL_TEST;
+};
+} // namespace KIGFX
+
+#endif  // OPENGLGAL_H_