board_adapter.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) 2023 CERN
 * 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 BOARD_ADAPTER_H
#define BOARD_ADAPTER_H
 
#include <array>
#include <optional>
#include <vector>
#include "../3d_rendering/raytracing/accelerators/container_2d.h"
#include "../3d_rendering/raytracing/accelerators/container_3d.h"
#include "../3d_rendering/raytracing/shapes3D/bbox_3d.h"
#include <gal/3d/camera.h>
#include <3d_enums.h>
#include "../3d_cache/3d_cache.h"
#include "../common_ogl/ogl_attr_list.h"
#include "../3d_viewer/eda_3d_viewer_settings.h"
 
#include <layer_ids.h>
#include <pcb_base_frame.h>
#include <pcb_text.h>
#include <pcb_textbox.h>
#include <pcb_table.h>
#include <pcb_shape.h>
#include <pcb_dimension.h>
#include <reporter.h>
#include <dialogs/dialog_color_picker.h>
#include <stop_token>
 
class COLOR_SETTINGS;
class FOOTPRINT;
class PAD;
class PCB_BARCODE;
class PCB_TEXTBOX;
class PCB_TRACK;
class ZONE;

typedef std::map<PCB_LAYER_ID, BVH_CONTAINER_2D*> MAP_CONTAINER_2D_BASE;

typedef std::map<PCB_LAYER_ID, SHAPE_POLY_SET*> MAP_POLY;

#define RANGE_SCALE_3D 8.0f
 

class BOARD_ADAPTER
{
public:
    BOARD_ADAPTER();
 
    ~BOARD_ADAPTER();

    void Set3dCacheManager( S3D_CACHE* aCacheMgr ) noexcept { m_3dModelManager = aCacheMgr; }
    S3D_CACHE* Get3dCacheManager() const noexcept { return m_3dModelManager; }

    bool Is3dLayerEnabled( PCB_LAYER_ID aLayer, const std::bitset<LAYER_3D_END>& aVisibilityFlags ) const;

    bool IsFootprintShown( const FOOTPRINT* aFootprint ) const;

    wxString GetFootprintLibraryPath( const FOOTPRINT* aFootprint ) const;

    void SetBoard( BOARD* aBoard ) noexcept { m_board = aBoard; }
    const BOARD* GetBoard() const noexcept { return m_board; }
 
    void ReloadColorSettings() noexcept;

    std::map<int, COLOR4D> GetLayerColors() const;
 
    std::map<int, COLOR4D> GetDefaultColors() const;
    void SetLayerColors( const std::map<int, COLOR4D>& aColors );
 
    std::bitset<LAYER_3D_END> GetVisibleLayers() const;
    std::bitset<LAYER_3D_END> GetDefaultVisibleLayers() const;
    void SetVisibleLayers( const std::bitset<LAYER_3D_END>& aLayers );

    void SetVisibilityOverride( const std::optional<std::bitset<LAYER_3D_END>>& aLayers )
    {
        m_visibilityOverride = aLayers;
    }
 
    bool GetUseBoardEditorCopperLayerColors() const;

    void InitSettings( std::shared_ptr<REPORTER> aStatusReporter, std::shared_ptr<REPORTER> aWarningReporter );

    void CreateLayers( std::shared_ptr<REPORTER> aStatusReporter, std::stop_token aStop = std::stop_token() );

    double BiuTo3dUnits() const noexcept { return m_biuTo3Dunits; }

    const BBOX_3D& GetBBox() const noexcept { return m_boardBoundingBox; }

    float GetBoardBodyThickness() const noexcept { return m_boardBodyThickness3DU; }

    float GetNonCopperLayerThickness() const noexcept { return m_nonCopperLayerThickness3DU; }

    float GetFrontCopperThickness() const noexcept { return m_frontCopperThickness3DU; }
    float GetBackCopperThickness() const noexcept { return m_backCopperThickness3DU; }

