EDA_3D_CANVAS Class Reference

Implement a canvas based on a wxGLCanvas. More...

#include <eda_3d_canvas.h>

Inheritance diagram for EDA_3D_CANVAS:

Public Member Functions
	EDA_3D_CANVAS (wxWindow *aParent, const int *aAttribList, BOARD *aBoard, BOARD_ADAPTER &aSettings, CAMERA &aCamera, S3D_CACHE *a3DCachePointer)
	Create a new 3D Canvas with an attribute list. More...
	~EDA_3D_CANVAS ()
void	SetEventDispatcher (TOOL_DISPATCHER *aEventDispatcher)
	Set a dispatcher that processes events and forwards them to tools. More...
void	SetStatusBar (wxStatusBar *aStatusBar)
void	SetInfoBar (WX_INFOBAR *aInfoBar)
void	ReloadRequest (BOARD *aBoard=nullptr, S3D_CACHE *aCachePointer=nullptr)
bool	IsReloadRequestPending () const
	Query if there is a pending reload request. More...
void	RenderRaytracingRequest ()
	Request to render the current view in Raytracing mode. More...
void	GetScreenshot (wxImage &aDstImage)
	Request a screenshot and output it to the aDstImage. More...
bool	SetView3D (int aKeycode)
	Helper function to call view commands. More...
void	AnimationEnabledSet (bool aAnimationEnabled)
	Enable or disable camera animation when switching to a pre-defined view. More...
bool	AnimationEnabledGet () const
	Return whether camera animation is enabled when switching to a pre-defined view. More...
void	MovingSpeedMultiplierSet (int aMovingSpeedMultiplier)
	Set the camera animation moving speed multiplier option. More...
int	MovingSpeedMultiplierGet () const
	Return the current camera animation moving speed multiplier option. More...
void	RenderEngineChanged ()
	Notify that the render engine was changed. More...
void	DisplayStatus ()
	Update the status bar with the position information. More...
void	Request_refresh (bool aRedrawImmediately=true)
	Schedule a refresh update of the canvas. More...
void	OnEvent (wxEvent &aEvent)
	Used to forward events to the canvas from popups, etc. More...
virtual wxSize	GetNativePixelSize () const
void	SetScaleFactor (double aFactor)
	Set the canvas scale factor, probably for a hi-DPI display. More...
double	GetScaleFactor () const
	Get the current scale factor. More...

Private Member Functions
void	OnPaint (wxPaintEvent &aEvent)
	Called by a wxPaintEvent event. More...
void	DoRePaint ()
	The actual function to repaint the canvas. More...
void	OnEraseBackground (wxEraseEvent &event)
void	OnRefreshRequest (wxEvent &aEvent)
void	OnMouseWheel (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)
void	stop_editingTimeOut_Timer ()
	Stop the editing time so it will not timeout. More...
void	restart_editingTimeOut_Timer ()
	Reset the editing timer. More...
void	request_start_moving_camera (float aMovingSpeed=2.0f, bool aRenderPivot=true)
	Start a camera movement. More...
void	move_pivot_based_on_cur_mouse_position ()
	This function hits a ray to the board and start a movement. More...
void	render_pivot (float t, float aScale)
	Render the pivot cursor. More...
bool	initializeOpenGL ()
void	releaseOpenGL ()
	Free created targets and openGL context. More...
RAY	getRayAtCurrrentMousePosition ()

Private Attributes
TOOL_DISPATCHER *	m_eventDispatcher
wxStatusBar *	m_parentStatusBar
WX_INFOBAR *	m_parentInfoBar
wxGLContext *	m_glRC
bool	m_is_opengl_initialized
bool	m_is_opengl_version_supported
wxTimer	m_editing_timeout_timer
wxTimer	m_redraw_trigger_timer
std::atomic_flag	m_is_currently_painting
bool	m_mouse_is_moving
bool	m_mouse_was_moved
bool	m_camera_is_moving
bool	m_render_pivot
float	m_camera_moving_speed
unsigned	m_strtime_camera_movement
bool	m_animation_enabled
int	m_moving_speed_multiplier
BOARD_ADAPTER &	m_boardAdapter
CAMERA &	m_camera
RENDER_3D_BASE *	m_3d_render
RENDER_3D_RAYTRACE *	m_3d_render_raytracing
RENDER_3D_LEGACY *	m_3d_render_ogl_legacy
bool	m_opengl_supports_raytracing
bool	m_render_raytracing_was_requested
CONTAINER_3D	m_3DShapes_container
ACCELERATOR_3D *	m_accelerator3DShapes
BOARD_ITEM *	m_currentIntersectedBoardItem

Static Private Attributes
static const float	m_delta_move_step_factor = 0.7f
static const wxChar *	m_logTrace = wxT( "KI_TRACE_EDA_3D_CANVAS" )
	Trace mask used to enable or disable the trace output of this class. More...

Detailed Description

Implement a canvas based on a wxGLCanvas.

Definition at line 48 of file eda_3d_canvas.h.

Constructor & Destructor Documentation

EDA_3D_CANVAS()

EDA_3D_CANVAS::EDA_3D_CANVAS	(	wxWindow *	aParent,
		const int *	aAttribList,
		BOARD *	aBoard,
		BOARD_ADAPTER &	aSettings,
		CAMERA &	aCamera,
		S3D_CACHE *	a3DCachePointer
	)

Create a new 3D Canvas with an attribute list.

Parameters

aParent	the parent creator of this canvas.
aAttribList	a list of openGL options created by GetOpenGL_AttributesList.
aBoard	The board.
aSettings	the settings options to be used by this canvas.

Definition at line 90 of file eda_3d_canvas.cpp.

        : HIDPI_GL_CANVAS( aParent, wxID_ANY, aAttribList, wxDefaultPosition, wxDefaultSize,
                           wxFULL_REPAINT_ON_RESIZE ),
          m_eventDispatcher( nullptr ),
          m_parentStatusBar( nullptr ),
          m_parentInfoBar( nullptr ),
          m_glRC( nullptr ),
          m_is_opengl_initialized( false ),
          m_is_opengl_version_supported( true ),
          m_mouse_is_moving( false ),
          m_mouse_was_moved( false ),
          m_camera_is_moving( false ),
          m_render_pivot( false ),
          m_camera_moving_speed( 1.0f ),
          m_strtime_camera_movement( 0 ),
          m_animation_enabled( true ),
          m_moving_speed_multiplier( 3 ),
          m_boardAdapter( aBoardAdapter ),
          m_camera( aCamera ),
          m_3d_render( nullptr ),
          m_opengl_supports_raytracing( true ),
          m_render_raytracing_was_requested( false ),
          m_accelerator3DShapes( nullptr ),
          m_currentIntersectedBoardItem( nullptr )
{
    wxLogTrace( m_logTrace, "EDA_3D_CANVAS::EDA_3D_CANVAS" );

    m_editing_timeout_timer.SetOwner( this );
    Connect( m_editing_timeout_timer.GetId(), wxEVT_TIMER,
             wxTimerEventHandler( EDA_3D_CANVAS::OnTimerTimeout_Editing ), nullptr, this );

    m_redraw_trigger_timer.SetOwner( this );
    Connect( m_redraw_trigger_timer.GetId(), wxEVT_TIMER,
             wxTimerEventHandler( EDA_3D_CANVAS::OnTimerTimeout_Redraw ), nullptr, this );

    m_is_currently_painting.clear();

    m_3d_render_raytracing = new RENDER_3D_RAYTRACE( m_boardAdapter, m_camera );
    m_3d_render_ogl_legacy = new RENDER_3D_LEGACY( m_boardAdapter, m_camera );

    wxASSERT( m_3d_render_raytracing != nullptr );
    wxASSERT( m_3d_render_ogl_legacy != nullptr );

    auto busy_indicator_factory = []() { return std::make_unique<WX_BUSY_INDICATOR>(); };

    m_3d_render_raytracing->SetBusyIndicatorFactory( busy_indicator_factory );
    m_3d_render_ogl_legacy->SetBusyIndicatorFactory( busy_indicator_factory );

    RenderEngineChanged();

    wxASSERT( aBoard != nullptr );
    m_boardAdapter.SetBoard( aBoard );

    m_boardAdapter.SetColorSettings( Pgm().GetSettingsManager().GetColorSettings() );

    wxASSERT( a3DCachePointer != nullptr );
    m_boardAdapter.Set3dCacheManager( a3DCachePointer );

    const wxEventType events[] =
    {
        // Binding both EVT_CHAR and EVT_CHAR_HOOK ensures that all key events,
        // especially special key like arrow keys, are handled by the GAL event dispatcher,
        // and not sent to GUI without filtering, because they have a default action (scroll)
        // that must not be called.
        wxEVT_LEFT_UP, wxEVT_LEFT_DOWN, wxEVT_LEFT_DCLICK,
        wxEVT_RIGHT_UP, wxEVT_RIGHT_DOWN, wxEVT_RIGHT_DCLICK,
        wxEVT_MIDDLE_UP, wxEVT_MIDDLE_DOWN, wxEVT_MIDDLE_DCLICK,
        wxEVT_MOTION, wxEVT_MOUSEWHEEL, wxEVT_CHAR, wxEVT_CHAR_HOOK,
#if wxCHECK_VERSION( 3, 1, 0 ) || defined( USE_OSX_MAGNIFY_EVENT )
        wxEVT_MAGNIFY,
#endif
        wxEVT_MENU_OPEN, wxEVT_MENU_CLOSE, wxEVT_MENU_HIGHLIGHT
    };

    for( wxEventType eventType : events )
        Connect( eventType, wxEventHandler( EDA_3D_CANVAS::OnEvent ), nullptr, m_eventDispatcher );
}

