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 // other events
77 EVT_ERASE_BACKGROUND( EDA_3D_CANVAS::OnEraseBackground )
78 EVT_CUSTOM(wxEVT_REFRESH_CUSTOM_COMMAND, ID_CUSTOM_EVENT_1, EDA_3D_CANVAS::OnRefreshRequest )
79
81 EVT_SIZE( EDA_3D_CANVAS::OnResize )
82END_EVENT_TABLE()
83
84
85EDA_3D_CANVAS::EDA_3D_CANVAS( wxWindow* aParent, const wxGLAttributes& aGLAttribs,
86 BOARD_ADAPTER& aBoardAdapter, CAMERA& aCamera,
87 S3D_CACHE* a3DCachePointer ) :
88 HIDPI_GL_3D_CANVAS( EDA_DRAW_PANEL_GAL::GetVcSettings(), aCamera, aParent, aGLAttribs,
89 wxID_ANY, wxDefaultPosition,
90 wxDefaultSize, wxFULL_REPAINT_ON_RESIZE ),
91 m_eventDispatcher( nullptr ),
92 m_parentStatusBar( nullptr ),
93 m_parentInfoBar( nullptr ),
94 m_glRC( nullptr ),
95 m_is_opengl_initialized( false ),
96 m_is_opengl_version_supported( true ),
97 m_editing_timeout_timer( this, wxID_HIGHEST + 1 ),
98 m_redraw_trigger_timer( this, wxID_HIGHEST + 2 ),
99 m_render_pivot( false ),
100 m_camera_moving_speed( 1.0f ),
101 m_strtime_camera_movement( 0 ),
102 m_animation_enabled( true ),
103 m_moving_speed_multiplier( 3 ),
104 m_boardAdapter( aBoardAdapter ),
105 m_3d_render( nullptr ),
106 m_opengl_supports_raytracing( true ),
107 m_render_raytracing_was_requested( false ),
108 m_accelerator3DShapes( nullptr ),
109 m_currentRollOverItem( nullptr )
110{
111 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::EDA_3D_CANVAS" ) );
112
113 m_editing_timeout_timer.SetOwner( this );
114 Connect( m_editing_timeout_timer.GetId(), wxEVT_TIMER,
115 wxTimerEventHandler( EDA_3D_CANVAS::OnTimerTimeout_Editing ), nullptr, this );
116
117 m_redraw_trigger_timer.SetOwner( this );
118 Connect( m_redraw_trigger_timer.GetId(), wxEVT_TIMER,
119 wxTimerEventHandler( EDA_3D_CANVAS::OnTimerTimeout_Redraw ), nullptr, this );
120
121 m_is_currently_painting.clear();
122
123 m_3d_render_raytracing = new RENDER_3D_RAYTRACE_GL( this, m_boardAdapter, m_camera );
124 m_3d_render_opengl = new RENDER_3D_OPENGL( this, m_boardAdapter, m_camera );
125
126 wxASSERT( m_3d_render_raytracing != nullptr );
127 wxASSERT( m_3d_render_opengl != nullptr );
128
129 auto busy_indicator_factory =
130 []()
131 {
132 return std::make_unique<WX_BUSY_INDICATOR>();
133 };
134
135 m_3d_render_raytracing->SetBusyIndicatorFactory( busy_indicator_factory );
136 m_3d_render_opengl->SetBusyIndicatorFactory( busy_indicator_factory );
137
138 // We always start with the opengl engine (raytracing is avoided due to very
139 // long calculation time)
140 m_3d_render = m_3d_render_opengl;
141
142 m_boardAdapter.ReloadColorSettings();
143
144 wxASSERT( a3DCachePointer != nullptr );
145 m_boardAdapter.Set3dCacheManager( a3DCachePointer );
146
147 const wxEventType events[] =
148 {
149 // Binding both EVT_CHAR and EVT_CHAR_HOOK ensures that all key events,
150 // especially special key like arrow keys, are handled by the GAL event dispatcher,
151 // and not sent to GUI without filtering, because they have a default action (scroll)
152 // that must not be called.
153 wxEVT_LEFT_UP, wxEVT_LEFT_DOWN, wxEVT_LEFT_DCLICK,
154 wxEVT_RIGHT_UP, wxEVT_RIGHT_DOWN, wxEVT_RIGHT_DCLICK,
155 wxEVT_MIDDLE_UP, wxEVT_MIDDLE_DOWN, wxEVT_MIDDLE_DCLICK,
156 wxEVT_MOTION, wxEVT_MOUSEWHEEL, wxEVT_CHAR, wxEVT_CHAR_HOOK,
157 wxEVT_MAGNIFY,
158 wxEVT_MENU_OPEN, wxEVT_MENU_CLOSE, wxEVT_MENU_HIGHLIGHT
159 };
160
161 for( wxEventType eventType : events )
162 Connect( eventType, wxEventHandler( EDA_3D_CANVAS::OnEvent ), nullptr, m_eventDispatcher );
163}
164
165
167{
168 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::~EDA_3D_CANVAS" ) );
169
171 m_accelerator3DShapes = nullptr;
172
174}
175
176
178{
179 if( m_glRC )
180 {
182
184 m_3d_render_raytracing = nullptr;
185
186 delete m_3d_render_opengl;
187 m_3d_render_opengl = nullptr;
188
189 // This is just a copy of a pointer, can safely be set to NULL.
190 m_3d_render = nullptr;
191
194 m_glRC = nullptr;
195 }
196}
197
198
199void EDA_3D_CANVAS::OnCloseWindow( wxCloseEvent& event )
200{
202
203 event.Skip();
204}
205
206
207void EDA_3D_CANVAS::OnResize( wxSizeEvent& event )
208{
210}
211
212
214{
215 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::initializeOpenGL" ) );
216
217 const GLenum err = glewInit();
218
219 if( GLEW_OK != err )
220 {
221 const wxString msgError = (const char*) glewGetErrorString( err );
222
223 wxLogMessage( msgError );
224
225 return false;
226 }
227 else
228 {
229 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::initializeOpenGL Using GLEW version %s" ),
230 From_UTF8( (char*) glewGetString( GLEW_VERSION ) ) );
231 }
232
233 SetOpenGLInfo( (const char*) glGetString( GL_VENDOR ), (const char*) glGetString( GL_RENDERER ),
234 (const char*) glGetString( GL_VERSION ) );
235
236 wxString version = From_UTF8( (char *) glGetString( GL_VERSION ) );
237
238 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::%s OpenGL version string %s." ),
239 __WXFUNCTION__, version );
240
241 // Extract OpenGL version from string. This method is used because prior to OpenGL 2,
242 // getting the OpenGL major and minor version as integers didn't exist.
243 wxString tmp;
244
245 wxStringTokenizer tokenizer( version );
246
247 if( tokenizer.HasMoreTokens() )
248 {
249 long major = 0;
250 long minor = 0;
251
252 tmp = tokenizer.GetNextToken();
253
254 tokenizer.SetString( tmp, wxString( wxT( "." ) ) );
255
256 if( tokenizer.HasMoreTokens() )
257 tokenizer.GetNextToken().ToLong( &major );
258
259 if( tokenizer.HasMoreTokens() )
260 tokenizer.GetNextToken().ToLong( &minor );
261
262 if( major < 2 || ( ( major == 2 ) && ( minor < 1 ) ) )
263 {
264 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::%s OpenGL ray tracing not supported." ),
265 __WXFUNCTION__ );
266
267 if( GetParent() )
268 {
269 wxCommandEvent evt( wxEVT_MENU, ID_DISABLE_RAY_TRACING );
270 GetParent()->ProcessWindowEvent( evt );
271 }
272
274 }
275
276 if( ( major == 1 ) && ( minor < 5 ) )
277 {
278 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::%s OpenGL not supported." ),
279 __WXFUNCTION__ );
280
282 }
283 }
284
287
288 return true;
289}
290
291
292void EDA_3D_CANVAS::GetScreenshot( wxImage& aDstImage )
293{
294 OglGetScreenshot( aDstImage );
295}
296
297
298void EDA_3D_CANVAS::ReloadRequest( BOARD* aBoard , S3D_CACHE* aCachePointer )
299{
300 if( aCachePointer != nullptr )
301 m_boardAdapter.Set3dCacheManager( aCachePointer );
302
303 if( aBoard != nullptr )
304 m_boardAdapter.SetBoard( aBoard );
305
307
308 if( m_3d_render )
310}
311
312
314{
316
317 if( m_3d_render )
319
321
323}
324
325
327{
329 {
330 wxString msg;
331
332 msg.Printf( wxT( "dx %3.2f" ), m_camera.GetCameraPos().x );
333 m_parentStatusBar->SetStatusText( msg, static_cast<int>( EDA_3D_VIEWER_STATUSBAR::X_POS ) );
334
335 msg.Printf( wxT( "dy %3.2f" ), m_camera.GetCameraPos().y );
336 m_parentStatusBar->SetStatusText( msg, static_cast<int>( EDA_3D_VIEWER_STATUSBAR::Y_POS ) );
337
338 msg.Printf( wxT( "zoom %3.2f" ), 1 / m_camera.GetZoom() );
339 m_parentStatusBar->SetStatusText( msg, static_cast<int>( EDA_3D_VIEWER_STATUSBAR::ZOOM_LEVEL ) );
340 }
341}
342
343
344void EDA_3D_CANVAS::OnPaint( wxPaintEvent& aEvent )
345{
346 // Please have a look at: https://lists.launchpad.net/kicad-developers/msg25149.html
347 DoRePaint();
348}
349
350
352{
353 if( m_is_currently_painting.test_and_set() )
354 return;
355
356 // SwapBuffer requires the window to be shown before calling
357 if( !IsShownOnScreen() )
358 {
359 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::DoRePaint !IsShown" ) );
361 return;
362 }
363
364 // Because the board to draw is handled by the parent viewer frame,
365 // ensure this parent is still alive. When it is closed before the viewer
366 // frame, a paint event can be generated after the parent is closed,
367 // therefore with invalid board.
368 // This is dependent of the platform.
369 // Especially on OSX, but also on Windows, it frequently happens
370 if( !GetParent()->GetParent()->IsShownOnScreen() )
371 return; // The parent board editor frame is no more alive
372
373 wxString err_messages;
374 INFOBAR_REPORTER warningReporter( m_parentInfoBar );
375 STATUSBAR_REPORTER activityReporter( m_parentStatusBar, EDA_3D_VIEWER_STATUSBAR::ACTIVITY );
376 int64_t start_time = GetRunningMicroSecs();
377
378 // "Makes the OpenGL state that is represented by the OpenGL rendering
379 // context context current, i.e. it will be used by all subsequent OpenGL calls.
380 // This function may only be called when the window is shown on screen"
381
382 // Explicitly create a new rendering context instance for this canvas.
383 if( m_glRC == nullptr )
385
386 // CreateCtx could and does fail per sentry crash events, lets be graceful
387 if( m_glRC == nullptr )
388 {
389 warningReporter.Report( _( "OpenGL context creation error" ), RPT_SEVERITY_ERROR );
390 warningReporter.Finalize();
392 return;
393 }
394
396
397 // Set the OpenGL viewport according to the client size of this canvas.
398 // This is done here rather than in a wxSizeEvent handler because our
399 // OpenGL rendering context (and thus viewport setting) is used with
400 // multiple canvases: If we updated the viewport in the wxSizeEvent
401 // handler, changing the size of one canvas causes a viewport setting that
402 // is wrong when next another canvas is repainted.
403 wxSize clientSize = GetNativePixelSize();
404
405 const bool windows_size_changed = m_camera.SetCurWindowSize( clientSize );
406
407 // Initialize openGL if need
409 {
410 if( !initializeOpenGL() )
411 {
414
415 return;
416 }
417
419 {
420 warningReporter.Report( _( "Your OpenGL version is not supported. Minimum required "
421 "is 1.5." ), RPT_SEVERITY_ERROR );
422
423 warningReporter.Finalize();
424 }
425 }
426
428 {
429 glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
430 glClear( GL_COLOR_BUFFER_BIT );
431
432 SwapBuffers();
433
436
437 return;
438 }
439
440 // Don't attend to ray trace if OpenGL doesn't support it.
442 {
445 m_boardAdapter.m_Cfg->m_Render.engine = RENDER_ENGINE::OPENGL;
446 }
447
448 // Check if a raytacing was requested and need to switch to raytracing mode
449 if( m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
450 {
451 const bool was_camera_changed = m_camera.ParametersChanged();
452
453 // It reverts back to OpenGL mode if it was requested a raytracing
454 // render of the current scene. AND the mouse / camera is moving
455 if( ( m_mouse_is_moving || m_camera_is_moving || was_camera_changed
456 || windows_size_changed )
458 {
461 }
462 }
463
464 float curtime_delta_s = 0.0f;
465
467 {
468 const int64_t curtime_delta = GetRunningMicroSecs() - m_strtime_camera_movement;
469 curtime_delta_s = (curtime_delta / 1e6) * m_camera_moving_speed;
470 m_camera.Interpolate( curtime_delta_s );
471
472 if( curtime_delta_s > 1.0f )
473 {
474 m_render_pivot = false;
475 m_camera_is_moving = false;
476 m_mouse_was_moved = true;
477
480 }
481 else
482 {
484 }
485 }
486
487 // It will return true if the render request a new redraw
488 bool requested_redraw = false;
489
490 if( m_3d_render )
491 {
492 try
493 {
494 m_3d_render->SetCurWindowSize( clientSize );
495
496 bool reloadRaytracingForCalculations = false;
497
498 if( m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL
500 {
501 reloadRaytracingForCalculations = true;
502 }
503
505 &activityReporter, &warningReporter );
506
507 // Raytracer renderer is responsible for some features also used by the OpenGL
508 // renderer.
509 // FIXME: Presumably because raytracing renderer reload is called only after current
510 // renderer redraw, the old zoom value stays for a single frame. This is ugly, but only
511 // cosmetic, so I'm not fixing that for now: I don't know how to do this without
512 // reloading twice (maybe it's not too bad of an idea?) or doing a complicated
513 // refactor.
514 if( reloadRaytracingForCalculations )
515 m_3d_render_raytracing->Reload( nullptr, nullptr, true );
516 }
517 catch( std::runtime_error& )
518 {
524 return;
525 }
526 }
527
528 if( m_render_pivot )
529 {
530 const float scale = glm::min( m_camera.GetZoom(), 1.0f );
531 render_pivot( curtime_delta_s, scale );
532 }
533
534 // This will only be enabled by the 3d mouse plugin, so we can leave
535 // it as a simple if statement
537 {
538 const float scale = glm::min( m_camera.GetZoom(), 1.0f );
540 }
541
542 // "Swaps the double-buffer of this window, making the back-buffer the
543 // front-buffer and vice versa, so that the output of the previous OpenGL
544 // commands is displayed on the window."
545 SwapBuffers();
546
548
550 {
551 // Calculation time in milliseconds
552 const double calculation_time = (double)( GetRunningMicroSecs() - start_time ) / 1e3;
553
554 activityReporter.Report( wxString::Format( _( "Last render time %.0f ms" ),
555 calculation_time ) );
556 }
557
558 // This will reset the flag of camera parameters changed
560
561 warningReporter.Finalize();
562
563 if( !err_messages.IsEmpty() )
564 wxLogMessage( err_messages );
565
566 if( ( !m_camera_is_moving ) && requested_redraw )
567 {
568 m_mouse_was_moved = false;
569 Request_refresh( false );
570 }
571
573}
574
575
577{
578 m_eventDispatcher = aEventDispatcher;
579}
580
581
582void EDA_3D_CANVAS::OnEvent( wxEvent& aEvent )
583{
584 if( !m_eventDispatcher )
585 aEvent.Skip();
586 else
588
589 Refresh();
590}
591
592
593void EDA_3D_CANVAS::OnEraseBackground( wxEraseEvent& event )
594{
595 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::OnEraseBackground" ) );
596 // Do nothing, to avoid flashing.
597}
598
599
600void EDA_3D_CANVAS::OnMouseWheel( wxMouseEvent& event )
601{
602 wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::OnMouseWheel" ) );
603
605
607 {
611 }
612}
613
614
615void EDA_3D_CANVAS::OnMagnify( wxMouseEvent& event )
616{
617 SetFocus();
618
620 return;
621
622 //m_is_moving_mouse = true;
624
625 float magnification = ( event.GetMagnification() + 1.0f );
626
627 m_camera.Zoom( magnification );
628
631}
632
633
634void EDA_3D_CANVAS::OnMouseMove( wxMouseEvent& event )
635{
637 return; // Prevents using invalid m_3d_render_raytracing data
638
640 return;
641
642 OnMouseMoveCamera( event );
643
645 {
648 // *Do not* reactivate the timer here during the mouse move command:
649 // OnMiddleUp() will do it at the end of mouse drag/move command
650 }
651
652 if( !event.Dragging() && m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
653 {
654 STATUSBAR_REPORTER reporter( m_parentStatusBar, EDA_3D_VIEWER_STATUSBAR::HOVERED_ITEM );
656 BOARD_ITEM* rollOverItem = m_3d_render_raytracing->IntersectBoardItem( mouseRay );
657
658 auto printNetInfo =
659 []( BOARD_CONNECTED_ITEM* aItem )
660 {
661 return wxString::Format( _( "Net %s\tNet class %s" ),
662 aItem->GetNet()->GetNetname(),
663 aItem->GetNet()->GetNetClass()->GetName() );
664 };
665
666 if( rollOverItem )
667 {
668 wxString msg;
669
670 if( rollOverItem != m_currentRollOverItem )
671 {
673 m_currentRollOverItem = rollOverItem;
674
676 }
677
678 switch( rollOverItem->Type() )
679 {
680 case PCB_PAD_T:
681 {
682 PAD* pad = static_cast<PAD*>( rollOverItem );
683
684 if( !pad->GetNumber().IsEmpty() )
685 msg += wxString::Format( _( "Pad %s\t" ), pad->GetNumber() );
686
687 if( pad->IsOnCopperLayer() )
688 msg += printNetInfo( pad );
689
690 break;
691 }
692
693 case PCB_FOOTPRINT_T:
694 {
695 FOOTPRINT* footprint = static_cast<FOOTPRINT*>( rollOverItem );
696 msg += footprint->GetReference();
697 break;
698 }
699
700 case PCB_TRACE_T:
701 case PCB_VIA_T:
702 case PCB_ARC_T:
703 {
704 PCB_TRACK* track = static_cast<PCB_TRACK*>( rollOverItem );
705 msg += printNetInfo( track );
706 break;
707 }
708
709 case PCB_ZONE_T:
710 {
711 ZONE* zone = static_cast<ZONE*>( rollOverItem );
712
713 if( !zone->GetZoneName().IsEmpty() )
714 {
715 if( zone->GetIsRuleArea() )
716 msg += wxString::Format( _( "Rule area %s\t" ), zone->GetZoneName() );
717 else
718 msg += wxString::Format( _( "Zone %s\t" ), zone->GetZoneName() );
719 }
720
721 if( zone->IsOnCopperLayer() )
722 msg += printNetInfo( zone );
723
724 break;
725 }
726
727 default:
728 break;
729 }
730
731 reporter.Report( msg );
732 }
733 else
734 {
736 && m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
737 {
740
741 reporter.Report( wxEmptyString );
742 }
743
744 m_currentRollOverItem = nullptr;
745 }
746 }
747}
748
749
750void EDA_3D_CANVAS::OnLeftDown( wxMouseEvent& event )
751{
752 SetFocus();
754
755 if( !event.Dragging() && ( m_3d_render_raytracing != nullptr ) )
756 {
758
759 BOARD_ITEM *intersectedBoardItem = m_3d_render_raytracing->IntersectBoardItem( mouseRay );
760
761 // !TODO: send a selection item to pcbnew, eg: via kiway?
762 }
763}
764
765
766void EDA_3D_CANVAS::OnLeftUp( wxMouseEvent& event )
767{
769 return;
770
772 {
773 m_mouse_is_moving = false;
775 }
776}
777
778
779void EDA_3D_CANVAS::OnMiddleDown( wxMouseEvent& event )
780{
781 SetFocus();
783}
784
785
786void EDA_3D_CANVAS::OnMiddleUp( wxMouseEvent& event )
787{
789 return;
790
792 {
793 m_mouse_is_moving = false;
795 }
796 else
797 {
799 }
800}
801
802
803void EDA_3D_CANVAS::OnTimerTimeout_Editing( wxTimerEvent& aEvent )
804{
805 if( aEvent.GetId() != m_editing_timeout_timer.GetId() )
806 {
807 aEvent.Skip();
808 return;
809 }
810
811 m_mouse_is_moving = false;
812 m_mouse_was_moved = false;
813
815}
816
817
819{
821}
822
823
825{
826 if( m_3d_render )
828}
829
830
831void EDA_3D_CANVAS::OnTimerTimeout_Redraw( wxTimerEvent& aEvent )
832{
833 if( aEvent.GetId() != m_redraw_trigger_timer.GetId() )
834 {
835 aEvent.Skip();
836 return;
837 }
838
839 Request_refresh( true );
840}
841
842
843void EDA_3D_CANVAS::OnRefreshRequest( wxEvent& aEvent )
844{
845 Refresh();
846}
847
848
849void EDA_3D_CANVAS::Request_refresh( bool aRedrawImmediately )
850{
851 if( aRedrawImmediately )
852 {
853 // Just calling Refresh() does not work always
854 // Using an event to call DoRepaint ensure the repaint code will be executed,
855 // and PostEvent will take priority to other events like mouse movements, keys, etc.
856 // and is executed during the next idle time
857 wxCommandEvent redrawEvent( wxEVT_REFRESH_CUSTOM_COMMAND, ID_CUSTOM_EVENT_1 );
858 wxPostEvent( this, redrawEvent );
859 }
860 else
861 {
862 // Schedule a timed redraw
863 m_redraw_trigger_timer.Start( 10 , wxTIMER_ONE_SHOT );
864 }
865}
866
867
868void EDA_3D_CANVAS::request_start_moving_camera( float aMovingSpeed, bool aRenderPivot )
869{
870 wxASSERT( aMovingSpeed > FLT_EPSILON );
871
872 // Fast forward the animation if the animation is disabled
874 {
875 m_camera.Interpolate( 1.0f );
878 return;
879 }
880
881 // Map speed multiplier option to actual multiplier value
882 // [1,2,3,4,5] -> [0.25, 0.5, 1, 2, 4]
883 aMovingSpeed *= ( 1 << m_moving_speed_multiplier ) / 8.0f;
884
885 m_render_pivot = aRenderPivot;
886 m_camera_moving_speed = aMovingSpeed;
887
889
892
893 m_camera_is_moving = true;
894
896}
897
898
900{
902
903 float hit_t;
904
905 // Test it with the board bounding box
906 if( m_boardAdapter.GetBBox().Intersect( mouseRay, &hit_t ) )
907 {
908 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
910 m_camera.SetLookAtPos_T1( mouseRay.at( hit_t ) );
912
914 }
915}
916
917
919{
921 return false;
922
923 const float delta_move = m_delta_move_step_factor * m_camera.GetZoom();
924 const float arrow_moving_time_speed = 8.0f;
925
926 switch( aRequestedView )
927 {
928 case VIEW3D_TYPE::VIEW3D_PIVOT_CENTER:
930 return true;
931
932 case VIEW3D_TYPE::VIEW3D_PAN_LEFT:
933 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
935 m_camera.Pan_T1( SFVEC3F( -delta_move, 0.0f, 0.0f ) );
936 request_start_moving_camera( arrow_moving_time_speed, false );
937 return true;
938
939 case VIEW3D_TYPE::VIEW3D_PAN_RIGHT:
940 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
942 m_camera.Pan_T1( SFVEC3F( +delta_move, 0.0f, 0.0f ) );
943 request_start_moving_camera( arrow_moving_time_speed, false );
944 return true;
945
946 case VIEW3D_TYPE::VIEW3D_PAN_UP:
947 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
949 m_camera.Pan_T1( SFVEC3F( 0.0f, +delta_move, 0.0f ) );
950 request_start_moving_camera( arrow_moving_time_speed, false );
951 return true;
952
953 case VIEW3D_TYPE::VIEW3D_PAN_DOWN:
954 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
956 m_camera.Pan_T1( SFVEC3F( 0.0f, -delta_move, 0.0f ) );
957 request_start_moving_camera( arrow_moving_time_speed, false );
958 return true;
959
960 case VIEW3D_TYPE::VIEW3D_FIT_SCREEN:
961 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
964 request_start_moving_camera( glm::min( glm::max( m_camera.GetZoom(), 1 / 1.26f ), 1.26f ) );
965 return true;
966
967 case VIEW3D_TYPE::VIEW3D_ZOOM_IN:
968 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
970
971 if( m_camera.Zoom_T1( 1.26f ) ) // 3 steps per doubling
973
974 return true;
975
976 case VIEW3D_TYPE::VIEW3D_ZOOM_OUT:
977 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
979
980 if( m_camera.Zoom_T1( 1/1.26f ) ) // 3 steps per halving
982
983 return true;
984
985 case VIEW3D_TYPE::VIEW3D_RIGHT:
986 case VIEW3D_TYPE::VIEW3D_LEFT:
987 case VIEW3D_TYPE::VIEW3D_FRONT:
988 case VIEW3D_TYPE::VIEW3D_BACK:
989 case VIEW3D_TYPE::VIEW3D_FLIP:
990 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
992 m_camera.ViewCommand_T1( aRequestedView );
994 return true;
995
996 case VIEW3D_TYPE::VIEW3D_TOP:
997 case VIEW3D_TYPE::VIEW3D_BOTTOM:
998 m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
1000 m_camera.ViewCommand_T1( aRequestedView );
1001 request_start_moving_camera( glm::min( glm::max( m_camera.GetZoom(), 0.5f ), 1.125f ) );
1002 return true;
1003
1004 default:
1005 return false;
1006 }
1007}
1008
1009
1011{
1014
1015 switch( cfg->m_Render.engine )
1016 {
1017 case RENDER_ENGINE::OPENGL: m_3d_render = m_3d_render_opengl; break;
1018 case RENDER_ENGINE::RAYTRACING: m_3d_render = m_3d_render_raytracing; break;
1019 default: m_3d_render = nullptr; break;
1020 }
1021
1022 if( m_3d_render )
1024
1025 m_mouse_was_moved = false;
1026
1028}
1029
1030
1032{
1033 SFVEC3F rayOrigin;
1034 SFVEC3F rayDir;
1035
1036 // Generate a ray origin and direction based on current mouser position and camera
1037 m_camera.MakeRayAtCurrentMousePosition( rayOrigin, rayDir );
1038
1039 RAY mouseRay;
1040 mouseRay.Init( rayOrigin, rayDir );
1041
1042 return mouseRay;
1043}
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:77
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:282
A class used to derive camera objects from.
Definition: camera.h:103
bool Zoom(float aFactor)
Definition: camera.cpp:597
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:703
bool SetCurWindowSize(const wxSize &aSize)
Update the windows size of the camera.
Definition: camera.cpp:570
void SetInterpolateMode(CAMERA_INTERPOLATION aInterpolateMode)
Definition: camera.h:259
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:689
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:721
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)
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()
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 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 move_pivot_based_on_cur_mouse_position()
This function hits a ray to the board and start a movement.
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:100
const wxString & GetReference() const
Definition: footprint.h:587
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:53
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:53
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:72
bool GetIsRuleArea() const
Accessors to parameters used in Rule Area zones:
Definition: zone.h:710
const wxString & GetZoneName() const
Definition: zone.h:131
bool IsOnCopperLayer() const override
Definition: zone.cpp:255
#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