    int GetHolePlatingThickness() const noexcept;

    VECTOR2I GetBoardSize() const noexcept { return m_boardSize; }

    VECTOR2I GetBoardPos() const noexcept { return m_boardPos; }

    const SFVEC3F& GetBoardCenter() const noexcept { return m_boardCenter; }

    float GetFootprintZPos( bool aIsFlipped ) const ;

    glm::mat4 GetFootprintMatrix( const FOOTPRINT& aFootprint ) const;

    const SHAPE_POLY_SET& GetBoardPoly() const noexcept { return m_board_poly; }

    SFVEC4F GetLayerColor( int aLayerId ) const;

    SFVEC4F GetColor( const COLOR4D& aColor ) const;
 
    SFVEC2F GetSphericalCoord( int i ) const;

    float GetLayerTopZPos( PCB_LAYER_ID aLayerId ) const noexcept
    {
        auto it = m_layerZcoordTop.find( aLayerId );
 
        if( it != m_layerZcoordTop.end() )
            return it->second;
        else
            return -( m_boardBodyThickness3DU / 2.0f );
    }

    float GetLayerBottomZPos( PCB_LAYER_ID aLayerId ) const noexcept
    {
        auto it = m_layerZcoordBottom.find( aLayerId );
 
        if( it != m_layerZcoordBottom.end() )
            return it->second;
        else
            return -( m_boardBodyThickness3DU / 2.0f ) - m_backCopperThickness3DU;
    }

    const MAP_CONTAINER_2D_BASE& GetLayerMap() const noexcept { return m_layerMap; }
    const BVH_CONTAINER_2D* GetPlatedPadsFront() const noexcept { return m_platedPadsFront; }
    const BVH_CONTAINER_2D* GetPlatedPadsBack() const noexcept { return m_platedPadsBack; }
    const BVH_CONTAINER_2D* GetOffboardPadsFront() const noexcept { return m_offboardPadsFront; }
    const BVH_CONTAINER_2D* GetOffboardPadsBack() const noexcept { return m_offboardPadsBack; }
 
    const MAP_CONTAINER_2D_BASE& GetLayerHoleMap() const noexcept { return m_layerHoleMap; }
    const BVH_CONTAINER_2D& GetTH_IDs() const noexcept { return m_TH_IDs; }
    const BVH_CONTAINER_2D& GetTH_ODs() const noexcept { return m_TH_ODs; }

    const SHAPE_POLY_SET& GetTH_ODPolys() const noexcept
    {
        return m_TH_ODPolys;
    }
 
    const BVH_CONTAINER_2D& GetViaAnnuli() const noexcept
    {
        return m_viaAnnuli;
    }
 
    const SHAPE_POLY_SET& GetViaAnnuliPolys() const noexcept
    {
        return m_viaAnnuliPolys;
    }
 
    const SHAPE_POLY_SET& GetNPTH_ODPolys() const noexcept
    {
        return m_NPTH_ODPolys;
    }

    const BVH_CONTAINER_2D& GetViaTH_ODs() const noexcept
    {
        return m_viaTH_ODs;
    }
 
    const SHAPE_POLY_SET& GetViaTH_ODPolys() const noexcept
    {
        return m_viaTH_ODPolys;
    }

    const SHAPE_POLY_SET& GetSecondarydrillPolys() const noexcept
    {
        return m_SecondarydrillPolys;
    }
 
    const SHAPE_POLY_SET& GetTertiarydrillPolys() const noexcept
    {
        return m_TertiarydrillPolys;
    }
 
    const BVH_CONTAINER_2D& GetBackdrillCutouts() const noexcept
    {
        return m_backdrillCutouts;
    }
 
    const BVH_CONTAINER_2D& GetTertiarydrillCutouts() const noexcept
    {
        return m_tertiarydrillCutouts;
    }

    const BVH_CONTAINER_2D& GetFrontCounterboreCutouts() const noexcept
    {
        return m_frontCounterboreCutouts;
    }