References GetSettingsManager(), OnEvent(), OnTimerTimeout_Editing(), OnTimerTimeout_Redraw(), and Pgm().

~EDA_3D_CANVAS()

EDA_3D_CANVAS::~EDA_3D_CANVAS

(

)

Definition at line 171 of file eda_3d_canvas.cpp.

{
    wxLogTrace( m_logTrace, "EDA_3D_CANVAS::~EDA_3D_CANVAS" );

    delete m_accelerator3DShapes;
    m_accelerator3DShapes = nullptr;

    releaseOpenGL();
}

References m_accelerator3DShapes, m_logTrace, and releaseOpenGL().

Member Function Documentation

AnimationEnabledGet()

bool EDA_3D_CANVAS::AnimationEnabledGet ( ) const

inline

Return whether camera animation is enabled when switching to a pre-defined view.

Returns

true if animation is enabled.

Definition at line 131 of file eda_3d_canvas.h.

{ return m_animation_enabled; }

References m_animation_enabled.

Referenced by EDA_3D_VIEWER::SaveSettings(), and DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow().

AnimationEnabledSet()

void EDA_3D_CANVAS::AnimationEnabledSet ( bool  aAnimationEnabled )

inline

Enable or disable camera animation when switching to a pre-defined view.

Parameters

aAnimationEnabled

animation enabled state to set.

Definition at line 124 of file eda_3d_canvas.h.

{ m_animation_enabled = aAnimationEnabled; }

References m_animation_enabled.

Referenced by EDA_3D_VIEWER::LoadSettings(), and DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow().

DisplayStatus()

void EDA_3D_CANVAS::DisplayStatus

(

)

Update the status bar with the position information.

Definition at line 327 of file eda_3d_canvas.cpp.

{
    if( m_parentStatusBar )
    {
        wxString msg;

        msg.Printf( "dx %3.2f", m_camera.GetCameraPos().x );
        m_parentStatusBar->SetStatusText( msg, static_cast<int>( EDA_3D_VIEWER_STATUSBAR::X_POS ) );

        msg.Printf( "dy %3.2f", m_camera.GetCameraPos().y );
        m_parentStatusBar->SetStatusText( msg, static_cast<int>( EDA_3D_VIEWER_STATUSBAR::Y_POS ) );
    }
}

References CAMERA::GetCameraPos(), m_camera, m_parentStatusBar, X_POS, and Y_POS.

Referenced by DoRePaint(), EDA_3D_CONTROLLER::doZoomInOut(), OnMouseMove(), OnMouseWheel(), request_start_moving_camera(), SetView3D(), and EDA_3D_CONTROLLER::ZoomFitScreen().

DoRePaint()

void EDA_3D_CANVAS::DoRePaint ( )

private

The actual function to repaint the canvas.

It is usually called by OnPaint() but because it does not use a wxPaintDC it can be called outside a wxPaintEvent

Definition at line 349 of file eda_3d_canvas.cpp.

{
    if( m_is_currently_painting.test_and_set() )
        return;

    // SwapBuffer requires the window to be shown before calling
    if( !IsShownOnScreen() )
    {
        wxLogTrace( m_logTrace, "EDA_3D_CANVAS::DoRePaint !IsShown" );
        m_is_currently_painting.clear();
        return;
    }

    // Because the board to draw is handled by the parent viewer frame,
    // ensure this parent is still alive. When it is closed before the viewer
    // frame, a paint event can be generated after the parent is closed,
    // therefore with invalid board.
    // This is dependent of the platform.
    // Especially on OSX, but also on Windows, it frequently happens
    if( !GetParent()->GetParent()->IsShown() )
        return; // The parent board editor frame is no more alive

    wxString err_messages;

    // !TODO: implement error reporter
    INFOBAR_REPORTER   warningReporter( m_parentInfoBar );
    STATUSBAR_REPORTER activityReporter( m_parentStatusBar,
                                         (int) EDA_3D_VIEWER_STATUSBAR::ACTIVITY );

    unsigned strtime = GetRunningMicroSecs();

    // "Makes the OpenGL state that is represented by the OpenGL rendering
    //  context context current, i.e. it will be used by all subsequent OpenGL calls.
    //  This function may only be called when the window is shown on screen"

    // Explicitly create a new rendering context instance for this canvas.
    if( m_glRC == nullptr )
        m_glRC = GL_CONTEXT_MANAGER::Get().CreateCtx( this );

    GL_CONTEXT_MANAGER::Get().LockCtx( m_glRC, this );

    // Set the OpenGL viewport according to the client size of this canvas.
    // This is done here rather than in a wxSizeEvent handler because our
    // OpenGL rendering context (and thus viewport setting) is used with
    // multiple canvases: If we updated the viewport in the wxSizeEvent
    // handler, changing the size of one canvas causes a viewport setting that
    // is wrong when next another canvas is repainted.
    wxSize clientSize = GetNativePixelSize();

    const bool windows_size_changed = m_camera.SetCurWindowSize( clientSize );

    // Initialize openGL if need
    if( !m_is_opengl_initialized )
    {
        if( !initializeOpenGL() )
        {
            GL_CONTEXT_MANAGER::Get().UnlockCtx( m_glRC );
            m_is_currently_painting.clear();

            return;
        }

        if( !m_is_opengl_version_supported )
        {
            warningReporter.Report( _( "Your OpenGL version is not supported. Minimum required "
                                       "is 1.5" ), RPT_SEVERITY_ERROR );

            warningReporter.Finalize();
        }
    }

    if( !m_is_opengl_version_supported )
    {
        glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
        glClear( GL_COLOR_BUFFER_BIT );

        SwapBuffers();

        GL_CONTEXT_MANAGER::Get().UnlockCtx( m_glRC );
        m_is_currently_painting.clear();

        return;
    }

    // Don't attend to ray trace if OpenGL doesn't support it.
    if( !m_opengl_supports_raytracing )
    {
        m_3d_render = m_3d_render_ogl_legacy;
        m_render_raytracing_was_requested = false;
        m_boardAdapter.SetRenderEngine( RENDER_ENGINE::OPENGL_LEGACY );
    }

    // Check if a raytacing was requested and need to switch to raytracing mode
    if( m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::OPENGL_LEGACY )
    {
        const bool was_camera_changed = m_camera.ParametersChanged();

        // It reverts back to OpenGL mode if it was requested a raytracing
        // render of the current scene. AND the mouse / camera is moving
        if( ( m_mouse_is_moving || m_camera_is_moving || was_camera_changed
            || windows_size_changed )
          && m_render_raytracing_was_requested )
        {
            m_render_raytracing_was_requested = false;
            m_3d_render = m_3d_render_ogl_legacy;
        }
    }

    float curtime_delta_s = 0.0f;

    if( m_camera_is_moving )
    {
        const unsigned curtime_delta = GetRunningMicroSecs() - m_strtime_camera_movement;
        curtime_delta_s = (curtime_delta / 1e6) * m_camera_moving_speed;
        m_camera.Interpolate( curtime_delta_s );

        if( curtime_delta_s > 1.0f )
        {
            m_render_pivot = false;
            m_camera_is_moving = false;
            m_mouse_was_moved = true;

            restart_editingTimeOut_Timer();
            DisplayStatus();
        }
        else
        {
            Request_refresh();
        }
    }

    // It will return true if the render request a new redraw
    bool requested_redraw = false;

    if( m_3d_render )
    {
        try
        {
            m_3d_render->SetCurWindowSize( clientSize );

            bool reloadRaytracingForIntersectionCalculations = false;

            if( ( m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::OPENGL_LEGACY )
              && m_3d_render_ogl_legacy->IsReloadRequestPending() )
            {
                reloadRaytracingForIntersectionCalculations = true;
            }

            requested_redraw = m_3d_render->Redraw( m_mouse_was_moved || m_camera_is_moving,
                                                    &activityReporter, &warningReporter );

            if( reloadRaytracingForIntersectionCalculations )
                m_3d_render_raytracing->Reload( nullptr, nullptr, true );
        }
        catch( std::runtime_error& )
        {
            m_is_opengl_version_supported = false;
            m_opengl_supports_raytracing  = false;
            m_is_opengl_initialized       = false;
            GL_CONTEXT_MANAGER::Get().UnlockCtx( m_glRC );
            m_is_currently_painting.clear();
            return;
        }
    }

    if( m_render_pivot )
    {
        const float scale = glm::min( m_camera.ZoomGet(), 1.0f );
        render_pivot( curtime_delta_s, scale * scale );
    }

    // "Swaps the double-buffer of this window, making the back-buffer the
    //  front-buffer and vice versa, so that the output of the previous OpenGL
    //  commands is displayed on the window."
    SwapBuffers();

    GL_CONTEXT_MANAGER::Get().UnlockCtx( m_glRC );

    if( !activityReporter.HasMessage() )
    {
        if( m_mouse_was_moved || m_camera_is_moving )
        {
            // Calculation time in milliseconds
            const double calculation_time = (double)( GetRunningMicroSecs() - strtime) / 1e3;

            activityReporter.Report( wxString::Format( _( "Last render time %.0f ms" ),
                                     calculation_time ) );
        }
    }

    // This will reset the flag of camera parameters changed
    m_camera.ParametersChanged();

    warningReporter.Finalize();

    if( !err_messages.IsEmpty() )
        wxLogMessage( err_messages );

    if( ( !m_camera_is_moving ) && requested_redraw )
    {
        m_mouse_was_moved = false;
        Request_refresh( false );
    }

    m_is_currently_painting.clear();
}

