render_3d_opengl.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 The 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, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef RENDER_3D_OPENGL_H
#define RENDER_3D_OPENGL_H
 
#include <kicad_gl/kiglad.h> // Must be included first
 
#include "../render_3d_base.h"
#include "layer_triangles.h"
#include "3d_spheres_gizmo.h"
 
#include "../raytracing/shapes2D/polygon_2d.h"
#include "../raytracing/shapes2D/triangle_2d.h"
#include "../raytracing/shapes2D/4pt_polygon_2d.h"
#include "../raytracing/shapes2D/filled_circle_2d.h"
#include "../raytracing/shapes2D/ring_2d.h"
#include "../raytracing/shapes2D/round_segment_2d.h"
 
#include "3d_model.h"
 
#include "3d_cache/3d_info.h"
 
#include <geometry/eda_angle.h>
#include <pad.h> // For PAD_DRILL_POST_MACHINING_MODE
 
#include <atomic>
#include <map>
#include <memory>
#include <stop_token>
#include <thread>
 
typedef std::map<PCB_LAYER_ID, std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED>> MAP_OGL_DISP_LISTS;
typedef std::list<std::shared_ptr<TRIANGLE_DISPLAY_LIST>>                    LIST_TRIANGLES;
 
#define SIZE_OF_CIRCLE_TEXTURE 1024

class RENDER_3D_OPENGL : public RENDER_3D_BASE
{
public:
    explicit RENDER_3D_OPENGL( EDA_3D_CANVAS* aCanvas, BOARD_ADAPTER& aAdapter, CAMERA& aCamera );
 
    ~RENDER_3D_OPENGL();
 
    void SetCurWindowSize( const wxSize& aSize ) override;
    bool Redraw( bool aIsMoving ) override;
 
    int GetWaitForEditingTimeOut() override;
 
    void JoinBgWorker() override;
    void StopBgWorker() override;
 
    void SetCurrentRollOverItem( BOARD_ITEM* aRollOverItem )
    {
        m_currentRollOverItem = aRollOverItem;
    }

    void Load3dModelsIfNeeded();

    void RebuildHitTestAsync();
 
    void                                handleGizmoMouseInput( int mouseX, int mouseY );
    void                                updateGizmoSelection( glm::mat4 aCameraRotationMatrix );
    void                                setGizmoViewport( int x, int y, int width, int height );
    std::tuple<int, int, int, int>      getGizmoViewport() const;
    SPHERES_GIZMO::GizmoSphereSelection getSelectedGizmoSphere() const;
    void                                resetSelectedGizmoSphere();
 
private:
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> generateHoles( const LIST_OBJECT2D& aListHolesObject2d,
                                       const SHAPE_POLY_SET& aPoly, float aZtop, float aZbot,
                                       bool aInvertFaces,
                                       const BVH_CONTAINER_2D* aThroughHoles = nullptr );
 
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> generateLayerList( const BVH_CONTAINER_2D* aContainer,
                                           const SHAPE_POLY_SET* aPolyList, PCB_LAYER_ID aLayer,
                                           const BVH_CONTAINER_2D* aThroughHoles = nullptr );
 
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> generateEmptyLayerList( PCB_LAYER_ID aLayer );
 
    void addTopAndBottomTriangles( std::shared_ptr<TRIANGLE_DISPLAY_LIST> aDst, const SFVEC2F& v0,
                                   const SFVEC2F& v1, const SFVEC2F& v2, float top, float bot );
 
    void addObjectTriangles( const RING_2D* aRing, std::shared_ptr<TRIANGLE_DISPLAY_LIST> aDstLayer,
                             float aZtop, float aZbot );
 
    void addObjectTriangles( const POLYGON_4PT_2D* aPoly, std::shared_ptr<TRIANGLE_DISPLAY_LIST> aDstLayer,
                             float aZtop, float aZbot );
 
    void addObjectTriangles( const FILLED_CIRCLE_2D* aCircle, std::shared_ptr<TRIANGLE_DISPLAY_LIST> aDstLayer,
                             float aZtop, float aZbot );
 
    void addObjectTriangles( const TRIANGLE_2D* aTri, std::shared_ptr<TRIANGLE_DISPLAY_LIST> aDstLayer,
                             float aZtop, float aZbot );
 
    void addObjectTriangles( const ROUND_SEGMENT_2D* aSeg, std::shared_ptr<TRIANGLE_DISPLAY_LIST> aDstLayer,
                             float aZtop, float aZbot );
 
    void renderSolderMaskLayer( PCB_LAYER_ID aLayerID, float aZPos, bool aShowThickness,
                                bool aSkipRenderHoles );
 