    const BVH_CONTAINER_2D& GetBackCounterboreCutouts() const noexcept
    {
        return m_backCounterboreCutouts;
    }

    const BVH_CONTAINER_2D& GetFrontCountersinkCutouts() const noexcept
    {
        return m_frontCountersinkCutouts;
    }

    const BVH_CONTAINER_2D& GetBackCountersinkCutouts() const noexcept
    {
        return m_backCountersinkCutouts;
    }

    const SHAPE_POLY_SET& GetFrontCounterborePolys() const noexcept
    {
        return m_frontCounterborePolys;
    }

    const SHAPE_POLY_SET& GetBackCounterborePolys() const noexcept
    {
        return m_backCounterborePolys;
    }

    const SHAPE_POLY_SET& GetFrontCountersinkPolys() const noexcept
    {
        return m_frontCountersinkPolys;
    }

    const SHAPE_POLY_SET& GetBackCountersinkPolys() const noexcept
    {
        return m_backCountersinkPolys;
    }
 
    unsigned int GetViaCount() const noexcept { return m_viaCount; }
    unsigned int GetHoleCount() const noexcept { return m_holeCount; }

    float GetAverageViaHoleDiameter() const noexcept { return m_averageViaHoleDiameter; }

    float GetAverageHoleDiameter() const noexcept { return m_averageHoleDiameter; }

    float GetAverageTrackWidth() const noexcept { return m_averageTrackWidth; }

    unsigned int GetCircleSegmentCount( float aDiameter3DU ) const;

    unsigned int GetCircleSegmentCount( int aDiameterBIU ) const;

    const MAP_POLY& GetPolyMap() const noexcept { return m_layers_poly; }
 
    const SHAPE_POLY_SET* GetFrontPlatedCopperPolys()
    {
        return m_frontPlatedCopperPolys;
    }
 
    const SHAPE_POLY_SET* GetBackPlatedCopperPolys()
    {
        return m_backPlatedCopperPolys;
    }
 
    const MAP_POLY& GetHoleIdPolysMap() const noexcept { return m_layerHoleIdPolys; }
    const MAP_POLY& GetHoleOdPolysMap() const noexcept { return m_layerHoleOdPolys; }
 
    bool ShowMissingModels()
    {
        return m_IsPreviewer || m_Cfg->m_Render.show_missing_models;
    }
 
private:
    bool createBoardPolygon( wxString* aErrorMsg );
    void createLayers( std::shared_ptr<REPORTER> aStatusReporter, std::stop_token aStop );
    void destroyLayers();
 
    // Helper functions to create the board
    void createTrackWithMargin( const PCB_TRACK* aTrack, CONTAINER_2D_BASE* aDstContainer, PCB_LAYER_ID aLayer,
                                int aMargin = 0 );
 
    // Generate the pad shape on board layers. The pad hole is not generated by createPadWithMargin
    void createPadWithMargin( const PAD *aPad, CONTAINER_2D_BASE* aDstContainer, PCB_LAYER_ID aLayer,
                              const VECTOR2I& aMargin ) const;
 
    // Generate the hole shape of aPad, stored in aDstContainer
    void createPadHoleShape( const PAD* aPad, CONTAINER_2D_BASE* aDstContainer, int aInflateValue );
 
    void addPads( const FOOTPRINT* aFootprint, CONTAINER_2D_BASE* aDstContainer, PCB_LAYER_ID aLayerId );
 
    void addFootprintShapes( const FOOTPRINT* aFootprint, CONTAINER_2D_BASE* aDstContainer, PCB_LAYER_ID aLayerId,
                             const std::bitset<LAYER_3D_END>& aVisibilityFlags );
 
    void addText( const EDA_TEXT* aText, CONTAINER_2D_BASE* aDstContainer, const BOARD_ITEM* aOwner );
 