References _, ACTIVITY, GL_CONTEXT_MANAGER::CreateCtx(), DisplayStatus(), INFOBAR_REPORTER::Finalize(), Format(), GL_CONTEXT_MANAGER::Get(), HIDPI_GL_CANVAS::GetNativePixelSize(), BOARD_ADAPTER::GetRenderEngine(), GetRunningMicroSecs(), STATUSBAR_REPORTER::HasMessage(), initializeOpenGL(), CAMERA::Interpolate(), RENDER_3D_BASE::IsReloadRequestPending(), GL_CONTEXT_MANAGER::LockCtx(), m_3d_render, m_3d_render_ogl_legacy, m_3d_render_raytracing, m_boardAdapter, m_camera, m_camera_is_moving, m_camera_moving_speed, m_glRC, m_is_currently_painting, m_is_opengl_initialized, m_is_opengl_version_supported, m_logTrace, m_mouse_is_moving, m_mouse_was_moved, m_opengl_supports_raytracing, m_parentInfoBar, m_parentStatusBar, m_render_pivot, m_render_raytracing_was_requested, m_strtime_camera_movement, OPENGL_LEGACY, CAMERA::ParametersChanged(), RENDER_3D_BASE::Redraw(), RENDER_3D_RAYTRACE::Reload(), render_pivot(), STATUSBAR_REPORTER::Report(), INFOBAR_REPORTER::Report(), Request_refresh(), restart_editingTimeOut_Timer(), RPT_SEVERITY_ERROR, scale, RENDER_3D_BASE::SetCurWindowSize(), CAMERA::SetCurWindowSize(), BOARD_ADAPTER::SetRenderEngine(), GL_CONTEXT_MANAGER::UnlockCtx(), and CAMERA::ZoomGet().

Referenced by OnPaint(), and OnRefreshRequest().

GetNativePixelSize()

wxSize HIDPI_GL_CANVAS::GetNativePixelSize ( ) const

virtualinherited

Definition at line 46 of file hidpi_gl_canvas.cpp.

{
    wxSize size = wxGLCanvas::GetClientSize();

    const double scaleFactor = GetScaleFactor();
    size.x *= scaleFactor;
    size.y *= scaleFactor;

    return size;
}

References HIDPI_GL_CANVAS::GetScaleFactor().

Referenced by DoRePaint(), OnMouseMove(), and KIGFX::OPENGL_GAL::OPENGL_GAL().

getRayAtCurrrentMousePosition()

RAY EDA_3D_CANVAS::getRayAtCurrrentMousePosition ( )

private

Definition at line 1128 of file eda_3d_canvas.cpp.

{
    SFVEC3F rayOrigin;
    SFVEC3F rayDir;

    // Generate a ray origin and direction based on current mouser position and camera
    m_camera.MakeRayAtCurrrentMousePosition( rayOrigin, rayDir );

    RAY mouseRay;
    mouseRay.Init( rayOrigin, rayDir );

    return mouseRay;
}

References RAY::Init(), m_camera, and CAMERA::MakeRayAtCurrrentMousePosition().

Referenced by move_pivot_based_on_cur_mouse_position(), OnLeftDown(), and OnMouseMove().

GetScaleFactor()

double HIDPI_GL_CANVAS::GetScaleFactor ( ) const

inherited

Get the current scale factor.

Definition at line 64 of file hidpi_gl_canvas.cpp.

{
    return m_scale_factor;
}

References HIDPI_GL_CANVAS::m_scale_factor.

Referenced by KIGFX::OPENGL_GAL::beginDrawing(), KIGFX::OPENGL_GAL::DrawGrid(), HIDPI_GL_CANVAS::GetNativePixelSize(), KIGFX::OPENGL_GAL::getScreenPixelSize(), KIGFX::OPENGL_GAL::ResizeScreen(), KIGFX::PREVIEW::SetConstantGlyphHeight(), and KIGFX::OPENGL_GAL::updatedGalDisplayOptions().

GetScreenshot()

void EDA_3D_CANVAS::GetScreenshot

(

wxImage &

aDstImage

)

Request a screenshot and output it to the aDstImage.

Parameters

aDstImage

- Screenshot destination image

Definition at line 293 of file eda_3d_canvas.cpp.

{
    OglGetScreenshot( aDstImage );
}

References OglGetScreenshot().

Referenced by EDA_3D_VIEWER::takeScreenshot().

initializeOpenGL()

bool EDA_3D_CANVAS::initializeOpenGL ( )

private

Returns

true if OpenGL initialization succeeded.

Definition at line 218 of file eda_3d_canvas.cpp.

{
    wxLogTrace( m_logTrace, "EDA_3D_CANVAS::initializeOpenGL" );

    const GLenum err = glewInit();

    if( GLEW_OK != err )
    {
        const wxString msgError = (const char*) glewGetErrorString( err );

        wxLogMessage( msgError );

        return false;
    }
    else
    {
        wxLogTrace( m_logTrace, "EDA_3D_CANVAS::initializeOpenGL Using GLEW version %s",
                    FROM_UTF8( (char*) glewGetString( GLEW_VERSION ) ) );
    }

    wxString version = FROM_UTF8( (char *) glGetString( GL_VERSION ) );

    wxLogTrace( m_logTrace, "EDA_3D_CANVAS::%s OpenGL version string %s.",
                __WXFUNCTION__, version );

    // Extract OpenGL version from string.  This method is used because prior to OpenGL 2,
    // getting the OpenGL major and minor version as integers didn't exist.
    wxString tmp;

    wxStringTokenizer tokenizer( version );

    if( tokenizer.HasMoreTokens() )
    {
        long major = 0;
        long minor = 0;

        tmp = tokenizer.GetNextToken();

        tokenizer.SetString( tmp, wxString( "." ) );

        if( tokenizer.HasMoreTokens() )
            tokenizer.GetNextToken().ToLong( &major );

        if( tokenizer.HasMoreTokens() )
            tokenizer.GetNextToken().ToLong( &minor );

        if( major < 2 || ( ( major == 2 ) && ( minor < 1 ) ) )
        {
            wxLogTrace( m_logTrace, "EDA_3D_CANVAS::%s OpenGL ray tracing not supported.",
                        __WXFUNCTION__ );

            if( GetParent() )
            {
                wxCommandEvent evt( wxEVT_MENU, ID_DISABLE_RAY_TRACING );
                GetParent()->ProcessWindowEvent( evt );
            }

            m_opengl_supports_raytracing = false;
        }

        if( ( major == 1 ) && ( minor < 5 ) )
        {
            wxLogTrace( m_logTrace, "EDA_3D_CANVAS::%s OpenGL not supported.", __WXFUNCTION__ );

            m_is_opengl_version_supported = false;
        }
    }

    GL_UTILS::SetSwapInterval( -1 );
    m_is_opengl_initialized = true;

    return true;
}

