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 (C) 1992-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 BOARD_ADAPTER_H
#define BOARD_ADAPTER_H
 
#include <array>
#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 <pad.h>
#include <pcb_track.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 <zone.h>
#include <footprint.h>
#include <reporter.h>
#include <dialogs/dialog_color_picker.h>
 
class COLOR_SETTINGS;
class PCB_TEXTBOX;
 
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( FOOTPRINT_ATTR_T aFPAttributes ) 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;
 
 void GetBoardEditorCopperLayerColors( PCBNEW_SETTINGS* aCfg );
 
 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 InitSettings( REPORTER* aStatusReporter, REPORTER* aWarningReporter );
 
 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 ;
 
 const SHAPE_POLY_SET& GetBoardPoly() const noexcept { return m_board_poly; }
 
 SFVEC4F GetLayerColor( PCB_LAYER_ID aLayerId ) const;
 
 SFVEC4F GetItemColor( int aItemId ) 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;
 }
 
 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* GetFrontPlatedPadAndGraphicPolys() { return m_frontPlatedPadAndGraphicPolys; }
 const SHAPE_POLY_SET* GetBackPlatedPadAndGraphicPolys() { return m_backPlatedPadAndGraphicPolys; }
 const MAP_POLY& GetHoleIdPolysMap() const noexcept { return m_layerHoleIdPolys; }
 const MAP_POLY& GetHoleOdPolysMap() const noexcept { return m_layerHoleOdPolys; }
 
private:
 bool createBoardPolygon( wxString* aErrorMsg );
 void createLayers( REPORTER* aStatusReporter );
 void destroyLayers();
 
 // Helper functions to create the board
 void createTrackWithMargin( const PCB_TRACK* aTrack, CONTAINER_2D_BASE* aDstContainer,
 int aMargin = 0 );
 
 void createPadWithMargin( const PAD *aPad, CONTAINER_2D_BASE* aDstContainer,
 PCB_LAYER_ID aLayer, const VECTOR2I& aMargin ) const;
 
 void createPadWithHole( const PAD* aPad, CONTAINER_2D_BASE* aDstContainer,
 int aInflateValue );
 
 void addPads( const FOOTPRINT* aFootprint, CONTAINER_2D_BASE* aDstContainer,
 PCB_LAYER_ID aLayerId, bool aSkipPlatedPads, bool aSkipNonPlatedPads );
 
 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 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 CUSTOM_COLORS_LIST g_SilkColors;
 static CUSTOM_COLORS_LIST g_MaskColors;
 static CUSTOM_COLORS_LIST g_PasteColors;
 static CUSTOM_COLORS_LIST g_FinishColors;
 static CUSTOM_COLORS_LIST 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_DefaultSurfaceFinish;
 static KIGFX::COLOR4D g_DefaultBoardBody;
 static KIGFX::COLOR4D g_DefaultComments;
 static KIGFX::COLOR4D g_DefaultECOs;
 
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_SilkScreenColorBot; 
 SFVEC4F m_SilkScreenColorTop; 
 SFVEC4F m_CopperColor; 
 SFVEC4F m_UserDrawingsColor;
 SFVEC4F m_UserCommentsColor;
 SFVEC4F m_ECO1Color;
 SFVEC4F m_ECO2Color;
 
 std::map<int, COLOR4D> m_ColorOverrides; 
 std::map<int, COLOR4D> m_BoardEditorColors; 
 
private:
 BOARD* m_board;
 S3D_CACHE* m_3dModelManager;
 COLOR_SETTINGS* m_colors;
 
 VECTOR2I m_boardPos; 
 VECTOR2I m_boardSize; 
 SFVEC3F m_boardCenter; 
 BBOX_3D m_boardBoundingBox; 
 
 MAP_POLY m_layers_poly; 
 
 SHAPE_POLY_SET* m_frontPlatedPadAndGraphicPolys;
 SHAPE_POLY_SET* m_backPlatedPadAndGraphicPolys;
 SHAPE_POLY_SET* m_frontPlatedCopperPolys;
 SHAPE_POLY_SET* m_backPlatedCopperPolys;
 
 MAP_POLY m_layerHoleOdPolys; 
 MAP_POLY m_layerHoleIdPolys; 
 
 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_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; 
 
 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_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;
 
};
 
 
class EDA_3D_BOARD_HOLDER
{
public:
 virtual BOARD_ADAPTER& GetAdapter() = 0;
 virtual CAMERA& GetCurrentCamera() = 0;
 
 virtual ~EDA_3D_BOARD_HOLDER() {};
};
 
#endif // BOARD_ADAPTER_H