    void addBarCode( const PCB_BARCODE* aBarCode, CONTAINER_2D_BASE* aDstContainer, const BOARD_ITEM* aOwner );
 
    void addShape( const PCB_SHAPE* aShape, CONTAINER_2D_BASE* aContainer, const BOARD_ITEM* aOwner,
                   PCB_LAYER_ID aLayer );
 
    void addShape( const PCB_DIMENSION_BASE* aDimension, CONTAINER_2D_BASE* aDstContainer, const BOARD_ITEM* aOwner );
 
    void addShape( const PCB_TEXTBOX* aTextBox, CONTAINER_2D_BASE* aContainer, const BOARD_ITEM* aOwner );
 
    void addTable( const PCB_TABLE* aTable, CONTAINER_2D_BASE* aContainer, const BOARD_ITEM* aOwner );
 
    void addSolidAreasShapes( const ZONE* aZone, CONTAINER_2D_BASE* aDstContainer, PCB_LAYER_ID aLayerId );
 
    void createArcSegments( const VECTOR2I& aCentre, const VECTOR2I& aStart, const EDA_ANGLE& aArcAngle,
                            int aCircleToSegmentsCount, int aWidth, CONTAINER_2D_BASE* aContainer,
                            const BOARD_ITEM& aOwner );
 
    void buildPadOutlineAsSegments( const PAD* aPad, PCB_LAYER_ID aLayer, CONTAINER_2D_BASE* aDstContainer,
                                    int aWidth );
 
public:
    static std::vector<CUSTOM_COLOR_ITEM> g_SilkColors;
    static std::vector<CUSTOM_COLOR_ITEM> g_MaskColors;
    static std::vector<CUSTOM_COLOR_ITEM> g_PasteColors;
    static std::vector<CUSTOM_COLOR_ITEM> g_FinishColors;
    static std::vector<CUSTOM_COLOR_ITEM> g_BoardColors;
 
    static KIGFX::COLOR4D                 g_DefaultBackgroundTop;
    static KIGFX::COLOR4D                 g_DefaultBackgroundBot;
    static KIGFX::COLOR4D                 g_DefaultSilkscreen;
    static KIGFX::COLOR4D                 g_DefaultSolderMask;
    static KIGFX::COLOR4D                 g_DefaultSolderPaste;
    static KIGFX::COLOR4D                 g_DefaultAdhesive;
    static KIGFX::COLOR4D                 g_DefaultSurfaceFinish;
    static KIGFX::COLOR4D                 g_DefaultBoardBody;
    static KIGFX::COLOR4D                 g_DefaultComments;
    static KIGFX::COLOR4D                 g_DefaultECOs;
    static KIGFX::COLOR4D                 g_DefaultFabColor;
    static KIGFX::COLOR4D                 g_DefaultCourtyardColor;
 
public:
    EDA_3D_VIEWER_SETTINGS* m_Cfg;
 
    bool                    m_IsBoardView;
    bool                    m_MousewheelPanning;
    bool                    m_IsPreviewer;          
 
    SFVEC4F                 m_BgColorBot;           
    SFVEC4F                 m_BgColorTop;           
    SFVEC4F                 m_BoardBodyColor;
    SFVEC4F                 m_SolderMaskColorBot;
    SFVEC4F                 m_SolderMaskColorTop;
    SFVEC4F                 m_SolderPasteColor;
    SFVEC4F                 m_AdhesiveColor;
    SFVEC4F                 m_SilkScreenColorBot;
    SFVEC4F                 m_SilkScreenColorTop;
    SFVEC4F                 m_CopperColor;
    SFVEC4F                 m_UserDrawingsColor;
    SFVEC4F                 m_UserCommentsColor;
    SFVEC4F                 m_ECO1Color;
    SFVEC4F                 m_ECO2Color;
    SFVEC4F                 m_FFabColor;
    SFVEC4F                 m_BFabColor;
    SFVEC4F                 m_FCourtyardColor;
    SFVEC4F                 m_BCourtyardColor;
    SFVEC4F                 m_UserDefinedLayerColor[45];
 