References FROM_UTF8(), ID_DISABLE_RAY_TRACING, m_is_opengl_initialized, m_is_opengl_version_supported, m_logTrace, m_opengl_supports_raytracing, and GL_UTILS::SetSwapInterval().

Referenced by DoRePaint().

IsReloadRequestPending()

bool EDA_3D_CANVAS::IsReloadRequestPending ( ) const

inline

Query if there is a pending reload request.

Returns

true if it wants to reload, false if there is no reload pending.

Definition at line 91 of file eda_3d_canvas.h.

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

References RENDER_3D_BASE::IsReloadRequestPending(), and m_3d_render.

Referenced by EDA_3D_VIEWER::OnActivate().

move_pivot_based_on_cur_mouse_position()

void EDA_3D_CANVAS::move_pivot_based_on_cur_mouse_position ( )

private

This function hits a ray to the board and start a movement.

Definition at line 929 of file eda_3d_canvas.cpp.

{
    RAY mouseRay = getRayAtCurrrentMousePosition();

    float hit_t;

    // Test it with the board bounding box
    if( m_boardAdapter.GetBBox().Intersect( mouseRay, &hit_t ) )
    {
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
        m_camera.SetT0_and_T1_current_T();
        m_camera.SetLookAtPos_T1( mouseRay.at( hit_t ) );
        m_camera.ResetXYpos_T1();

        request_start_moving_camera();
    }
}

References RAY::at(), BEZIER, BOARD_ADAPTER::GetBBox(), getRayAtCurrrentMousePosition(), BBOX_3D::Intersect(), m_boardAdapter, m_camera, request_start_moving_camera(), CAMERA::ResetXYpos_T1(), CAMERA::SetInterpolateMode(), CAMERA::SetLookAtPos_T1(), and CAMERA::SetT0_and_T1_current_T().

Referenced by OnMiddleUp(), and SetView3D().

MovingSpeedMultiplierGet()

int EDA_3D_CANVAS::MovingSpeedMultiplierGet ( ) const

inline

Return the current camera animation moving speed multiplier option.

Returns

current moving speed multiplier option, one of [1,2,3,4,5].

Definition at line 148 of file eda_3d_canvas.h.

{ return m_moving_speed_multiplier; }

References m_moving_speed_multiplier.

Referenced by EDA_3D_VIEWER::SaveSettings(), and DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow().

MovingSpeedMultiplierSet()

void EDA_3D_CANVAS::MovingSpeedMultiplierSet ( int  aMovingSpeedMultiplier )

inline

Set the camera animation moving speed multiplier option.

Parameters

aMovingSpeedMultiplier

one of the possible integer options: [1,2,3,4,5].

Definition at line 138 of file eda_3d_canvas.h.

    {
        m_moving_speed_multiplier = aMovingSpeedMultiplier;
    }

References m_moving_speed_multiplier.

Referenced by EDA_3D_VIEWER::LoadSettings(), and DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow().

OnCloseWindow()

void EDA_3D_CANVAS::OnCloseWindow ( wxCloseEvent &  event )

private

Definition at line 204 of file eda_3d_canvas.cpp.

{
    releaseOpenGL();

    event.Skip();
}

References releaseOpenGL().

OnEraseBackground()

void EDA_3D_CANVAS::OnEraseBackground ( wxEraseEvent &  event )

private

Definition at line 574 of file eda_3d_canvas.cpp.

{
    wxLogTrace( m_logTrace, "EDA_3D_CANVAS::OnEraseBackground" );
    // Do nothing, to avoid flashing.
}

References m_logTrace.

OnEvent()

void EDA_3D_CANVAS::OnEvent

(

wxEvent &

aEvent

)

Used to forward events to the canvas from popups, etc.

Definition at line 563 of file eda_3d_canvas.cpp.

{
    if( !m_eventDispatcher )
        aEvent.Skip();
    else
        m_eventDispatcher->DispatchWxEvent( aEvent );

    Refresh();
}

References TOOL_DISPATCHER::DispatchWxEvent(), m_eventDispatcher, and Refresh().

Referenced by EDA_3D_CANVAS().

OnLeftDown()

void EDA_3D_CANVAS::OnLeftDown ( wxMouseEvent &  event )

private

Definition at line 790 of file eda_3d_canvas.cpp.

{
    SetFocus();
    stop_editingTimeOut_Timer();

    if( !event.Dragging() && ( m_3d_render_raytracing != nullptr ) )
    {
        RAY mouseRay = getRayAtCurrrentMousePosition();

        BOARD_ITEM *intersectedBoardItem = m_3d_render_raytracing->IntersectBoardItem( mouseRay );

        // !TODO: send a selection item to pcbnew, eg: via kiway?
    }
}

References getRayAtCurrrentMousePosition(), RENDER_3D_RAYTRACE::IntersectBoardItem(), m_3d_render_raytracing, and stop_editingTimeOut_Timer().

OnLeftUp()

void EDA_3D_CANVAS::OnLeftUp ( wxMouseEvent &  event )

private

Definition at line 806 of file eda_3d_canvas.cpp.

{
    if( m_camera_is_moving )
        return;

    if( m_mouse_is_moving )
    {
        m_mouse_is_moving = false;
        restart_editingTimeOut_Timer();
    }
}

References m_camera_is_moving, m_mouse_is_moving, and restart_editingTimeOut_Timer().

OnMiddleDown()

void EDA_3D_CANVAS::OnMiddleDown ( wxMouseEvent &  event )

private

Definition at line 819 of file eda_3d_canvas.cpp.

{
    SetFocus();
    stop_editingTimeOut_Timer();
}

References stop_editingTimeOut_Timer().

OnMiddleUp()

void EDA_3D_CANVAS::OnMiddleUp ( wxMouseEvent &  event )

private

Definition at line 826 of file eda_3d_canvas.cpp.

{
    if( m_camera_is_moving )
        return;

    if( m_mouse_is_moving )
    {
        m_mouse_is_moving = false;
        restart_editingTimeOut_Timer();
    }
    else
    {
        move_pivot_based_on_cur_mouse_position();
    }
}

References m_camera_is_moving, m_mouse_is_moving, move_pivot_based_on_cur_mouse_position(), and restart_editingTimeOut_Timer().

OnMouseMove()

void EDA_3D_CANVAS::OnMouseMove ( wxMouseEvent &  event )

private

Definition at line 669 of file eda_3d_canvas.cpp.

{
    //wxLogTrace( m_logTrace, wxT( "EDA_3D_CANVAS::OnMouseMove" ) );

    if( m_camera_is_moving )
        return;

    m_camera.SetCurWindowSize( GetNativePixelSize() );

    if( event.Dragging() )
    {
        if( event.LeftIsDown() )            // Drag
            m_camera.Drag( event.GetPosition() );
        else if( event.MiddleIsDown() )     // Pan
            m_camera.Pan( event.GetPosition() );

        m_mouse_is_moving = true;
        m_mouse_was_moved = true;

        // orientation has changed, redraw mesh
        DisplayStatus();
        Request_refresh();
    }

    const wxPoint eventPosition = event.GetPosition();
    m_camera.SetCurMousePosition( eventPosition );

    if( !event.Dragging() &&
        ( m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::OPENGL_LEGACY ) )
    {
        STATUSBAR_REPORTER reporter( m_parentStatusBar,
                                     static_cast<int>( EDA_3D_VIEWER_STATUSBAR::HOVERED_ITEM ) );

        RAY mouseRay = getRayAtCurrrentMousePosition();

        BOARD_ITEM *intersectedBoardItem = m_3d_render_raytracing->IntersectBoardItem( mouseRay );

        if( intersectedBoardItem )
        {
            if( intersectedBoardItem != m_currentIntersectedBoardItem )
            {
                m_3d_render_ogl_legacy->SetCurrentIntersectedBoardItem( intersectedBoardItem );
                m_currentIntersectedBoardItem = intersectedBoardItem;

                Request_refresh();
            }

            switch( intersectedBoardItem->Type() )
            {
            case PCB_PAD_T:
            {
                PAD* pad = dynamic_cast<PAD*>( intersectedBoardItem );

                if( pad && pad->IsOnCopperLayer() )
                {
                    reporter.Report( wxString::Format( _( "Net %s\tNetClass %s\tPadName %s" ),
                                                       pad->GetNet()->GetNetname(),
                                                       pad->GetNet()->GetNetClassName(),
                                                       pad->GetName() ) );
                }
            }
                break;

            case PCB_FOOTPRINT_T:
            {
                FOOTPRINT* footprint = dynamic_cast<FOOTPRINT *>( intersectedBoardItem );

                if( footprint )
                    reporter.Report( footprint->GetReference() );
            }
                break;

            case PCB_TRACE_T:
            case PCB_VIA_T:
            case PCB_ARC_T:
            {
                TRACK* track = dynamic_cast<TRACK *>( intersectedBoardItem );

                if( track )
                {
                    reporter.Report( wxString::Format( _( "Net %s\tNetClass %s" ),
                                                       track->GetNet()->GetNetname(),
                                                       track->GetNet()->GetNetClassName() ) );
                }
            }
                break;

            case PCB_ZONE_T:
            {
                ZONE* zone = dynamic_cast<ZONE*>( intersectedBoardItem );

                if( zone && zone->IsOnCopperLayer() )
                {
                    reporter.Report( wxString::Format( _( "Net %s\tNetClass %s" ),
                                                       zone->GetNet()->GetNetname(),
                                                       zone->GetNet()->GetNetClassName() ) );
                }
            }
                break;

            default:
                break;
            }
        }
        else
        {
            if( ( m_currentIntersectedBoardItem != nullptr ) &&
                ( m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::OPENGL_LEGACY ) )
            {
                m_3d_render_ogl_legacy->SetCurrentIntersectedBoardItem( nullptr );
                Request_refresh();

                reporter.Report( "" );
            }

            m_currentIntersectedBoardItem = nullptr;
        }
    }
}

