camera.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2015-2016 Mario Luzeiro <[email protected]>
 * Copyright (C) 2015-2024 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#ifndef CAMERA_H
#define CAMERA_H
 
#include <gal/gal.h>
#include <plugins/3dapi/xv3d_types.h>
#include <wx/gdicmn.h>  // for wxSize
#include <vector>
#include <3d_enums.h>
 
enum class PROJECTION_TYPE
{
    ORTHO = 0,
    PERSPECTIVE
};
 
struct CAMERA_FRUSTUM
{
    SFVEC3F nc;
    SFVEC3F fc;
    SFVEC3F ntl; 
    SFVEC3F ntr; 
    SFVEC3F nbl; 
    SFVEC3F nbr; 
    SFVEC3F ftl; 
    SFVEC3F ftr; 
    SFVEC3F fbl; 
    SFVEC3F fbr; 
    float nearD, farD, ratio, angle, tang;
    float nw, nh, fw, fh;
 
    CAMERA_FRUSTUM() :
        nc( { 0.0, 0.0, 0.0 } ),
        fc( { 0.0, 0.0, 0.0 } ),
        ntl( { 0.0, 0.0, 0.0 } ),
        ntr( { 0.0, 0.0, 0.0 } ),
        nbl( { 0.0, 0.0, 0.0 } ),
        nbr( { 0.0, 0.0, 0.0 } ),
        ftl( { 0.0, 0.0, 0.0 } ),
        ftr( { 0.0, 0.0, 0.0 } ),
        fbl( { 0.0, 0.0, 0.0 } ),
        fbr( { 0.0, 0.0, 0.0 } ),
        nearD( 0.0 ),
        farD( 0.0 ),
        ratio( 1.0 ),
        angle( 0.0 ),
        tang( 0.0 ),
        nw( 0.0 ),
        nh( 0.0 ),
        fw( 0.0 ),
        fh( 0.0 )
    {
    }
};
 
 
enum class CAMERA_INTERPOLATION
{
    LINEAR,
    EASING_IN_OUT, // Quadratic
    BEZIER,
};
 
 
class GAL_API CAMERA
{
public:
    static const float DEFAULT_MIN_ZOOM;
    static const float DEFAULT_MAX_ZOOM;
 
    explicit CAMERA( float aInitialDistance );
    explicit CAMERA( SFVEC3F aInitPos, SFVEC3F aLookat, PROJECTION_TYPE aProjectionType );
 
    virtual ~CAMERA()
    {
    }
 
    glm::mat4 GetRotationMatrix() const;
 
    const glm::mat4& GetViewMatrix() const;
    const glm::mat4& GetViewMatrix_Inv() const;
 
    const glm::mat4& GetProjectionMatrix() const;
    const glm::mat4& GetProjectionMatrixInv() const;
 
    const SFVEC3F& GetRight()    const { return m_right; }
    const SFVEC3F& GetUp()       const { return m_up; }
    const SFVEC3F& GetDir()      const { return m_dir; }
    const SFVEC3F& GetPos()      const { return m_pos; }
    const SFVEC2F& GetFocalLen() const { return m_focalLen; }
    float GetNear() const { return m_frustum.nearD; }
    float GetFar() const { return m_frustum.farD; }
    const CAMERA_FRUSTUM& GetFrustum() const { return m_frustum; }
    const SFVEC3F&        GetLookAtPos() const { return m_lookat_pos; }
 
    void SetRotationMatrix( const glm::mat4& aRotation );
 
    void SetViewMatrix( glm::mat4 aViewMatrix );
 
    void SetBoardLookAtPos( const SFVEC3F& aBoardPos );
 
    void SetLookAtPos_T1( const SFVEC3F& aLookAtPos )
    {
        m_lookat_pos_t1 = aLookAtPos;
    }
 
    const SFVEC3F& GetLookAtPos_T1() const { return m_lookat_pos_t1; }
 
    const SFVEC3F& GetCameraPos() const { return m_camera_pos; }
    const SFVEC3F& GetCameraInitPos() const { return m_camera_pos_init; }
 
    float GetCameraMinDimension() const;
 
    virtual void Drag( const wxPoint& aNewMousePosition )  = 0;
 
    virtual void Pan( const wxPoint& aNewMousePosition )  = 0;
 
    virtual void Pan( const SFVEC3F& aDeltaOffsetInc )  = 0;
 
