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 (C) 1992-2024 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, 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 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;
 
 
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();
 
 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();
 
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 OnTimerTimeout_Editing( wxTimerEvent& event );
 void OnCloseWindow( wxCloseEvent& event );
 void OnResize( wxSizeEvent& event );
 void OnTimerTimeout_Redraw( wxTimerEvent& 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;
 wxStatusBar* m_parentStatusBar; // Parent statusbar to report progress
 WX_INFOBAR* m_parentInfoBar;
 
 wxGLContext* m_glRC; // Current OpenGL context
 bool m_is_opengl_initialized;
 bool m_is_opengl_version_supported;
 
 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; // Avoid drawing twice at the same time
 
 bool m_render_pivot; // Render the pivot while camera moving
 float m_camera_moving_speed; // 1.0f will be 1:1
 int64_t m_strtime_camera_movement; // Ticktime of camera movement start
 bool m_animation_enabled; // Camera animation enabled
 int m_moving_speed_multiplier; // Camera animation speed multiplier option
 
 BOARD_ADAPTER& m_boardAdapter; // Pre-computed 3D info and settings
 RENDER_3D_BASE* m_3d_render;
 RENDER_3D_RAYTRACE_GL* m_3d_render_raytracing;
 RENDER_3D_OPENGL* m_3d_render_opengl;
 
 bool m_opengl_supports_raytracing;
 bool m_render_raytracing_was_requested;
 
 ACCELERATOR_3D* m_accelerator3DShapes; // used for mouse over searching
 
 BOARD_ITEM* m_currentRollOverItem;
 
 bool m_render3dmousePivot = false; // Render the 3dmouse pivot
 SFVEC3F m_3dmousePivotPos; // The position of the 3dmouse pivot
 
 static const wxChar* m_logTrace;
};
 
 
#endif // EDA_3D_CANVAS_H