References _, DisplayStatus(), CAMERA::Drag(), Format(), HIDPI_GL_CANVAS::GetNativePixelSize(), BOARD_CONNECTED_ITEM::GetNet(), NETINFO_ITEM::GetNetClassName(), NETINFO_ITEM::GetNetname(), getRayAtCurrrentMousePosition(), FOOTPRINT::GetReference(), BOARD_ADAPTER::GetRenderEngine(), HOVERED_ITEM, RENDER_3D_RAYTRACE::IntersectBoardItem(), ZONE::IsOnCopperLayer(), m_3d_render_ogl_legacy, m_3d_render_raytracing, m_boardAdapter, m_camera, m_camera_is_moving, m_currentIntersectedBoardItem, m_mouse_is_moving, m_mouse_was_moved, m_parentStatusBar, OPENGL_LEGACY, pad, CAMERA::Pan(), PCB_ARC_T, PCB_FOOTPRINT_T, PCB_PAD_T, PCB_TRACE_T, PCB_VIA_T, PCB_ZONE_T, STATUSBAR_REPORTER::Report(), Request_refresh(), CAMERA::SetCurMousePosition(), RENDER_3D_LEGACY::SetCurrentIntersectedBoardItem(), CAMERA::SetCurWindowSize(), and EDA_ITEM::Type().

OnMouseWheel()

void EDA_3D_CANVAS::OnMouseWheel ( wxMouseEvent &  event )

private

Definition at line 581 of file eda_3d_canvas.cpp.

{
    bool mouseActivity = false;

    wxLogTrace( m_logTrace, "EDA_3D_CANVAS::OnMouseWheel" );

    if( m_camera_is_moving )
        return;

    float delta_move = m_delta_move_step_factor * m_camera.ZoomGet();

    if( m_boardAdapter.GetFlag( FL_MOUSEWHEEL_PANNING ) )
        delta_move *= 0.01f * event.GetWheelRotation();
    else
        if( event.GetWheelRotation() < 0 )
            delta_move = -delta_move;

    // mousewheel_panning enabled:
    //      wheel           -> pan;
    //      wheel + shift   -> horizontal scrolling;
    //      wheel + ctrl    -> zooming;
    // mousewheel_panning disabled:
    //      wheel + shift   -> vertical scrolling;
    //      wheel + ctrl    -> horizontal scrolling;
    //      wheel           -> zooming.

    if( m_boardAdapter.GetFlag( FL_MOUSEWHEEL_PANNING ) && !event.ControlDown() )
    {
        if( event.GetWheelAxis() == wxMOUSE_WHEEL_HORIZONTAL || event.ShiftDown() )
            m_camera.Pan( SFVEC3F( -delta_move, 0.0f, 0.0f ) );
        else
            m_camera.Pan( SFVEC3F( 0.0f, -delta_move, 0.0f ) );

        mouseActivity = true;
    }
    else if( event.ShiftDown() && !m_boardAdapter.GetFlag( FL_MOUSEWHEEL_PANNING ) )
    {
        m_camera.Pan( SFVEC3F( 0.0f, -delta_move, 0.0f ) );
        mouseActivity = true;
    }
    else if( event.ControlDown() && !m_boardAdapter.GetFlag( FL_MOUSEWHEEL_PANNING ) )
    {
        m_camera.Pan( SFVEC3F( delta_move, 0.0f, 0.0f ) );
        mouseActivity = true;
    }
    else
    {
        mouseActivity = m_camera.Zoom( event.GetWheelRotation() > 0 ? 1.1f : 1/1.1f );
    }

    // If it results on a camera movement
    if( mouseActivity )
    {
        DisplayStatus();
        Request_refresh();

        m_mouse_is_moving = true;
        m_mouse_was_moved = true;

        restart_editingTimeOut_Timer();
    }

    // Update the cursor current mouse position on the camera
    m_camera.SetCurMousePosition( event.GetPosition() );
}

References DisplayStatus(), FL_MOUSEWHEEL_PANNING, BOARD_ADAPTER::GetFlag(), m_boardAdapter, m_camera, m_camera_is_moving, m_delta_move_step_factor, m_logTrace, m_mouse_is_moving, m_mouse_was_moved, CAMERA::Pan(), Request_refresh(), restart_editingTimeOut_Timer(), CAMERA::SetCurMousePosition(), CAMERA::Zoom(), and CAMERA::ZoomGet().

OnPaint()

void EDA_3D_CANVAS::OnPaint ( wxPaintEvent &  aEvent )

private

Called by a wxPaintEvent event.

Definition at line 342 of file eda_3d_canvas.cpp.

{
    // Please have a look at: https://lists.launchpad.net/kicad-developers/msg25149.html
    DoRePaint();
}

References DoRePaint().

OnRefreshRequest()

void EDA_3D_CANVAS::OnRefreshRequest ( wxEvent &  aEvent )

private

Definition at line 873 of file eda_3d_canvas.cpp.

{
   DoRePaint();
}

References DoRePaint().

OnResize()

void EDA_3D_CANVAS::OnResize ( wxSizeEvent &  event )

private

Definition at line 212 of file eda_3d_canvas.cpp.

{
    this->Request_refresh();
}

References Request_refresh().

OnTimerTimeout_Editing()

void EDA_3D_CANVAS::OnTimerTimeout_Editing ( wxTimerEvent &  event )

private

Definition at line 843 of file eda_3d_canvas.cpp.

{
    (void)event;

    m_mouse_is_moving = false;
    m_mouse_was_moved = false;

    Request_refresh();
}

References m_mouse_is_moving, m_mouse_was_moved, and Request_refresh().

Referenced by EDA_3D_CANVAS().

OnTimerTimeout_Redraw()

void EDA_3D_CANVAS::OnTimerTimeout_Redraw ( wxTimerEvent &  event )

private

Definition at line 867 of file eda_3d_canvas.cpp.

{
    Request_refresh( true );
}

References Request_refresh().

Referenced by EDA_3D_CANVAS().

releaseOpenGL()

void EDA_3D_CANVAS::releaseOpenGL ( )

private

Free created targets and openGL context.

Definition at line 182 of file eda_3d_canvas.cpp.

{
    if( m_glRC )
    {
        GL_CONTEXT_MANAGER::Get().LockCtx( m_glRC, this );

        delete m_3d_render_raytracing;
        m_3d_render_raytracing = nullptr;

        delete m_3d_render_ogl_legacy;
        m_3d_render_ogl_legacy = nullptr;

        // This is just a copy of a pointer, can safely be set to NULL.
        m_3d_render = nullptr;

        GL_CONTEXT_MANAGER::Get().UnlockCtx( m_glRC );
        GL_CONTEXT_MANAGER::Get().DestroyCtx( m_glRC );
        m_glRC = nullptr;
    }
}

References GL_CONTEXT_MANAGER::DestroyCtx(), GL_CONTEXT_MANAGER::Get(), GL_CONTEXT_MANAGER::LockCtx(), m_3d_render, m_3d_render_ogl_legacy, m_3d_render_raytracing, m_glRC, and GL_CONTEXT_MANAGER::UnlockCtx().