    virtual void Pan_T1( const SFVEC3F& aDeltaOffsetInc )  = 0;
 
    virtual void Reset();
    virtual void Reset_T1();
 
    void ResetXYpos();
    void ResetXYpos_T1();
 
    const wxPoint& GetCurMousePosition() { return m_lastPosition; }
 
    void SetCurMousePosition( const wxPoint& aPosition );
 
    void ToggleProjection();
    PROJECTION_TYPE GetProjection() { return m_projectionType; }
    void SetProjection( PROJECTION_TYPE aProjection ) { m_projectionType = aProjection; }
 
    bool SetCurWindowSize( const wxSize& aSize );
 
    void ZoomReset();
 
    bool Zoom( float aFactor );
 
    bool Zoom_T1( float aFactor );
 
    float GetZoom() const { return m_zoom; }
 
    float GetMinZoom() { return m_minZoom; }
    void  SetMinZoom( float minZoom )
    {
        m_minZoom = minZoom;
        zoomChanged();
    }
 
    float GetMaxZoom() { return m_maxZoom; }
    void  SetMaxZoom( float maxZoom )
    {
        m_maxZoom = maxZoom;
        zoomChanged();
    }
 
    bool ViewCommand_T1( VIEW3D_TYPE aRequestedView );
 
    void RotateScreen( float aAngleInRadians );
 
    void RotateX( float aAngleInRadians );
    void RotateY( float aAngleInRadians );
    void RotateZ( float aAngleInRadians );
 
    void RotateX_T1( float aAngleInRadians );
    void RotateY_T1( float aAngleInRadians );
    void RotateZ_T1( float aAngleInRadians );
 
    virtual void SetT0_and_T1_current_T();
 
    virtual void Interpolate( float t );
 
    void SetInterpolateMode( CAMERA_INTERPOLATION aInterpolateMode )
    {
        m_interpolation_mode = aInterpolateMode;
    }
 
    bool ParametersChanged();
 
    bool ParametersChangedQuery() const { return m_parametersChanged; }
 
    void MakeRay( const SFVEC2I& aWindowPos, SFVEC3F& aOutOrigin, SFVEC3F& aOutDirection ) const;
 
    void MakeRay( const SFVEC2F& aWindowPos, SFVEC3F& aOutOrigin, SFVEC3F& aOutDirection ) const;
 
    void MakeRayAtCurrentMousePosition( SFVEC3F& aOutOrigin, SFVEC3F& aOutDirection ) const;
 
    void Update() { updateFrustum(); }
 
protected:
    void zoomChanged();
    void rebuildProjection();
    void updateFrustum();
    void updateViewMatrix();
 
    void updateRotationMatrix();
 
    float m_zoom;
    float m_zoom_t0;
    float m_zoom_t1;
 
    float m_minZoom;
    float m_maxZoom;
 
    SFVEC2I m_windowSize;
 
    wxPoint m_lastPosition;
 
    glm::mat4 m_rotationMatrix;
    glm::mat4 m_rotationMatrixAux;
    glm::mat4 m_viewMatrix;
    glm::mat4 m_viewMatrixInverse;
    glm::mat4 m_projectionMatrix;
    glm::mat4 m_projectionMatrixInv;
    PROJECTION_TYPE m_projectionType;
 
    CAMERA_FRUSTUM m_frustum;
 
    SFVEC3F m_right;
    SFVEC3F m_up;
    SFVEC3F m_dir;
    SFVEC3F m_pos;
 
    SFVEC2F m_focalLen;
 
    SFVEC3F m_camera_pos_init;
    SFVEC3F m_camera_pos;
    SFVEC3F m_camera_pos_t0;
    SFVEC3F m_camera_pos_t1;
 
    SFVEC3F m_lookat_pos;
    SFVEC3F m_lookat_pos_t0;
    SFVEC3F m_lookat_pos_t1;
    SFVEC3F m_board_lookat_pos_init;    
 
    SFVEC3F m_rotate_aux;               
    SFVEC3F m_rotate_aux_t0;
    SFVEC3F m_rotate_aux_t1;
 
    CAMERA_INTERPOLATION m_interpolation_mode;
 
    std::vector< float > m_scr_nX;
    std::vector< float > m_scr_nY;
 
    std::vector< SFVEC3F > m_right_nX;
    std::vector< SFVEC3F > m_up_nY;
 
    bool m_parametersChanged;
 
    static const wxChar* m_logTrace;
};
 
#endif // CAMERA_H