    void renderBoardBody( bool aSkipRenderHoles );
 
    void getLayerZPos( PCB_LAYER_ID aLayerID, float& aOutZtop, float& aOutZbot ) const;
 
    void generateRing( const SFVEC2F& aCenter, float aInnerRadius, float aOuterRadius,
                       unsigned int aNr_sides_per_circle,
                       std::vector< SFVEC2F >& aInnerContourResult,
                       std::vector< SFVEC2F >& aOuterContourResult, bool aInvertOrder );
 
    void generateCylinder( const SFVEC2F& aCenter, float aInnerRadius, float aOuterRadius,
                           float aZtop, float aZbot, unsigned int aNr_sides_per_circle,
                           std::shared_ptr<TRIANGLE_DISPLAY_LIST> aDstLayer );
 
    void generateInvCone( const SFVEC2F& aCenter, float aInnerRadius, float aOuterRadius,
                          float aZtop, float aZbot, unsigned int aNr_sides_per_circle,
                          std::shared_ptr<TRIANGLE_DISPLAY_LIST> aDstLayer, EDA_ANGLE aAngle );
 
    void generateDisk( const SFVEC2F& aCenter, float aRadius, float aZ,
                       unsigned int aNr_sides_per_circle, std::shared_ptr<TRIANGLE_DISPLAY_LIST> aDstLayer,
                       bool aTop );
 
    void generateDimple( const SFVEC2F& aCenter, float aRadius, float aZ, float aDepth,
                         unsigned int aNr_sides_per_circle, std::shared_ptr<TRIANGLE_DISPLAY_LIST> aDstLayer,
                         bool aTop );
 
    void generateViasAndPads();
 
    bool appendPostMachiningGeometry( std::shared_ptr<TRIANGLE_DISPLAY_LIST> aDstLayer,
                                      const SFVEC2F& aHoleCenter,
                                      PAD_DRILL_POST_MACHINING_MODE aMode,
                                      int aSizeIU,
                                      int aDepthIU,
                                      float aHoleInnerRadius,
                                      float aZSurface,
                                      bool aIsFront,
                                      float aPlatingThickness3d,
                                      float aUnitScale,
                                      float* aZEnd );
 
    void generateViaBarrels( float aPlatingThickness3d, float aUnitScale );
 
    void generatePlatedHoleShells( int aPlatingThickness, float aUnitScale );
 
    void generateViaCovers( float aPlatingThickness3d, float aUnitScale );

    void load3dModels( std::stop_token aStop = std::stop_token() );
 
    void createPlaceholderModel();
    struct MODELTORENDER
    {
        glm::mat4 m_modelWorldMat;
        std::shared_ptr<MODEL_3D> m_model;
        float m_opacity;
        bool m_isTransparent;
        bool m_isSelected;
 
        MODELTORENDER( glm::mat4 aModelWorldMat,
                       std::shared_ptr<MODEL_3D> aModel,
                       float aOpacity,
                       bool aIsTransparent,
                       bool aIsSelected ) :
                       m_modelWorldMat( std::move( aModelWorldMat ) ),
                       m_model( std::move( aModel ) ),
                       m_opacity( aOpacity ),
                       m_isTransparent( aIsTransparent ),
                       m_isSelected( aIsSelected )
        {
        }
    };
 
    void renderPlaceholderForFootprint( std::list<MODELTORENDER>& aDstRenderList, const glm::mat4& aFpMatrix,
                                        const FOOTPRINT* aFootprint, bool aRenderTransparentOnly, bool aIsSelected,
                                        float aOpacity );
 
    void renderExtrudedBodies();
 
    void renderOpaqueModels( const glm::mat4 &aCameraViewMatrix );
 
    void renderExtrudedBodies( bool aTransparentPass );
 
    void renderTransparentModels( const glm::mat4 &aCameraViewMatrix );
 
    void renderModel( const glm::mat4 &aCameraViewMatrix, const MODELTORENDER &aModelToRender,
                      const SFVEC3F &aSelColor, const SFVEC3F *aCameraWorldPos );
 
 
    void get3dModelsSelected( std::list<MODELTORENDER> &aDstRenderList, bool aGetTop, bool aGetBot,
                              bool aRenderTransparentOnly, bool aRenderSelectedOnly );
 
    void get3dModelsFromFootprint( std::list<MODELTORENDER> &aDstRenderList,
                                   const FOOTPRINT* aFootprint, bool aRenderTransparentOnly,
                                   bool aIsSelected );
 
    void setLightFront( bool enabled );
    void setLightTop( bool enabled );
    void setLightBottom( bool enabled );