Referenced by OnCloseWindow(), and ~EDA_3D_CANVAS().

ReloadRequest()

void EDA_3D_CANVAS::ReloadRequest	(	BOARD *	aBoard = nullptr,
		S3D_CACHE *	aCachePointer = nullptr
	)

Definition at line 299 of file eda_3d_canvas.cpp.

{
    if( aCachePointer != nullptr )
        m_boardAdapter.Set3dCacheManager( aCachePointer );

    if( aBoard != nullptr )
        m_boardAdapter.SetBoard( aBoard );

    m_boardAdapter.SetColorSettings( Pgm().GetSettingsManager().GetColorSettings() );

    if( m_3d_render )
        m_3d_render->ReloadRequest();
}

References GetSettingsManager(), m_3d_render, m_boardAdapter, Pgm(), RENDER_3D_BASE::ReloadRequest(), BOARD_ADAPTER::Set3dCacheManager(), BOARD_ADAPTER::SetBoard(), and BOARD_ADAPTER::SetColorSettings().

Referenced by EDA_3D_VIEWER::ReloadRequest(), PANEL_PREV_3D::UpdateDummyFootprint(), and PANEL_PREV_3D::View3DUpdate().

render_pivot()

void EDA_3D_CANVAS::render_pivot ( float  t, float  aScale  )

private

Render the pivot cursor.

Parameters

t	time between 0.0 and 1.0.
aScale	scale to apply on the cursor.

Definition at line 76 of file eda_3d_canvas_pivot.cpp.

{
    wxASSERT( aScale >= 0.0f );
    wxASSERT( t >= 0.0f );

    if( t > 1.0f )
        t = 1.0f;

    const SFVEC3F &lookAtPos = m_camera.GetLookAtPos_T1();

    glDisable( GL_LIGHTING );
    glDisable( GL_DEPTH_TEST );
    glDisable( GL_CULL_FACE );

    // Set projection and modelview matrixes
    glMatrixMode( GL_PROJECTION );
    glLoadMatrixf( glm::value_ptr( m_camera.GetProjectionMatrix() ) );

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    glLoadMatrixf( glm::value_ptr( m_camera.GetViewMatrix() ) );

    glEnable( GL_COLOR_MATERIAL );
    glColor4f( 0.0f, 1.0f, 0.0f, 0.75f - t * 0.75f );

    // Translate to the look at position
    glTranslatef( lookAtPos.x, lookAtPos.y, lookAtPos.z );

    glScalef( aScale, aScale, aScale );

    pivot_render_triangles( t * 0.5f );

    t = t * 0.80f;
    glScalef( 1.0f - t, 1.0f - t, 1.0f - t );
    glColor4f( 0.0f, 1.0f, 0.0f, 0.8f - t );

    glPushMatrix();
    glRotatef( t * 90.0f, 0.0f, 0.0f, 1.0f );
    pivot_render_triangles( t * 0.5f );
    glPopMatrix();

    glPushMatrix();
    glRotatef( -t * 90.0f, 0.0f, 0.0f, 1.0f );
    pivot_render_triangles( t  * 0.5f );
    glPopMatrix();
}

References CAMERA::GetLookAtPos_T1(), CAMERA::GetProjectionMatrix(), CAMERA::GetViewMatrix(), m_camera, and pivot_render_triangles().

Referenced by DoRePaint().

RenderEngineChanged()

void EDA_3D_CANVAS::RenderEngineChanged

(

)

Notify that the render engine was changed.

Definition at line 1110 of file eda_3d_canvas.cpp.

{
    switch( m_boardAdapter.GetRenderEngine() )
    {
    case RENDER_ENGINE::OPENGL_LEGACY: m_3d_render = m_3d_render_ogl_legacy; break;
    case RENDER_ENGINE::RAYTRACING:    m_3d_render = m_3d_render_raytracing; break;
    default:                           m_3d_render = nullptr;                break;
    }

    if( m_3d_render )
        m_3d_render->ReloadRequest();

    m_mouse_was_moved = false;

    Request_refresh();
}

References BOARD_ADAPTER::GetRenderEngine(), m_3d_render, m_3d_render_ogl_legacy, m_3d_render_raytracing, m_boardAdapter, m_mouse_was_moved, OPENGL_LEGACY, RAYTRACING, RENDER_3D_BASE::ReloadRequest(), and Request_refresh().

Referenced by EDA_3D_VIEWER::RenderEngineChanged().

RenderRaytracingRequest()

void EDA_3D_CANVAS::RenderRaytracingRequest

(

)

Request to render the current view in Raytracing mode.

Definition at line 314 of file eda_3d_canvas.cpp.

{
    m_3d_render = m_3d_render_raytracing;

    if( m_3d_render )
        m_3d_render->ReloadRequest();

    m_render_raytracing_was_requested = true;

    Request_refresh();
}

References m_3d_render, m_3d_render_raytracing, m_render_raytracing_was_requested, RENDER_3D_BASE::ReloadRequest(), and Request_refresh().

Referenced by EDA_3D_CONTROLLER::RotateView(), and EDA_3D_CONTROLLER::ToggleOrtho().

Request_refresh()

void EDA_3D_CANVAS::Request_refresh

(

bool

aRedrawImmediately = true

)

Schedule a refresh update of the canvas.

Parameters

aRedrawImmediately

true will request a redraw, false will schedule a redraw after a short timeout.

Definition at line 879 of file eda_3d_canvas.cpp.

{
    if( aRedrawImmediately )
    {
        // Just calling Refresh() does not work always
        // Using an event to call DoRepaint ensure the repaint code will be executed,
        // and PostEvent will take priority to other events like mouse movements, keys, etc.
        // and is executed during the next idle time
        wxCommandEvent redrawEvent( wxEVT_REFRESH_CUSTOM_COMMAND, ID_CUSTOM_EVENT_1 );
        wxPostEvent( this, redrawEvent );
    }
    else
    {
        // Schedule a timed redraw
        m_redraw_trigger_timer.Start( 10 , wxTIMER_ONE_SHOT );
    }
}

References ID_CUSTOM_EVENT_1, and m_redraw_trigger_timer.

Referenced by DoRePaint(), EDA_3D_CONTROLLER::On3DGridSelection(), EDA_3D_VIEWER::OnActivate(), OnMouseMove(), OnMouseWheel(), OnResize(), OnTimerTimeout_Editing(), OnTimerTimeout_Redraw(), EDA_3D_VIEWER::Redraw(), EDA_3D_VIEWER::refreshRender(), RenderEngineChanged(), RenderRaytracingRequest(), request_start_moving_camera(), EDA_3D_CONTROLLER::RotateView(), EDA_3D_CONTROLLER::SetMaterial(), SetView3D(), EDA_3D_VIEWER::takeScreenshot(), EDA_3D_CONTROLLER::ToggleOrtho(), EDA_3D_CONTROLLER::ToggleVisibility(), PANEL_PREV_3D::UpdateDummyFootprint(), and EDA_3D_CONTROLLER::ZoomRedraw().

request_start_moving_camera()

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

private

Start a camera movement.

Parameters

aMovingSpeed	the time speed.
aRenderPivot	if it should display pivot cursor while move.

Definition at line 898 of file eda_3d_canvas.cpp.

{
    wxASSERT( aMovingSpeed > FLT_EPSILON );

    // Fast forward the animation if the animation is disabled
    if( !m_animation_enabled )
    {
        m_camera.Interpolate( 1.0f );
        DisplayStatus();
        Request_refresh();
        return;
    }

    // Map speed multiplier option to actual multiplier value
    // [1,2,3,4,5] -> [0.25, 0.5, 1, 2, 4]
    aMovingSpeed *= ( 1 << m_moving_speed_multiplier ) / 8.0f;

    m_render_pivot = aRenderPivot;
    m_camera_moving_speed = aMovingSpeed;

    stop_editingTimeOut_Timer();

    DisplayStatus();
    Request_refresh();

    m_camera_is_moving = true;

    m_strtime_camera_movement = GetRunningMicroSecs();
}

References DisplayStatus(), GetRunningMicroSecs(), CAMERA::Interpolate(), m_animation_enabled, m_camera, m_camera_is_moving, m_camera_moving_speed, m_moving_speed_multiplier, m_render_pivot, m_strtime_camera_movement, Request_refresh(), and stop_editingTimeOut_Timer().

Referenced by move_pivot_based_on_cur_mouse_position(), and SetView3D().

restart_editingTimeOut_Timer()

void EDA_3D_CANVAS::restart_editingTimeOut_Timer ( )