    std::map<int, COLOR4D>  m_ColorOverrides;  
    std::map<int, COLOR4D>  m_BoardEditorColors; 
 
private:
    BOARD*                  m_board;
    S3D_CACHE*              m_3dModelManager;
 
    std::optional<std::bitset<LAYER_3D_END>> m_visibilityOverride;
 
    VECTOR2I                m_boardPos;             
    VECTOR2I                m_boardSize;            
    SFVEC3F                 m_boardCenter;          
    BBOX_3D                 m_boardBoundingBox;     
 
    MAP_POLY                m_layers_poly;          
 
    SHAPE_POLY_SET*         m_frontPlatedCopperPolys;
    SHAPE_POLY_SET*         m_backPlatedCopperPolys;
 
    MAP_POLY                m_layerHoleOdPolys;     
    MAP_POLY                m_layerHoleIdPolys;     
 
    SHAPE_POLY_SET          m_SecondarydrillPolys;  
    SHAPE_POLY_SET          m_TertiarydrillPolys;   
 
    SHAPE_POLY_SET          m_NPTH_ODPolys;         
    SHAPE_POLY_SET          m_TH_ODPolys;           
    SHAPE_POLY_SET          m_viaTH_ODPolys;        
    SHAPE_POLY_SET          m_viaAnnuliPolys;       
 
    SHAPE_POLY_SET          m_frontCounterborePolys;   
    SHAPE_POLY_SET          m_backCounterborePolys;    
    SHAPE_POLY_SET          m_frontCountersinkPolys;   
    SHAPE_POLY_SET          m_backCountersinkPolys;    
 
    SHAPE_POLY_SET          m_board_poly;           
 
    MAP_CONTAINER_2D_BASE   m_layerMap;             
    MAP_CONTAINER_2D_BASE   m_layerHoleMap;         
 
    BVH_CONTAINER_2D*       m_platedPadsFront;
    BVH_CONTAINER_2D*       m_platedPadsBack;
    BVH_CONTAINER_2D*       m_offboardPadsFront;
    BVH_CONTAINER_2D*       m_offboardPadsBack;
 
    BVH_CONTAINER_2D        m_TH_ODs;               
    BVH_CONTAINER_2D        m_TH_IDs;               
    BVH_CONTAINER_2D        m_viaAnnuli;            
    BVH_CONTAINER_2D        m_viaTH_ODs;            
 
    BVH_CONTAINER_2D        m_backdrillCutouts;          
    BVH_CONTAINER_2D        m_tertiarydrillCutouts;      
 
    BVH_CONTAINER_2D        m_frontCounterboreCutouts;   
    BVH_CONTAINER_2D        m_backCounterboreCutouts;    
    BVH_CONTAINER_2D        m_frontCountersinkCutouts;   
    BVH_CONTAINER_2D        m_backCountersinkCutouts;    
 
    unsigned int            m_copperLayersCount;
 
    double                  m_biuTo3Dunits;         
 
    std::map<PCB_LAYER_ID, float> m_layerZcoordTop;    
    std::map<PCB_LAYER_ID, float> m_layerZcoordBottom; 
 
    float                   m_frontCopperThickness3DU;
    float                   m_backCopperThickness3DU;
    float                   m_boardBodyThickness3DU;
    float                   m_nonCopperLayerThickness3DU;
    float                   m_frontMaskThickness3DU;
    float                   m_backMaskThickness3DU;
    float                   m_solderPasteLayerThickness3DU;
 
    unsigned int            m_trackCount;
    float                   m_averageTrackWidth;
    unsigned int            m_viaCount;
    float                   m_averageViaHoleDiameter;
    unsigned int            m_holeCount;
    float                   m_averageHoleDiameter;

    static const wxChar*    m_logTrace;
 
};
 
 
#endif // BOARD_ADAPTER_H