KiCad PCB EDA Suite
Loading...
Searching...
No Matches
eda_3d_canvas.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2015-2016 Mario Luzeiro <[email protected]>
5 * Copyright (C) 1992-2024 KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, you may find one here:
19 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20 * or you may search the http://www.gnu.org website for the version 2 license,
21 * or you may write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25#include <gal/opengl/kiglew.h> // Must be included first
26#include <gal/opengl/gl_utils.h>
27#include <wx/tokenzr.h>
28
29#include "../common_ogl/ogl_utils.h"
30#include "eda_3d_canvas.h"
31#include <eda_3d_viewer_frame.h>
34#include <3d_viewer_id.h>
35#include <advanced_config.h>
36#include <build_version.h>
37#include <board.h>
38#include <reporter.h>
40#include <core/profile.h> // To use GetRunningMicroSecs or another profiling utility
41#include <bitmaps.h>
42#include <macros.h>
43#include <pgm_base.h>
46
48
49
57const wxChar* EDA_3D_CANVAS::m_logTrace = wxT( "KI_TRACE_EDA_3D_CANVAS" );
58
59
60// A custom event, used to call DoRePaint during an idle time
61wxDEFINE_EVENT( wxEVT_REFRESH_CUSTOM_COMMAND, wxEvent );
62
63
64BEGIN_EVENT_TABLE( EDA_3D_CANVAS, HIDPI_GL_3D_CANVAS )
65 EVT_PAINT( EDA_3D_CANVAS::OnPaint )
66
67 // mouse events
68 EVT_LEFT_DOWN( EDA_3D_CANVAS::OnLeftDown )
69 EVT_LEFT_UP( EDA_3D_CANVAS::OnLeftUp )
70 EVT_MIDDLE_UP( EDA_3D_CANVAS::OnMiddleUp )
71 EVT_MIDDLE_DOWN( EDA_3D_CANVAS::OnMiddleDown)
72 EVT_MOUSEWHEEL( EDA_3D_CANVAS::OnMouseWheel )
73 EVT_MOTION( EDA_3D_CANVAS::OnMouseMove )
74 EVT_MAGNIFY( EDA_3D_CANVAS::OnMagnify )
75
76 // touch gesture events
77 EVT_GESTURE_ZOOM( wxID_ANY, EDA_3D_CANVAS::OnZoomGesture )
78 EVT_GESTURE_PAN( wxID_ANY, EDA_3D_CANVAS::OnPanGesture )
79 EVT_GESTURE_ROTATE( wxID_ANY, EDA_3D_CANVAS::OnRotateGesture )
80
81 // other events
82 EVT_ERASE_BACKGROUND( EDA_3D_CANVAS::OnEraseBackground )
83 EVT_CUSTOM(wxEVT_REFRESH_CUSTOM_COMMAND, ID_CUSTOM_EVENT_1, EDA_3D_CANVAS::OnRefreshRequest )
84
86 EVT_SIZE( EDA_3D_CANVAS::OnResize )
87END_EVENT_TABLE()
88
89
90EDA_3D_CANVAS::EDA_3D_CANVAS( wxWindow* aParent, const wxGLAttributes& aGLAttribs,
91 BOARD_ADAPTER& aBoardAdapter, CAMERA& aCamera,
92 S3D_CACHE* a3DCachePointer ) :
93 HIDPI_GL_3D_CANVAS( EDA_DRAW_PANEL_GAL::GetVcSettings(), aCamera, aParent, aGLAttribs,
94 wxID_ANY, wxDefaultPosition,
95 wxDefaultSize, wxFULL_REPAINT_ON_RESIZE ),
96 m_eventDispatcher( nullptr ),
97 m_parentStatusBar( nullptr ),
98 m_parentInfoBar( nullptr ),
99 m_glRC( nullptr ),
100 m_is_opengl_initialized( false ),
101 m_is_opengl_version_supported( true ),
102 m_editing_timeout_timer( this, wxID_HIGHEST + 1 ),
103 m_redraw_trigger_timer( this, wxID_HIGHEST + 2 ),
104 m_render_pivot( false ),
105 m_camera_moving_speed( 1.0f ),
106 m_strtime_camera_movement( 0 ),
107 m_animation_enabled( true ),
108 m_moving_speed_multiplier( 3 ),
109 m_boardAdapter( aBoardAdapter ),
110 m_3d_render( nullptr ),
111 m_opengl_supports_raytracing( true ),
112 m_render_raytracing_was_requested( false ),
113 m_accelerator3DShapes( nullptr ),
114 m_currentRollOverItem( nullptr )
115{
116 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::EDA_3D_CANVAS" ) );
117
118 m_editing_timeout_timer.SetOwner( this );
119 Connect( m_editing_timeout_timer.GetId(), wxEVT_TIMER,
120 wxTimerEventHandler( EDA_3D_CANVAS::OnTimerTimeout_Editing ), nullptr, this );
121
122 m_redraw_trigger_timer.SetOwner( this );
123 Connect( m_redraw_trigger_timer.GetId(), wxEVT_TIMER,
124 wxTimerEventHandler( EDA_3D_CANVAS::OnTimerTimeout_Redraw ), nullptr, this );
125
126 m_is_currently_painting.clear();
127
128 m_3d_render_raytracing = new RENDER_3D_RAYTRACE_GL( this, m_boardAdapter, m_camera );
129 m_3d_render_opengl = new RENDER_3D_OPENGL( this, m_boardAdapter, m_camera );
130
131 wxASSERT( m_3d_render_raytracing != nullptr );
132 wxASSERT( m_3d_render_opengl != nullptr );
133
134 auto busy_indicator_factory =
135 []()
136 {
137 return std::make_unique<WX_BUSY_INDICATOR>();
138 };
139
140 m_3d_render_raytracing->SetBusyIndicatorFactory( busy_indicator_factory );
141 m_3d_render_opengl->SetBusyIndicatorFactory( busy_indicator_factory );
142
143 // We always start with the opengl engine (raytracing is avoided due to very
144 // long calculation time)
145 m_3d_render = m_3d_render_opengl;
146
147 m_boardAdapter.ReloadColorSettings();
148
149 wxASSERT( a3DCachePointer != nullptr );
150 m_boardAdapter.Set3dCacheManager( a3DCachePointer );
151
152#ifdef __WXMSW__
153 EnableTouchEvents( wxTOUCH_ZOOM_GESTURE | wxTOUCH_PAN_GESTURES | wxTOUCH_ROTATE_GESTURE );
154#endif
155
156 const wxEventType events[] =
157 {
158 // Binding both EVT_CHAR and EVT_CHAR_HOOK ensures that all key events,
159 // especially special key like arrow keys, are handled by the GAL event dispatcher,
160 // and not sent to GUI without filtering, because they have a default action (scroll)
161 // that must not be called.
162 wxEVT_LEFT_UP, wxEVT_LEFT_DOWN, wxEVT_LEFT_DCLICK,
163 wxEVT_RIGHT_UP, wxEVT_RIGHT_DOWN, wxEVT_RIGHT_DCLICK,
164 wxEVT_MIDDLE_UP, wxEVT_MIDDLE_DOWN, wxEVT_MIDDLE_DCLICK,
165 wxEVT_MOTION, wxEVT_MOUSEWHEEL, wxEVT_CHAR, wxEVT_CHAR_HOOK,
166 wxEVT_MAGNIFY,
167 wxEVT_MENU_OPEN, wxEVT_MENU_CLOSE, wxEVT_MENU_HIGHLIGHT
168 };
169
170 for( wxEventType eventType : events )
171 Connect( eventType, wxEventHandler( EDA_3D_CANVAS::OnEvent ), nullptr, m_eventDispatcher );
172}
173
174
176{
177 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::~EDA_3D_CANVAS" ) );
178
180 m_accelerator3DShapes = nullptr;
181
183}
184
185
187{
188 if( m_glRC )
189 {
191
193 m_3d_render_raytracing = nullptr;
194
195 delete m_3d_render_opengl;
196 m_3d_render_opengl = nullptr;
197
198 // This is just a copy of a pointer, can safely be set to NULL.
199 m_3d_render = nullptr;
200
203 m_glRC = nullptr;
204 }
205}
206
207
208void EDA_3D_CANVAS::OnCloseWindow( wxCloseEvent& event )
209{
211
212 event.Skip();
213}
214
215
216void EDA_3D_CANVAS::OnResize( wxSizeEvent& event )
217{
219}
220
221
223{
224 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::initializeOpenGL" ) );
225
226 const GLenum err = glewInit();
227
228 if( GLEW_OK != err )
229 {
230 const wxString msgError = (const char*) glewGetErrorString( err );
231
232 wxLogMessage( msgError );
233
234 return false;
235 }
236 else
237 {
238 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::initializeOpenGL Using GLEW version %s" ),
239 From_UTF8( (char*) glewGetString( GLEW_VERSION ) ) );
240 }
241
242 SetOpenGLInfo( (const char*) glGetString( GL_VENDOR ), (const char*) glGetString( GL_RENDERER ),
243 (const char*) glGetString( GL_VERSION ) );
244
245 wxString version = From_UTF8( (char *) glGetString( GL_VERSION ) );
246
247 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::%s OpenGL version string %s." ),
248 __WXFUNCTION__, version );
249
250 // Extract OpenGL version from string. This method is used because prior to OpenGL 2,
251 // getting the OpenGL major and minor version as integers didn't exist.
252 wxString tmp;
253
254 wxStringTokenizer tokenizer( version );
255
256 if( tokenizer.HasMoreTokens() )
257 {
258 long major = 0;
259 long minor = 0;
260
261 tmp = tokenizer.GetNextToken();
262
263 tokenizer.SetString( tmp, wxString( wxT( "." ) ) );
264
265 if( tokenizer.HasMoreTokens() )
266 tokenizer.GetNextToken().ToLong( &major );
267
268 if( tokenizer.HasMoreTokens() )
269 tokenizer.GetNextToken().ToLong( &minor );
270
271 if( major < 2 || ( ( major == 2 ) && ( minor < 1 ) ) )
272 {
273 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::%s OpenGL ray tracing not supported." ),
274 __WXFUNCTION__ );
275
276 if( GetParent() )
277 {
278 wxCommandEvent evt( wxEVT_MENU, ID_DISABLE_RAY_TRACING );
279 GetParent()->ProcessWindowEvent( evt );
280 }
281
283 }
284
285 if( ( major == 1 ) && ( minor < 5 ) )
286 {
287 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::%s OpenGL not supported." ),
288 __WXFUNCTION__ );
289
291 }
292 }
293
296
297 return true;
298}
299
300
301void EDA_3D_CANVAS::GetScreenshot( wxImage& aDstImage )
302{
303 OglGetScreenshot( aDstImage );
304}
305
306
307void EDA_3D_CANVAS::ReloadRequest( BOARD* aBoard , S3D_CACHE* aCachePointer )
308{
309 if( aCachePointer != nullptr )
310 m_boardAdapter.Set3dCacheManager( aCachePointer );
311
312 if( aBoard != nullptr )
313 m_boardAdapter.SetBoard( aBoard );
314
316
317 if( m_3d_render )
319}
320
321
323{
325
326 if( m_3d_render )
328
330
332}
333
334
336{
338 {
339 wxString msg;
340
341 msg.Printf( wxT( "dx %3.2f" ), m_camera.GetCameraPos().x );
342 m_parentStatusBar->SetStatusText( msg, static_cast<int>( EDA_3D_VIEWER_STATUSBAR::X_POS ) );
343
344 msg.Printf( wxT( "dy %3.2f" ), m_camera.GetCameraPos().y );
345 m_parentStatusBar->SetStatusText( msg, static_cast<int>( EDA_3D_VIEWER_STATUSBAR::Y_POS ) );
346
347 msg.Printf( wxT( "zoom %3.2f" ), 1 / m_camera.GetZoom() );
348 m_parentStatusBar->SetStatusText( msg, static_cast<int>( EDA_3D_VIEWER_STATUSBAR::ZOOM_LEVEL ) );
349 }
350}
351
352
353void EDA_3D_CANVAS::OnPaint( wxPaintEvent& aEvent )
354{
355 // Please have a look at: https://lists.launchpad.net/kicad-developers/msg25149.html
356 DoRePaint();
357}
358
359
361{
362 if( m_is_currently_painting.test_and_set() )
363 return;
364
365 // SwapBuffer requires the window to be shown before calling
366 if( !IsShownOnScreen() )
367 {
368 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::DoRePaint !IsShown" ) );
370 return;
371 }
372
373 // Because the board to draw is handled by the parent viewer frame,
374 // ensure this parent is still alive. When it is closed before the viewer
375 // frame, a paint event can be generated after the parent is closed,
376 // therefore with invalid board.
377 // This is dependent of the platform.
378 // Especially on OSX, but also on Windows, it frequently happens
379 if( !GetParent()->GetParent()->IsShownOnScreen() )
380 return; // The parent board editor frame is no more alive
381
382 wxString err_messages;
383 INFOBAR_REPORTER warningReporter( m_parentInfoBar );
384 STATUSBAR_REPORTER activityReporter( m_parentStatusBar, EDA_3D_VIEWER_STATUSBAR::ACTIVITY );
385 int64_t start_time = GetRunningMicroSecs();
386
387 // "Makes the OpenGL state that is represented by the OpenGL rendering
388 // context context current, i.e. it will be used by all subsequent OpenGL calls.
389 // This function may only be called when the window is shown on screen"
390
391 // Explicitly create a new rendering context instance for this canvas.
392 if( m_glRC == nullptr )
394
395 // CreateCtx could and does fail per sentry crash events, lets be graceful
396 if( m_glRC == nullptr )
397 {
398 warningReporter.Report( _( "OpenGL context creation error" ), RPT_SEVERITY_ERROR );
399 warningReporter.Finalize();
401 return;
402 }
403
405
406 // Set the OpenGL viewport according to the client size of this canvas.
407 // This is done here rather than in a wxSizeEvent handler because our
408 // OpenGL rendering context (and thus viewport setting) is used with
409 // multiple canvases: If we updated the viewport in the wxSizeEvent
410 // handler, changing the size of one canvas causes a viewport setting that
411 // is wrong when next another canvas is repainted.
412 wxSize clientSize = GetNativePixelSize();
413
414 const bool windows_size_changed = m_camera.SetCurWindowSize( clientSize );
415
416 // Initialize openGL if need
418 {
419 if( !initializeOpenGL() )
420 {
423
424 return;
425 }
426
428 {
429 warningReporter.Report( _( "Your OpenGL version is not supported. Minimum required "
430 "is 1.5." ), RPT_SEVERITY_ERROR );
431
432 warningReporter.Finalize();
433 }
434 }
435
437 {
438 glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
439 glClear( GL_COLOR_BUFFER_BIT );
440
441 SwapBuffers();
442
445
446 return;
447 }
448
449 // Don't attend to ray trace if OpenGL doesn't support it.
451 {
454 m_boardAdapter.m_Cfg->m_Render.engine = RENDER_ENGINE::OPENGL;
455 }
456
457 // Check if a raytacing was requested and need to switch to raytracing mode
458 if( m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
459 {
460 const bool was_camera_changed = m_camera.ParametersChanged();
461
462 // It reverts back to OpenGL mode if it was requested a raytracing
463 // render of the current scene. AND the mouse / camera is moving
464 if( ( m_mouse_is_moving || m_camera_is_moving || was_camera_changed
465 || windows_size_changed )
467 {
470 }
471 }
472
473 float curtime_delta_s = 0.0f;
474
476 {
477 const int64_t curtime_delta = GetRunningMicroSecs() - m_strtime_camera_movement;
478 curtime_delta_s = (curtime_delta / 1e6) * m_camera_moving_speed;
479 m_camera.Interpolate( curtime_delta_s );
480
481 if( curtime_delta_s > 1.0f )
482 {
483 m_render_pivot = false;
484 m_camera_is_moving = false;
485 m_mouse_was_moved = true;
486
489 }
490 else
491 {
493 }
494 }
495
496 // It will return true if the render request a new redraw
497 bool requested_redraw = false;
498
499 if( m_3d_render )
500 {
501 try
502 {
503 m_3d_render->SetCurWindowSize( clientSize );
504
505 bool reloadRaytracingForCalculations = false;
506
507 if( m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL
509 {
510 reloadRaytracingForCalculations = true;
511 }
512
514 &activityReporter, &warningReporter );
515
516 // Raytracer renderer is responsible for some features also used by the OpenGL
517 // renderer.
518 // FIXME: Presumably because raytracing renderer reload is called only after current
519 // renderer redraw, the old zoom value stays for a single frame. This is ugly, but only
520 // cosmetic, so I'm not fixing that for now: I don't know how to do this without
521 // reloading twice (maybe it's not too bad of an idea?) or doing a complicated
522 // refactor.
523 if( reloadRaytracingForCalculations )
524 m_3d_render_raytracing->Reload( nullptr, nullptr, true );
525 }
526 catch( std::runtime_error& )
527 {
533 return;
534 }
535 }
536
537 if( m_render_pivot )
538 {
539 const float scale = glm::min( m_camera.GetZoom(), 1.0f );
540 render_pivot( curtime_delta_s, scale );
541 }
542
543 // This will only be enabled by the 3d mouse plugin, so we can leave
544 // it as a simple if statement
546 {
547 const float scale = glm::min( m_camera.GetZoom(), 1.0f );
549 }
550
551 // "Swaps the double-buffer of this window, making the back-buffer the
552 // front-buffer and vice versa, so that the output of the previous OpenGL
553 // commands is displayed on the window."
554 SwapBuffers();
555
557
559 {
560 // Calculation time in milliseconds
561 const double calculation_time = (double)( GetRunningMicroSecs() - start_time ) / 1e3;
562
563 activityReporter.Report( wxString::Format( _( "Last render time %.0f ms" ),
564 calculation_time ) );
565 }
566
567 // This will reset the flag of camera parameters changed
569
570 warningReporter.Finalize();
571
572 if( !err_messages.IsEmpty() )
573 wxLogMessage( err_messages );
574
575 if( ( !m_camera_is_moving ) && requested_redraw )
576 {
577 m_mouse_was_moved = false;
578 Request_refresh( false );
579 }
580
582}
583
584
586{
587 m_eventDispatcher = aEventDispatcher;
588}
589
590
591void EDA_3D_CANVAS::OnEvent( wxEvent& aEvent )
592{
593 if( !m_eventDispatcher )
594 aEvent.Skip();
595 else
597
598 Refresh();
599}
600
601
602void EDA_3D_CANVAS::OnEraseBackground( wxEraseEvent& event )
603{
604 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::OnEraseBackground" ) );
605 // Do nothing, to avoid flashing.
606}
607
608
609void EDA_3D_CANVAS::OnMouseWheel( wxMouseEvent& event )
610{
611 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::OnMouseWheel" ) );
612
614
616 {
620 }
621}
622
623
624void EDA_3D_CANVAS::OnMagnify( wxMouseEvent& event )
625{
626 SetFocus();
627
629 return;
630
631 //m_is_moving_mouse = true;
633
634 float magnification = ( event.GetMagnification() + 1.0f );
635
636 m_camera.Zoom( magnification );
637
640}
641
642
643void EDA_3D_CANVAS::OnZoomGesture( wxZoomGestureEvent& aEvent )
644{
645 SetFocus();
646
647 if( aEvent.IsGestureStart() )
648 {
650 m_camera.SetCurMousePosition( aEvent.GetPosition() );
651 }
652
654 return;
655
657
658 m_camera.Pan( aEvent.GetPosition() );
659 m_camera.SetCurMousePosition( aEvent.GetPosition() );
660
661 m_camera.Zoom( aEvent.GetZoomFactor() / m_gestureLastZoomFactor );
662
663 m_gestureLastZoomFactor = aEvent.GetZoomFactor();
664
667}
668
669
670void EDA_3D_CANVAS::OnPanGesture( wxPanGestureEvent& aEvent )
671{
672 SetFocus();
673
674 if( aEvent.IsGestureStart() )
675 m_camera.SetCurMousePosition( aEvent.GetPosition() );
676
678 return;
679
680 m_camera.Pan( aEvent.GetPosition() );
681 m_camera.SetCurMousePosition( aEvent.GetPosition() );
682
685}
686
687
688void EDA_3D_CANVAS::OnRotateGesture( wxRotateGestureEvent& aEvent )
689{
690 SetFocus();
691
692 if( aEvent.IsGestureStart() )
693 {
695 m_camera.SetCurMousePosition( aEvent.GetPosition() );
696
697 // We don't want to process the first angle
698 return;
699 }
700
702 return;
703
704 m_camera.RotateScreen( m_gestureLastAngle - aEvent.GetRotationAngle() );
705 m_gestureLastAngle = aEvent.GetRotationAngle();
706
709}
710
711
712void EDA_3D_CANVAS::OnMouseMove( wxMouseEvent& event )
713{
715 return; // Prevents using invalid m_3d_render_raytracing data
716
718 return;
719
720 OnMouseMoveCamera( event );
721
723 {
726 // *Do not* reactivate the timer here during the mouse move command:
727 // OnMiddleUp() will do it at the end of mouse drag/move command
728 }
729
730 if( !event.Dragging() && m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
731 {
732 STATUSBAR_REPORTER reporter( m_parentStatusBar, EDA_3D_VIEWER_STATUSBAR::HOVERED_ITEM );
734 BOARD_ITEM* rollOverItem = m_3d_render_raytracing->IntersectBoardItem( mouseRay );
735
736 auto printNetInfo =
737 []( BOARD_CONNECTED_ITEM* aItem )
738 {
739 return wxString::Format( _( "Net %s\tNet class %s" ),
740 aItem->GetNet()->GetNetname(),
741 aItem->GetNet()->GetNetClass()->GetName() );
742 };
743
744 if( rollOverItem )
745 {
746 wxString msg;
747
748 if( rollOverItem != m_currentRollOverItem )
749 {
751 m_currentRollOverItem = rollOverItem;
752
754 }
755
756 switch( rollOverItem->Type() )
757 {
758 case PCB_PAD_T:
759 {
760 PAD* pad = static_cast<PAD*>( rollOverItem );
761
762 if( !pad->GetNumber().IsEmpty() )
763 msg += wxString::Format( _( "Pad %s\t" ), pad->GetNumber() );
764
765 if( pad->IsOnCopperLayer() )
766 msg += printNetInfo( pad );
767
768 break;
769 }
770
771 case PCB_FOOTPRINT_T:
772 {
773 FOOTPRINT* footprint = static_cast<FOOTPRINT*>( rollOverItem );
774 msg += footprint->GetReference();
775 break;
776 }
777
778 case PCB_TRACE_T:
779 case PCB_VIA_T:
780 case PCB_ARC_T:
781 {
782 PCB_TRACK* track = static_cast<PCB_TRACK*>( rollOverItem );
783 msg += printNetInfo( track );
784 break;
785 }
786
787 case PCB_ZONE_T:
788 {
789 ZONE* zone = static_cast<ZONE*>( rollOverItem );
790
791 if( !zone->GetZoneName().IsEmpty() )
792 {
793 if( zone->GetIsRuleArea() )
794 msg += wxString::Format( _( "Rule area %s\t" ), zone->GetZoneName() );
795 else
796 msg += wxString::Format( _( "Zone %s\t" ), zone->GetZoneName() );
797 }
798
799 if( zone->IsOnCopperLayer() )
800 msg += printNetInfo( zone );
801
802 break;
803 }
804
805 default:
806 break;
807 }
808
809 reporter.Report( msg );
810 }
811 else
812 {
814 && m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
815 {
818
819 reporter.Report( wxEmptyString );
820 }
821
822 m_currentRollOverItem = nullptr;
823 }
824 }
825}
826
827
828void EDA_3D_CANVAS::OnLeftDown( wxMouseEvent& event )
829{
830 SetFocus();
832
833 if( !event.Dragging() && ( m_3d_render_raytracing != nullptr ) )
834 {
836
837 BOARD_ITEM *intersectedBoardItem = m_3d_render_raytracing->IntersectBoardItem( mouseRay );
838
839 // !TODO: send a selection item to pcbnew, eg: via kiway?
840 }
841}
842
843
844void EDA_3D_CANVAS::OnLeftUp( wxMouseEvent& event )
845{
847 return;
848
850 {
851 m_mouse_is_moving = false;
853 }
854}
855
856
857void EDA_3D_CANVAS::OnMiddleDown( wxMouseEvent& event )
858{
859 SetFocus();
861}
862
863
864void EDA_3D_CANVAS::OnMiddleUp( wxMouseEvent& event )
865{
867 return;
868
870 {
871 m_mouse_is_moving = false;
873 }
874 else
875 {
877 }
878}
879
880
881void EDA_3D_CANVAS::OnTimerTimeout_Editing( wxTimerEvent& aEvent )
882{
883 if( aEvent.GetId() != m_editing_timeout_timer.GetId() )
884 {
885 aEvent.Skip();
886 return;
887 }
888
889 m_mouse_is_moving = false;
890 m_mouse_was_moved = false;
891
893}
894
895
897{
899}
900
901
903{
904 if( m_3d_render )
906}
907
908
909void EDA_3D_CANVAS::OnTimerTimeout_Redraw( wxTimerEvent& aEvent )
910{
911 if( aEvent.GetId() != m_redraw_trigger_timer.GetId() )
912 {
913 aEvent.Skip();
914 return;
915 }
916
917 Request_refresh( true );
918}
919
920
921void EDA_3D_CANVAS::OnRefreshRequest( wxEvent& aEvent )
922{
923 Refresh();
924}
925
926
927void EDA_3D_CANVAS::Request_refresh( bool aRedrawImmediately )
928{
929 if( aRedrawImmediately )
930 {
931 // Just calling Refresh() does not work always
932 // Using an event to call DoRepaint ensure the repaint code will be executed,
933 // and PostEvent will take priority to other events like mouse movements, keys, etc.
934 // and is executed during the next idle time
935 wxCommandEvent redrawEvent( wxEVT_REFRESH_CUSTOM_COMMAND, ID_CUSTOM_EVENT_1 );
936 wxPostEvent( this, redrawEvent );
937 }
938 else
939 {
940 // Schedule a timed redraw
941 m_redraw_trigger_timer.Start( 10 , wxTIMER_ONE_SHOT );
942 }
943}
944
945
946void EDA_3D_CANVAS::request_start_moving_camera( float aMovingSpeed, bool aRenderPivot )
947{
948 wxASSERT( aMovingSpeed > FLT_EPSILON );
949
950 // Fast forward the animation if the animation is disabled
952 {
953 m_camera.Interpolate( 1.0f );
956 return;
957 }
958
959 // Map speed multiplier option to actual multiplier value
960 // [1,2,3,4,5] -> [0.25, 0.5, 1, 2, 4]
961 aMovingSpeed *= ( 1 << m_moving_speed_multiplier ) / 8.0f;
962
963 m_render_pivot = aRenderPivot;
964 m_camera_moving_speed = aMovingSpeed;
965
967
970
971 m_camera_is_moving = true;
972
974}
975
976
978{
980
981 float hit_t;
982
983 // Test it with the board bounding box
984 if( m_boardAdapter.GetBBox().Intersect( mouseRay, &hit_t ) )
985 {
986 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
988 m_camera.SetLookAtPos_T1( mouseRay.at( hit_t ) );
990
992 }
993}
994
995
997{
999 return false;
1000
1001 const float delta_move = m_delta_move_step_factor * m_camera.GetZoom();
1002 const float arrow_moving_time_speed = 8.0f;
1003
1004 switch( aRequestedView )
1005 {
1006 case VIEW3D_TYPE::VIEW3D_PIVOT_CENTER:
1008 return true;
1009
1010 case VIEW3D_TYPE::VIEW3D_PAN_LEFT:
1011 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
1013 m_camera.Pan_T1( SFVEC3F( -delta_move, 0.0f, 0.0f ) );
1014 request_start_moving_camera( arrow_moving_time_speed, false );
1015 return true;
1016
1017 case VIEW3D_TYPE::VIEW3D_PAN_RIGHT:
1018 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
1020 m_camera.Pan_T1( SFVEC3F( +delta_move, 0.0f, 0.0f ) );
1021 request_start_moving_camera( arrow_moving_time_speed, false );
1022 return true;
1023
1024 case VIEW3D_TYPE::VIEW3D_PAN_UP:
1025 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
1027 m_camera.Pan_T1( SFVEC3F( 0.0f, +delta_move, 0.0f ) );
1028 request_start_moving_camera( arrow_moving_time_speed, false );
1029 return true;
1030
1031 case VIEW3D_TYPE::VIEW3D_PAN_DOWN:
1032 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
1034 m_camera.Pan_T1( SFVEC3F( 0.0f, -delta_move, 0.0f ) );
1035 request_start_moving_camera( arrow_moving_time_speed, false );
1036 return true;
1037
1038 case VIEW3D_TYPE::VIEW3D_FIT_SCREEN:
1039 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
1042 request_start_moving_camera( glm::min( glm::max( m_camera.GetZoom(), 1 / 1.26f ), 1.26f ) );
1043 return true;
1044
1045 case VIEW3D_TYPE::VIEW3D_ZOOM_IN:
1046 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
1048
1049 if( m_camera.Zoom_T1( 1.26f ) ) // 3 steps per doubling
1051
1052 return true;
1053
1054 case VIEW3D_TYPE::VIEW3D_ZOOM_OUT:
1055 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
1057
1058 if( m_camera.Zoom_T1( 1/1.26f ) ) // 3 steps per halving
1060
1061 return true;
1062
1063 case VIEW3D_TYPE::VIEW3D_RIGHT:
1064 case VIEW3D_TYPE::VIEW3D_LEFT:
1065 case VIEW3D_TYPE::VIEW3D_FRONT:
1066 case VIEW3D_TYPE::VIEW3D_BACK:
1067 case VIEW3D_TYPE::VIEW3D_FLIP:
1068 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
1070 m_camera.ViewCommand_T1( aRequestedView );
1072 return true;
1073
1074 case VIEW3D_TYPE::VIEW3D_TOP:
1075 case VIEW3D_TYPE::VIEW3D_BOTTOM:
1076 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
1078 m_camera.ViewCommand_T1( aRequestedView );
1079 request_start_moving_camera( glm::min( glm::max( m_camera.GetZoom(), 0.5f ), 1.125f ) );
1080 return true;
1081
1082 default:
1083 return false;
1084 }
1085}
1086
1087
1089{
1092
1093 switch( cfg->m_Render.engine )
1094 {
1095 case RENDER_ENGINE::OPENGL: m_3d_render = m_3d_render_opengl; break;
1096 case RENDER_ENGINE::RAYTRACING: m_3d_render = m_3d_render_raytracing; break;
1097 default: m_3d_render = nullptr; break;
1098 }
1099
1100 if( m_3d_render )
1102
1103 m_mouse_was_moved = false;
1104
1106}
1107
1108
1110{
1111 SFVEC3F rayOrigin;
1112 SFVEC3F rayDir;
1113
1114 // Generate a ray origin and direction based on current mouser position and camera
1115 m_camera.MakeRayAtCurrentMousePosition( rayOrigin, rayDir );
1116
1117 RAY mouseRay;
1118 mouseRay.Init( rayOrigin, rayDir );
1119
1120 return mouseRay;
1121}
VIEW3D_TYPE
Definition: 3d_enums.h:78
@ ID_CUSTOM_EVENT_1
Definition: 3d_viewer_id.h:53
@ ID_DISABLE_RAY_TRACING
Definition: 3d_viewer_id.h:51
void SetOpenGLInfo(const char *aVendor, const char *aRenderer, const char *aVersion)
A setter for OpenGL info when it's initialized.
Helper class to handle information needed to display 3D board.
Definition: board_adapter.h:73
const BBOX_3D & GetBBox() const noexcept
Get the board outling bounding box.
void ReloadColorSettings() noexcept
void SetBoard(BOARD *aBoard) noexcept
Set current board to be rendered.
EDA_3D_VIEWER_SETTINGS * m_Cfg
bool m_MousewheelPanning
void Set3dCacheManager(S3D_CACHE *aCacheMgr) noexcept
Update the cache manager pointer.
Definition: board_adapter.h:84
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:79
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:289
A class used to derive camera objects from.
Definition: camera.h:103
bool Zoom(float aFactor)
Definition: camera.cpp:597
virtual void Pan(const wxPoint &aNewMousePosition)=0
void RotateScreen(float aAngleInRadians)
Rotates the camera in screen plane.
Definition: camera.cpp:650
bool Zoom_T1(float aFactor)
Definition: camera.cpp:628
virtual void Reset_T1()
Definition: camera.cpp:161
virtual void Pan_T1(const SFVEC3F &aDeltaOffsetInc)=0
virtual void Interpolate(float t)
It will update the matrix to interpolate between T0 and T1 values.
Definition: camera.cpp:711
bool SetCurWindowSize(const wxSize &aSize)
Update the windows size of the camera.
Definition: camera.cpp:570
void SetInterpolateMode(CAMERA_INTERPOLATION aInterpolateMode)
Definition: camera.h:264
float GetZoom() const
Definition: camera.h:221
void ResetXYpos_T1()
Definition: camera.cpp:502
bool ViewCommand_T1(VIEW3D_TYPE aRequestedView)
Definition: camera.cpp:110
virtual void SetT0_and_T1_current_T()
This will set T0 and T1 with the current values.
Definition: camera.cpp:697
void MakeRayAtCurrentMousePosition(SFVEC3F &aOutOrigin, SFVEC3F &aOutDirection) const
Make a ray based on the latest mouse position.
Definition: camera.cpp:461
void SetLookAtPos_T1(const SFVEC3F &aLookAtPos)
Definition: camera.h:162
const SFVEC3F & GetCameraPos() const
Definition: camera.h:169
bool ParametersChanged()
Definition: camera.cpp:729
void SetCurMousePosition(const wxPoint &aPosition)
Update the current mouse position without make any new calculations on camera.
Definition: camera.cpp:553
Implement a canvas based on a wxGLCanvas.
Definition: eda_3d_canvas.h:49
RENDER_3D_OPENGL * m_3d_render_opengl
TOOL_DISPATCHER * m_eventDispatcher
void OnEvent(wxEvent &aEvent)
Used to forward events to the canvas from popups, etc.
void OnMagnify(wxMouseEvent &event)
void restart_editingTimeOut_Timer()
Reset the editing timer.
BOARD_ITEM * m_currentRollOverItem
RENDER_3D_BASE * m_3d_render
bool m_is_opengl_initialized
void OnResize(wxSizeEvent &event)
bool m_render3dmousePivot
void OnMouseWheel(wxMouseEvent &event)
WX_INFOBAR * m_parentInfoBar
wxTimer m_editing_timeout_timer
int64_t m_strtime_camera_movement
void OnLeftDown(wxMouseEvent &event)
void OnPanGesture(wxPanGestureEvent &event)
wxGLContext * m_glRC
bool initializeOpenGL()
ACCELERATOR_3D * m_accelerator3DShapes
void OnTimerTimeout_Redraw(wxTimerEvent &event)
wxStatusBar * m_parentStatusBar
void DoRePaint()
The actual function to repaint the canvas.
int m_moving_speed_multiplier
bool m_is_opengl_version_supported
wxTimer m_redraw_trigger_timer
BOARD_ADAPTER & m_boardAdapter
void DisplayStatus()
Update the status bar with the position information.
void render3dmousePivot(float aScale)
Render the 3dmouse pivot cursor.
void OnPaint(wxPaintEvent &aEvent)
void RenderRaytracingRequest()
Request to render the current view in Raytracing mode.
void SetEventDispatcher(TOOL_DISPATCHER *aEventDispatcher)
Set a dispatcher that processes events and forwards them to tools.
bool m_render_raytracing_was_requested
float m_camera_moving_speed
bool m_animation_enabled
void OnLeftUp(wxMouseEvent &event)
void ReloadRequest(BOARD *aBoard=nullptr, S3D_CACHE *aCachePointer=nullptr)
RAY getRayAtCurrentMousePosition()
double m_gestureLastZoomFactor
< Used to track gesture events.
void OnCloseWindow(wxCloseEvent &event)
bool SetView3D(VIEW3D_TYPE aRequestedView)
Select a specific 3D view or operation.
void OnMiddleDown(wxMouseEvent &event)
void GetScreenshot(wxImage &aDstImage)
Request a screenshot and output it to the aDstImage.
RENDER_3D_RAYTRACE_GL * m_3d_render_raytracing
void OnZoomGesture(wxZoomGestureEvent &event)
void OnMiddleUp(wxMouseEvent &event)
void render_pivot(float t, float aScale)
Render the pivot cursor.
void request_start_moving_camera(float aMovingSpeed=2.0f, bool aRenderPivot=true)
Start a camera movement.
void RenderEngineChanged()
Notify that the render engine was changed.
std::atomic_flag m_is_currently_painting
void OnRefreshRequest(wxEvent &aEvent)
void OnEraseBackground(wxEraseEvent &event)
void releaseOpenGL()
Free created targets and openGL context.
void Request_refresh(bool aRedrawImmediately=true)
Schedule a refresh update of the canvas.
bool m_opengl_supports_raytracing
void OnMouseMove(wxMouseEvent &event)
void OnRotateGesture(wxRotateGestureEvent &event)
void move_pivot_based_on_cur_mouse_position()
This function hits a ray to the board and start a movement.
double m_gestureLastAngle
void OnTimerTimeout_Editing(wxTimerEvent &event)
void stop_editingTimeOut_Timer()
Stop the editing time so it will not timeout.
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:101
const wxString & GetReference() const
Definition: footprint.h:591
void UnlockCtx(wxGLContext *aContext)
Allow other canvases to bind an OpenGL context.
void DestroyCtx(wxGLContext *aContext)
Destroy a managed OpenGL context.
void LockCtx(wxGLContext *aContext, wxGLCanvas *aCanvas)
Set a context as current and prevents other canvases from switching it.
static GL_CONTEXT_MANAGER & Get()
Return the GL_CONTEXT_MANAGER instance (singleton).
wxGLContext * CreateCtx(wxGLCanvas *aCanvas, const wxGLContext *aOther=nullptr)
Create a managed OpenGL context.
static int SetSwapInterval(int aVal)
Attempts to set the OpenGL swap interval.
Definition: gl_utils.h:49
Provides basic 3D controls ( zoom, rotate, translate, ... )
static const float m_delta_move_step_factor
void OnMouseWheelCamera(wxMouseEvent &event, bool aPan)
void OnMouseMoveCamera(wxMouseEvent &event)
virtual wxSize GetNativePixelSize() const
A wrapper for reporting to a WX_INFOBAR UI element.
Definition: reporter.h:338
void Finalize()
Update the infobar with the reported text.
Definition: reporter.cpp:262
REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED) override
Report a string with a given severity.
Definition: reporter.cpp:246
Definition: pad.h:54
virtual SETTINGS_MANAGER & GetSettingsManager() const
Definition: pgm_base.h:142
virtual bool Redraw(bool aIsMoving, REPORTER *aStatusReporter=nullptr, REPORTER *aWarningReporter=nullptr)=0
Redraw the view.
virtual int GetWaitForEditingTimeOut()=0
Give the interface the time (in ms) that it should wait for editing or movements before (this works f...
void ReloadRequest()
virtual void SetCurWindowSize(const wxSize &aSize)=0
Before each render, the canvas will tell the render what is the size of its windows,...
bool IsReloadRequestPending() const
Query if there is a pending reload request.
Object to render the board using openGL.
void SetCurrentRollOverItem(BOARD_ITEM *aRollOverItem)
void Reload(REPORTER *aStatusReporter, REPORTER *aWarningReporter, bool aOnlyLoadCopperAndShapes)
BOARD_ITEM * IntersectBoardItem(const RAY &aRay)
Cache for storing the 3D shapes.
Definition: 3d_cache.h:54
T * GetAppSettings()
Returns a handle to the a given settings by type If the settings have already been loaded,...
A wrapper for reporting to a specific text location in a statusbar.
Definition: reporter.h:309
REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED) override
Report a string with a given severity.
Definition: reporter.cpp:223
virtual void DispatchWxEvent(wxEvent &aEvent)
Process wxEvents (mostly UI events), translate them to TOOL_EVENTs, and make tools handle those.
Handle a list of polygons defining a copper zone.
Definition: zone.h:73
bool GetIsRuleArea() const
Accessors to parameters used in Rule Area zones:
Definition: zone.h:711
const wxString & GetZoneName() const
Definition: zone.h:132
bool IsOnCopperLayer() const override
Definition: zone.cpp:257
#define _(s)
wxDEFINE_EVENT(wxEVT_REFRESH_CUSTOM_COMMAND, wxEvent)
Declaration of the eda_3d_viewer class.
static const wxChar * m_logTrace
Trace mask used to enable or disable the trace output of this class.
This file contains miscellaneous commonly used macros and functions.
void OglGetScreenshot(wxImage &aDstImage)
Get the pixel data of current OpenGL image.
Definition: ogl_utils.cpp:37
void Refresh()
Update the board display after modifying it by a python script (note: it is automatically called by a...
PGM_BASE & Pgm()
The global Program "get" accessor.
Definition: pgm_base.cpp:1059
see class PGM_BASE
int64_t GetRunningMicroSecs()
An alternate way to calculate an elapsed time (in microsecondes) to class PROF_COUNTER.
@ RPT_SEVERITY_ERROR
const int scale
wxString From_UTF8(const char *cstring)
bool Intersect(const RAY &aRay, float *t) const
Definition: bbox_3d_ray.cpp:46
Definition: ray.h:63
void Init(const SFVEC3F &o, const SFVEC3F &d)
Definition: ray.cpp:35
SFVEC3F at(float t) const
Definition: ray.h:84
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:97
@ PCB_ZONE_T
class ZONE, a copper pour area
Definition: typeinfo.h:107
@ PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
Definition: typeinfo.h:86
@ PCB_PAD_T
class PAD, a pad in a footprint
Definition: typeinfo.h:87
@ PCB_ARC_T
class PCB_ARC, an arc track segment on a copper layer
Definition: typeinfo.h:98
@ PCB_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:96
glm::vec3 SFVEC3F
Definition: xv3d_types.h:44