private

Reset the editing timer.

Definition at line 860 of file eda_3d_canvas.cpp.

{
    if( m_3d_render )
        m_editing_timeout_timer.Start( m_3d_render->GetWaitForEditingTimeOut(), wxTIMER_ONE_SHOT );
}

References RENDER_3D_BASE::GetWaitForEditingTimeOut(), m_3d_render, and m_editing_timeout_timer.

Referenced by DoRePaint(), OnLeftUp(), OnMiddleUp(), OnMouseWheel(), and SetView3D().

SetEventDispatcher()

void EDA_3D_CANVAS::SetEventDispatcher

(

TOOL_DISPATCHER *

aEventDispatcher

)

Set a dispatcher that processes events and forwards them to tools.

#DRAW_PANEL_GAL does not take over the ownership. Passing NULL disconnects all event handlers from the DRAW_PANEL_GAL and parent frame.

Parameters

aEventDispatcher

is the object that will be used for dispatching events.

Definition at line 557 of file eda_3d_canvas.cpp.

{
    m_eventDispatcher = aEventDispatcher;
}

References m_eventDispatcher.

Referenced by PANEL_PREV_3D::PANEL_PREV_3D(), and EDA_3D_VIEWER::~EDA_3D_VIEWER().

SetInfoBar()

void EDA_3D_CANVAS::SetInfoBar ( WX_INFOBAR *  aInfoBar )

inline

Definition at line 79 of file eda_3d_canvas.h.

    {
        m_parentInfoBar = aInfoBar;
    }

References m_parentInfoBar.

Referenced by PANEL_PREV_3D::PANEL_PREV_3D().

SetScaleFactor()

void HIDPI_GL_CANVAS::SetScaleFactor ( double  aFactor )

inherited

Set the canvas scale factor, probably for a hi-DPI display.

Definition at line 58 of file hidpi_gl_canvas.cpp.

{
    m_scale_factor = aNewScaleFactor;
}

References HIDPI_GL_CANVAS::m_scale_factor.

Referenced by PANEL_PREV_3D::loadCommonSettings(), EDA_3D_VIEWER::loadCommonSettings(), and KIGFX::OPENGL_GAL::updatedGalDisplayOptions().

SetStatusBar()

void EDA_3D_CANVAS::SetStatusBar ( wxStatusBar *  aStatusBar )

inline

Definition at line 74 of file eda_3d_canvas.h.

    {
        m_parentStatusBar = aStatusBar;
    }

References m_parentStatusBar.

SetView3D()

bool EDA_3D_CANVAS::SetView3D

(

int

aKeycode

)

Helper function to call view commands.

Parameters

aKeycode

ascii key commands.

Returns

true if the key code was handled, false if no command found for this code.

Definition at line 948 of file eda_3d_canvas.cpp.

{
    if( m_camera_is_moving )
        return false;

    const float delta_move = m_delta_move_step_factor * m_camera.ZoomGet();
    const float arrow_moving_time_speed = 8.0f;
    bool handled = false;

    switch( aKeycode )
    {
    case WXK_SPACE:
        move_pivot_based_on_cur_mouse_position();
        return true;

    case WXK_LEFT:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
        m_camera.SetT0_and_T1_current_T();
        m_camera.Pan_T1( SFVEC3F( -delta_move, 0.0f, 0.0f ) );
        request_start_moving_camera( arrow_moving_time_speed, false );
        return true;

    case WXK_RIGHT:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
        m_camera.SetT0_and_T1_current_T();
        m_camera.Pan_T1( SFVEC3F( +delta_move, 0.0f, 0.0f ) );
        request_start_moving_camera( arrow_moving_time_speed, false );
        return true;

    case WXK_UP:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
        m_camera.SetT0_and_T1_current_T();
        m_camera.Pan_T1( SFVEC3F( 0.0f, +delta_move, 0.0f ) );
        request_start_moving_camera( arrow_moving_time_speed, false );
        return true;

    case WXK_DOWN:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
        m_camera.SetT0_and_T1_current_T();
        m_camera.Pan_T1( SFVEC3F( 0.0f, -delta_move, 0.0f ) );
        request_start_moving_camera( arrow_moving_time_speed, false );
        return true;

    case WXK_HOME:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
        m_camera.SetT0_and_T1_current_T();
        m_camera.Reset_T1();
        request_start_moving_camera( glm::min( glm::max( m_camera.ZoomGet(), 1/1.26f ), 1.26f ) );
        return true;

    case WXK_END:
        break;

    case WXK_TAB:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::EASING_IN_OUT );
        m_camera.SetT0_and_T1_current_T();
        m_camera.RotateZ_T1( glm::radians( 45.0f ) );
        request_start_moving_camera();
        handled = true;
        break;

    case WXK_F1:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
        m_camera.SetT0_and_T1_current_T();

        if( m_camera.Zoom_T1( 1.26f ) )   // 3 steps per doubling
            request_start_moving_camera( 3.0f );

        return true;

    case WXK_F2:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
        m_camera.SetT0_and_T1_current_T();

        if( m_camera.Zoom_T1( 1/1.26f ) ) // 3 steps per halving
            request_start_moving_camera( 3.0f );

        return true;

    case ID_VIEW3D_RESET:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
        m_camera.SetT0_and_T1_current_T();
        m_camera.Reset_T1();
        request_start_moving_camera( glm::min( glm::max( m_camera.ZoomGet(), 0.5f ), 1.125f ) );
        return true;

    case ID_VIEW3D_RIGHT:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
        m_camera.SetT0_and_T1_current_T();
        m_camera.Reset_T1();
        m_camera.RotateZ_T1( glm::radians( -90.0f ) );
        m_camera.RotateX_T1( glm::radians( -90.0f ) );
        request_start_moving_camera();
        return true;

    case ID_VIEW3D_LEFT:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
        m_camera.SetT0_and_T1_current_T();
        m_camera.Reset_T1();
        m_camera.RotateZ_T1( glm::radians(  90.0f ) );
        m_camera.RotateX_T1( glm::radians( -90.0f ) );
        request_start_moving_camera();
        return true;

    case ID_VIEW3D_FRONT:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
        m_camera.SetT0_and_T1_current_T();
        m_camera.Reset_T1();
        m_camera.RotateX_T1( glm::radians( -90.0f ) );
        request_start_moving_camera();
        return true;

    case ID_VIEW3D_BACK:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
        m_camera.SetT0_and_T1_current_T();
        m_camera.Reset_T1();
        m_camera.RotateX_T1( glm::radians( -90.0f ) );

        // The rotation angle should be 180.
        // We use 179.999 (180 - epsilon) to avoid a full 360 deg rotation when
        // using 180 deg if the previous rotated position was already 180 deg
        m_camera.RotateZ_T1( glm::radians( 179.999f ) );
        request_start_moving_camera();
        return true;

    case ID_VIEW3D_TOP:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
        m_camera.SetT0_and_T1_current_T();
        m_camera.Reset_T1();
        request_start_moving_camera( glm::min( glm::max( m_camera.ZoomGet(), 0.5f ), 1.125f ) );
        return true;

    case ID_VIEW3D_BOTTOM:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
        m_camera.SetT0_and_T1_current_T();
        m_camera.Reset_T1();
        m_camera.RotateY_T1( glm::radians( 179.999f ) );    // Rotation = 180 - epsilon
        request_start_moving_camera( glm::min( glm::max( m_camera.ZoomGet(), 0.5f ), 1.125f ) );
        return true;

    case ID_VIEW3D_FLIP:
        m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
        m_camera.SetT0_and_T1_current_T();
        m_camera.RotateY_T1( glm::radians( 179.999f ) );
        request_start_moving_camera();
        return true;

    default:
        return false;
    }

    m_mouse_was_moved = true;

    restart_editingTimeOut_Timer();

    DisplayStatus();
    Request_refresh();

    return handled;
}

References BEZIER, DisplayStatus(), EASING_IN_OUT, ID_VIEW3D_BACK, ID_VIEW3D_BOTTOM, ID_VIEW3D_FLIP, ID_VIEW3D_FRONT, ID_VIEW3D_LEFT, ID_VIEW3D_RESET, ID_VIEW3D_RIGHT, ID_VIEW3D_TOP, LINEAR, m_camera, m_camera_is_moving, m_delta_move_step_factor, m_mouse_was_moved, move_pivot_based_on_cur_mouse_position(), CAMERA::Pan_T1(), Request_refresh(), request_start_moving_camera(), CAMERA::Reset_T1(), restart_editingTimeOut_Timer(), CAMERA::RotateX_T1(), CAMERA::RotateY_T1(), CAMERA::RotateZ_T1(), CAMERA::SetInterpolateMode(), CAMERA::SetT0_and_T1_current_T(), CAMERA::Zoom_T1(), and CAMERA::ZoomGet().