    void generate3dGrid( GRID3D_TYPE aGridType );
 
    // Materials
    void setupMaterials();
 
    void setCopperMaterial();
    void setPlatedCopperAndDepthOffset( PCB_LAYER_ID aLayer_id );
    void unsetDepthOffset();
 
    void setLayerMaterial( PCB_LAYER_ID aLayerID );
 
    bool initializeOpenGL();
 
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> createBoard( const SHAPE_POLY_SET&   aBoardPoly,
                                                              const BVH_CONTAINER_2D* aThroughHoles = nullptr,
                                                              bool                    aTransparent = false );

    void backfillPostMachine();
 
    void reload();
 
    void setArrowMaterial();
 
    void freeAllLists();
 
    void releaseRetiredRenderPtrs();
 
    void startBgWorker();
    void bgWorker( std::stop_token aStop );
    void runHitTestRebuild( std::stop_token aStop );
    void sendRefreshView();
 
    struct
    {
        SMATERIAL m_Paste;
        SMATERIAL m_SilkSBot;
        SMATERIAL m_SilkSTop;
        SMATERIAL m_SolderMask;
        SMATERIAL m_EpoxyBoard;
        SMATERIAL m_NonPlatedCopper; // raw copper
        SMATERIAL m_Copper;
        SMATERIAL m_Plastic;
        SMATERIAL m_GrayMaterial;
    } m_materials;
 
    EDA_3D_CANVAS*       m_canvas;
    std::jthread         m_bgWorkerThread;
    std::atomic<bool>    m_bgWorkerBusy{ false };
    std::atomic<bool>    m_hitTestDirty{ false };
    std::recursive_mutex m_renderMutex;
 
private:
    // Helper functions for safe access
    template <typename T>
    void assignRenderPtr( std::shared_ptr<T>& aDst, std::shared_ptr<T> aVal )
    {
        std::lock_guard lock( m_renderMutex );
        retireRenderPtr( aDst );
        aDst = std::move( aVal );
    }
 
    template <typename TMap>
    void assignRenderMap( TMap& aMap, const typename TMap::key_type& aKey, typename TMap::mapped_type aVal )
    {
        std::lock_guard lock( m_renderMutex );
        typename TMap::mapped_type& slot = aMap[aKey];
        retireRenderPtr( slot );
        slot = std::move( aVal );
    }
 
    template <typename T>
    void retireRenderPtr( std::shared_ptr<T>& aPtr )
    {
        if( aPtr )
            m_retiredRenderPtrs.push_back( std::move( aPtr ) );
    }
 
    void appendRenderTriangleList( std::shared_ptr<TRIANGLE_DISPLAY_LIST> aTriangles )
    {
        std::lock_guard lock( m_renderMutex );
        m_triangles.push_back( std::move( aTriangles ) );
    }
 
private:
    // Access to the following members must be protected by m_renderMutex:
    MAP_OGL_DISP_LISTS  m_layers;
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_platedPadsFront;
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_platedPadsBack;
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_offboardPadsFront;
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_offboardPadsBack;
    MAP_OGL_DISP_LISTS  m_outerLayerHoles;
    MAP_OGL_DISP_LISTS  m_innerLayerHoles;
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_board;
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_boardWithHoles;
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_postMachinePlugs;     
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_antiBoard;
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_outerThroughHoles;
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_outerViaThroughHoles;
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_outerThroughHoleRings;
    std::vector<std::shared_ptr<void>>           m_retiredRenderPtrs;
 
    LIST_TRIANGLES      m_triangles;       
    GLuint              m_circleTexture;
 
    GLuint              m_grid;             
    GRID3D_TYPE         m_lastGridType;     
 
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_microviaHoles;
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_padHoles;
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_viaFrontCover;
    std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED> m_viaBackCover;
 
    // Caches
    std::map<wxString, std::shared_ptr<MODEL_3D_DEFERRED>> m_3dModelMap;
    std::map<std::vector<float>, glm::mat4>                m_3dModelMatrixMap;
 
    BOARD_ITEM*         m_currentRollOverItem;
 
    SHAPE_POLY_SET m_antiBoardPolys; 
    SPHERES_GIZMO* m_spheres_gizmo;
    std::shared_ptr<MODEL_3D>      m_placeholderModel = nullptr;
 
    std::map<const FOOTPRINT*, std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED>> m_extrudedBodyLists;
    std::map<const FOOTPRINT*, std::shared_ptr<OPENGL_RENDER_LIST_DEFERRED>> m_extrudedPadLists;
};
 
#endif // RENDER_3D_OPENGL_H