eda_3d_canvas.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2015-2016 Mario Luzeiro <[email protected]>
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * 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, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef EDA_3D_CANVAS_H
#define EDA_3D_CANVAS_H
 
#include <atomic>
#include "board_adapter.h"
#include "3d_rendering/raytracing/accelerators/accelerator_3d.h"
#include "3d_rendering/render_3d_base.h"
#include "3d_cache/3d_cache.h"
#include <gal/hidpi_gl_3D_canvas.h>
#include <wx/image.h>
#include <wx/timer.h>
 
 
class WX_INFOBAR;
class wxStatusBar;
class BOARD;
class RENDER_3D_RAYTRACE_GL;
class RENDER_3D_OPENGL;
 
 
#define EDA_3D_CANVAS_ID (wxID_HIGHEST + 1321)

class EDA_3D_CANVAS : public HIDPI_GL_3D_CANVAS
{
public:
    EDA_3D_CANVAS( wxWindow* aParent, const wxGLAttributes& aGLAttribs, BOARD_ADAPTER& aSettings,
                   CAMERA& aCamera, S3D_CACHE* a3DCachePointer );
 
    ~EDA_3D_CANVAS() override;

    void SetEventDispatcher( TOOL_DISPATCHER* aEventDispatcher );
 
    void SetStatusBar( wxStatusBar* aStatusBar )
    {
        m_parentStatusBar = aStatusBar;
    }
 
    void SetInfoBar( WX_INFOBAR* aInfoBar )
    {
        m_parentInfoBar = aInfoBar;
    }
 
    void ReloadRequest( BOARD* aBoard = nullptr, S3D_CACHE* aCachePointer = nullptr );

    bool IsReloadRequestPending() const
    {
        if( m_3d_render )
            return m_3d_render->IsReloadRequestPending();
        else
            return false;
    }

    RENDER_3D_BASE* GetCurrentRender() const { return m_3d_render; }

    void RenderRaytracingRequest();

    void GetScreenshot( wxImage& aDstImage );

    bool SetView3D( VIEW3D_TYPE aRequestedView );

    void SetAnimationEnabled( bool aEnable ) { m_animation_enabled = aEnable; }
    bool GetAnimationEnabled() const { return m_animation_enabled; }

    void SetMovingSpeedMultiplier( int aMultiplier ) { m_moving_speed_multiplier = aMultiplier; }
    int GetMovingSpeedMultiplier() const { return m_moving_speed_multiplier; }
 
    int GetProjectionMode() const { return (int) m_camera.GetProjection(); };
    void SetProjectionMode( int aMode ) { m_camera.SetProjection( (PROJECTION_TYPE) aMode ); }

    void RenderEngineChanged();

    void DisplayStatus();

    void Request_refresh( bool aRedrawImmediately = true );

    void OnEvent( wxEvent& aEvent );

    const BOARD_ADAPTER& GetBoardAdapter() const { return m_boardAdapter; }

    bool GetRenderPivot() { return m_render_pivot; }

    void SetRenderPivot( bool aValue ) { m_render_pivot = aValue; }

    bool GetRender3dmousePivot()
    {
        return m_render3dmousePivot;
    }
 

    void SetRender3dmousePivot( bool aValue )
    {
        m_render3dmousePivot = aValue;
    }
 

    void Set3dmousePivotPos( const SFVEC3F& aPos )
    {
        m_3dmousePivotPos = aPos;
    }

    void DoRePaint();
 
    void RenderToFrameBuffer( unsigned char* aBuffer, int aWidth, int aHeight );
 
    void OnCloseWindow( wxCloseEvent& event );
 
private:
    // The wxPaintEvent event. mainly calls DoRePaint()
    void OnPaint( wxPaintEvent& aEvent );
 
    void OnEraseBackground( wxEraseEvent& event );
 
    void OnRefreshRequest( wxEvent& aEvent );
 
    void OnMouseWheel( wxMouseEvent& event );
 
    void OnMagnify( wxMouseEvent& event );
    void OnMouseMove( wxMouseEvent& event );
    void OnLeftDown( wxMouseEvent& event );
    void OnLeftUp( wxMouseEvent& event );
    void OnMiddleUp( wxMouseEvent& event );
    void OnMiddleDown( wxMouseEvent& event );
    void OnRightUp( wxMouseEvent& event );
    void OnRightDown( wxMouseEvent& event );
 
    void OnTimerTimeout_Editing( wxTimerEvent& event );
    void OnResize( wxSizeEvent& event );
    void OnTimerTimeout_Redraw( wxTimerEvent& event );
 
    void OnZoomGesture( wxZoomGestureEvent& event );
    void OnPanGesture( wxPanGestureEvent& event );
    void OnRotateGesture( wxRotateGestureEvent& event );
 
    DECLARE_EVENT_TABLE()
 
    
    void stop_editingTimeOut_Timer();

    void restart_editingTimeOut_Timer();

    void request_start_moving_camera( float aMovingSpeed = 2.0f, bool aRenderPivot = true );

    void move_pivot_based_on_cur_mouse_position();

    void render_pivot( float t, float aScale );

    void render3dmousePivot( float aScale );

    bool initializeOpenGL();

    void releaseOpenGL();
 
    RAY getRayAtCurrentMousePosition();
 
private:
    TOOL_DISPATCHER*       m_eventDispatcher = nullptr;
    wxStatusBar*           m_parentStatusBar = nullptr;         // Parent statusbar to report progress
    WX_INFOBAR*            m_parentInfoBar = nullptr;
 
    wxGLContext*           m_glRC = nullptr;                    // Current OpenGL context
    bool                   m_is_opengl_initialized = false;
    bool                   m_is_opengl_version_supported = true;
 
    wxTimer                m_editing_timeout_timer;   // Expires after some time signaling that
                                                      // the mouse / keyboard movements are over
    wxTimer                m_redraw_trigger_timer;    // Used to schedule a redraw event
    std::atomic_flag       m_is_currently_painting = ATOMIC_FLAG_INIT;   // Avoid drawing twice at the same time
 
    bool                   m_render_pivot = false;            // Render the pivot while camera moving
    float                  m_camera_moving_speed = 1.0f;     // 1.0f will be 1:1
    int64_t                m_strtime_camera_movement = 0; // Ticktime of camera movement start
    bool                   m_animation_enabled = true;       // Camera animation enabled
    int                    m_moving_speed_multiplier = 3; // Camera animation speed multiplier option
 
    BOARD_ADAPTER&         m_boardAdapter;            // Pre-computed 3D info and settings
    RENDER_3D_BASE*        m_3d_render = nullptr;
    RENDER_3D_RAYTRACE_GL* m_3d_render_raytracing;
    RENDER_3D_OPENGL*      m_3d_render_opengl;
 
    bool                   m_opengl_supports_raytracing = true;
    bool                   m_render_raytracing_was_requested = false;
 
    ACCELERATOR_3D*        m_accelerator3DShapes = nullptr;    // used for mouse over searching
 
    BOARD_ITEM*            m_currentRollOverItem = nullptr;
 
    bool    m_render3dmousePivot = false; // Render the 3dmouse pivot
    SFVEC3F m_3dmousePivotPos;            // The position of the 3dmouse pivot

    double   m_gestureLastZoomFactor = 1.0;
    double   m_gestureLastAngle = 0.0;

    static const wxChar* m_logTrace;
};
 
 
#endif // EDA_3D_CANVAS_H