Referenced by EDA_3D_CONTROLLER::doZoomInOut(), EDA_3D_CONTROLLER::PanControl(), PANEL_PREV_3D::View3DBack(), PANEL_PREV_3D::View3DBottom(), PANEL_PREV_3D::View3DFront(), PANEL_PREV_3D::View3DLeft(), PANEL_PREV_3D::View3DRight(), PANEL_PREV_3D::View3DTop(), EDA_3D_CONTROLLER::ViewControl(), and EDA_3D_CONTROLLER::ZoomFitScreen().

stop_editingTimeOut_Timer()

void EDA_3D_CANVAS::stop_editingTimeOut_Timer ( )

private

Stop the editing time so it will not timeout.

Definition at line 854 of file eda_3d_canvas.cpp.

{
    m_editing_timeout_timer.Stop();
}

References m_editing_timeout_timer.

Referenced by OnLeftDown(), OnMiddleDown(), and request_start_moving_camera().

Member Data Documentation

m_3d_render

RENDER_3D_BASE* EDA_3D_CANVAS::m_3d_render

private

Definition at line 277 of file eda_3d_canvas.h.

Referenced by DoRePaint(), IsReloadRequestPending(), releaseOpenGL(), ReloadRequest(), RenderEngineChanged(), RenderRaytracingRequest(), and restart_editingTimeOut_Timer().

m_3d_render_ogl_legacy

RENDER_3D_LEGACY* EDA_3D_CANVAS::m_3d_render_ogl_legacy

private

Definition at line 279 of file eda_3d_canvas.h.

Referenced by DoRePaint(), OnMouseMove(), releaseOpenGL(), and RenderEngineChanged().

m_3d_render_raytracing

RENDER_3D_RAYTRACE* EDA_3D_CANVAS::m_3d_render_raytracing

private

Definition at line 278 of file eda_3d_canvas.h.

Referenced by DoRePaint(), OnLeftDown(), OnMouseMove(), releaseOpenGL(), RenderEngineChanged(), and RenderRaytracingRequest().

m_3DShapes_container

CONTAINER_3D EDA_3D_CANVAS::m_3DShapes_container

private

Definition at line 287 of file eda_3d_canvas.h.

m_accelerator3DShapes

ACCELERATOR_3D* EDA_3D_CANVAS::m_accelerator3DShapes

private

Definition at line 288 of file eda_3d_canvas.h.

Referenced by ~EDA_3D_CANVAS().

m_animation_enabled

bool EDA_3D_CANVAS::m_animation_enabled

private

Definition at line 272 of file eda_3d_canvas.h.

Referenced by AnimationEnabledGet(), AnimationEnabledSet(), and request_start_moving_camera().

m_boardAdapter

BOARD_ADAPTER& EDA_3D_CANVAS::m_boardAdapter

private

Definition at line 275 of file eda_3d_canvas.h.

Referenced by DoRePaint(), move_pivot_based_on_cur_mouse_position(), OnMouseMove(), OnMouseWheel(), ReloadRequest(), and RenderEngineChanged().

m_camera

CAMERA& EDA_3D_CANVAS::m_camera

private

Definition at line 276 of file eda_3d_canvas.h.

Referenced by DisplayStatus(), DoRePaint(), getRayAtCurrrentMousePosition(), move_pivot_based_on_cur_mouse_position(), OnMouseMove(), OnMouseWheel(), render_pivot(), request_start_moving_camera(), and SetView3D().

m_camera_is_moving

bool EDA_3D_CANVAS::m_camera_is_moving

private

Definition at line 268 of file eda_3d_canvas.h.

Referenced by DoRePaint(), OnLeftUp(), OnMiddleUp(), OnMouseMove(), OnMouseWheel(), request_start_moving_camera(), and SetView3D().

m_camera_moving_speed

float EDA_3D_CANVAS::m_camera_moving_speed

private

Definition at line 270 of file eda_3d_canvas.h.

Referenced by DoRePaint(), and request_start_moving_camera().

m_currentIntersectedBoardItem

BOARD_ITEM* EDA_3D_CANVAS::m_currentIntersectedBoardItem

private

Definition at line 290 of file eda_3d_canvas.h.

Referenced by OnMouseMove().

m_delta_move_step_factor

const float EDA_3D_CANVAS::m_delta_move_step_factor = 0.7f

staticprivate

Definition at line 281 of file eda_3d_canvas.h.

Referenced by OnMouseWheel(), and SetView3D().

m_editing_timeout_timer

wxTimer EDA_3D_CANVAS::m_editing_timeout_timer

private

Definition at line 261 of file eda_3d_canvas.h.

Referenced by restart_editingTimeOut_Timer(), and stop_editingTimeOut_Timer().

m_eventDispatcher

TOOL_DISPATCHER* EDA_3D_CANVAS::m_eventDispatcher

private

Definition at line 253 of file eda_3d_canvas.h.

Referenced by OnEvent(), and SetEventDispatcher().

m_glRC

wxGLContext* EDA_3D_CANVAS::m_glRC

private

Definition at line 257 of file eda_3d_canvas.h.

Referenced by DoRePaint(), and releaseOpenGL().

m_is_currently_painting

std::atomic_flag EDA_3D_CANVAS::m_is_currently_painting

private

Definition at line 264 of file eda_3d_canvas.h.

Referenced by DoRePaint().

m_is_opengl_initialized

bool EDA_3D_CANVAS::m_is_opengl_initialized

private

Definition at line 258 of file eda_3d_canvas.h.

Referenced by DoRePaint(), and initializeOpenGL().

m_is_opengl_version_supported

bool EDA_3D_CANVAS::m_is_opengl_version_supported

private

Definition at line 259 of file eda_3d_canvas.h.

Referenced by DoRePaint(), and initializeOpenGL().

m_mouse_is_moving

bool EDA_3D_CANVAS::m_mouse_is_moving

private

Definition at line 266 of file eda_3d_canvas.h.

Referenced by DoRePaint(), OnLeftUp(), OnMiddleUp(), OnMouseMove(), OnMouseWheel(), and OnTimerTimeout_Editing().

m_mouse_was_moved

bool EDA_3D_CANVAS::m_mouse_was_moved

private

Definition at line 267 of file eda_3d_canvas.h.

Referenced by DoRePaint(), OnMouseMove(), OnMouseWheel(), OnTimerTimeout_Editing(), RenderEngineChanged(), and SetView3D().

m_moving_speed_multiplier

int EDA_3D_CANVAS::m_moving_speed_multiplier

private

Definition at line 273 of file eda_3d_canvas.h.

Referenced by MovingSpeedMultiplierGet(), MovingSpeedMultiplierSet(), and request_start_moving_camera().

m_opengl_supports_raytracing

bool EDA_3D_CANVAS::m_opengl_supports_raytracing

private

Definition at line 284 of file eda_3d_canvas.h.

Referenced by DoRePaint(), and initializeOpenGL().

m_parentInfoBar

WX_INFOBAR* EDA_3D_CANVAS::m_parentInfoBar

private

Definition at line 255 of file eda_3d_canvas.h.

Referenced by DoRePaint(), and SetInfoBar().

m_parentStatusBar

wxStatusBar* EDA_3D_CANVAS::m_parentStatusBar

private

Definition at line 254 of file eda_3d_canvas.h.

Referenced by DisplayStatus(), DoRePaint(), OnMouseMove(), and SetStatusBar().

m_redraw_trigger_timer

wxTimer EDA_3D_CANVAS::m_redraw_trigger_timer

private

Definition at line 263 of file eda_3d_canvas.h.

Referenced by Request_refresh().

m_render_pivot

bool EDA_3D_CANVAS::m_render_pivot

private

Definition at line 269 of file eda_3d_canvas.h.

Referenced by DoRePaint(), and request_start_moving_camera().

m_render_raytracing_was_requested

bool EDA_3D_CANVAS::m_render_raytracing_was_requested

private

Definition at line 285 of file eda_3d_canvas.h.

Referenced by DoRePaint(), and RenderRaytracingRequest().

m_strtime_camera_movement

unsigned EDA_3D_CANVAS::m_strtime_camera_movement

private

Definition at line 271 of file eda_3d_canvas.h.

Referenced by DoRePaint(), and request_start_moving_camera().

---

The documentation for this class was generated from the following files:

• eda_3d_canvas.h
• eda_3d_canvas.cpp
• eda_3d_canvas_pivot.cpp