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) 1992-2021 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 "../3d_rendering/camera.h"
#include "../3d_enums.h"
#include "../3d_cache/3d_cache.h"
#include "../common_ogl/ogl_attr_list.h"

#include <layer_ids.h>
#include <pad.h>
#include <pcb_track.h>
#include <wx/gdicmn.h>
#include <pcb_base_frame.h>
#include <pcb_text.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;

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* aCachePointer ) noexcept
 {
 m_3dModelManager = aCachePointer;
 }

 S3D_CACHE* Get3dCacheManager() const noexcept
 {
 return m_3dModelManager;
 }

 bool GetFlag( DISPLAY3D_FLG aFlag ) const ;

 void SetFlag( DISPLAY3D_FLG aFlag, bool aState );

 bool Is3dLayerEnabled( PCB_LAYER_ID aLayer ) 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 SetColorSettings( COLOR_SETTINGS* aSettings ) noexcept
 {
 m_colors = aSettings;
 }

 void InitSettings( REPORTER* aStatusReporter, REPORTER* aWarningReporter );

 double BiuTo3dUnits() const noexcept
 {
 return m_biuTo3Dunits;
 }

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

 float GetEpoxyThickness() const noexcept
 {
 return m_epoxyThickness3DU;
 }

 float GetNonCopperLayerThickness() const noexcept
 {
 return m_nonCopperLayerThickness3DU;
 }

 float GetCopperThickness() const noexcept
 {
 return m_copperThickness3DU;
 }

 int GetHolePlatingThickness() const noexcept;

 wxSize GetBoardSize() const noexcept
 {
 return m_boardSize;
 }

 wxPoint GetBoardPos() const noexcept
 {
 return m_boardPos;
 }

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

 float GetFootprintZPos( bool aIsFlipped ) const ;

 GRID3D_TYPE GetGridType() const noexcept
 {
 return m_gridType;
 }

 void SetGridType( GRID3D_TYPE aGridType ) noexcept
 {
 m_gridType = aGridType;
 }

 ANTIALIASING_MODE GetAntiAliasingMode() const { return m_antiAliasingMode; }

 void SetAntiAliasingMode( ANTIALIASING_MODE aAAmode ) { m_antiAliasingMode = aAAmode; }

 void SetRenderEngine( RENDER_ENGINE aRenderEngine ) noexcept
 {
 m_renderEngine = aRenderEngine;
 }

 RENDER_ENGINE GetRenderEngine() const noexcept
 {
 return m_renderEngine;
 }

 void SetMaterialMode( MATERIAL_MODE aMaterialMode ) noexcept
 {
 m_materialMode = aMaterialMode;
 }

 MATERIAL_MODE GetMaterialMode() const noexcept
 {
 return m_materialMode;
 }

 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;

 float GetLayerTopZPos( PCB_LAYER_ID aLayerId ) const noexcept
 {
 return m_layerZcoordTop[aLayerId];
 }

 float GetLayerBottomZPos( PCB_LAYER_ID aLayerId ) const noexcept
 {
 return m_layerZcoordBottom[aLayerId];
 }

 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 MAP_CONTAINER_2D_BASE& GetLayerHoleMap() const noexcept
 {
 return m_layerHoleMap;
 }

 const BVH_CONTAINER_2D& GetThroughHoleOds() const noexcept
 {
 return m_throughHoleOds;
 }

 const BVH_CONTAINER_2D& GetThroughHoleAnnularRings() const noexcept
 {
 return m_throughHoleAnnularRings;
 }

 const SHAPE_POLY_SET& GetThroughHoleOdPolys() const noexcept
 {
 return m_throughHoleOdPolys;
 }

 const SHAPE_POLY_SET& GetThroughHoleAnnularRingPolys() const noexcept
 {
 return m_throughHoleAnnularRingPolys;
 }

 const SHAPE_POLY_SET& GetOuterNonPlatedThroughHolePoly() const noexcept
 {
 return m_nonPlatedThroughHoleOdPolys;
 }

 const BVH_CONTAINER_2D& GetThroughHoleViaOds() const noexcept
 {
 return m_throughHoleViaOds;
 }

 const SHAPE_POLY_SET& GetThroughHoleViaOdPolys() const noexcept
 {
 return m_throughHoleViaOdPolys;
 }

 const BVH_CONTAINER_2D& GetThroughHoleIds() const noexcept
 {
 return m_throughHoleIds;
 }

 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* GetFrontPlatedPadPolys()
 {
 return m_frontPlatedPadPolys;
 }

  const SHAPE_POLY_SET* GetBackPlatedPadPolys()
 {
 return m_backPlatedPadPolys;
 }

 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 createTrack( const PCB_TRACK* aTrack, CONTAINER_2D_BASE* aDstContainer,
 int aClearanceValue );

 void createPadWithClearance( const PAD *aPad, CONTAINER_2D_BASE* aDstContainer,
 PCB_LAYER_ID aLayer, const wxSize& aClearanceValue ) const;

 OBJECT_2D* createPadWithDrill( const PAD* aPad, int aInflateValue );

 void addPadsWithClearance( const FOOTPRINT* aFootprint, CONTAINER_2D_BASE* aDstContainer,
 PCB_LAYER_ID aLayerId, int aInflateValue,
 bool aSkipNPTHPadsWihNoCopper, bool aSkipPlatedPads,
 bool aSkipNonPlatedPads );

 void addFootprintShapesWithClearance( const FOOTPRINT* aFootprint,
 CONTAINER_2D_BASE* aDstContainer,
 PCB_LAYER_ID aLayerId, int aInflateValue );

 void addShapeWithClearance( const PCB_TEXT* aText, CONTAINER_2D_BASE* aDstContainer,
 PCB_LAYER_ID aLayerId, int aClearanceValue );

 void addShapeWithClearance( const PCB_SHAPE* aShape, CONTAINER_2D_BASE* aDstContainer,
 PCB_LAYER_ID aLayerId, int aClearanceValue );

 void addShapeWithClearance( const PCB_DIMENSION_BASE* aDimension,
 CONTAINER_2D_BASE* aDstContainer, PCB_LAYER_ID aLayerId,
 int aClearanceValue );

 void addSolidAreasShapes( const ZONE* aZoneContainer, CONTAINER_2D_BASE* aDstContainer,
 PCB_LAYER_ID aLayerId );

 void transformArcToSegments( const wxPoint& aCentre, const wxPoint& aStart, double aArcAngle,
 int aCircleToSegmentsCount, int aWidth,
 CONTAINER_2D_BASE* aDstContainer, const BOARD_ITEM& aBoardItem );

 void buildPadOutlineAsSegments( const PAD* aPad, CONTAINER_2D_BASE* aDstContainer, int aWidth );

 // Helper functions to create poly contours
 void buildPadOutlineAsPolygon( const PAD* aPad, SHAPE_POLY_SET& aCornerBuffer,
 int aWidth) const;

 void transformFPShapesToPolygon( const FOOTPRINT* aFootprint, PCB_LAYER_ID aLayer,
 SHAPE_POLY_SET& aCornerBuffer ) const;

public:
 static CUSTOM_COLORS_LIST g_SilkscreenColors;
 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;

public:
 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; 

 SFVEC3F m_OpenGlSelectionColor;

 // Raytracing light colors
 SFVEC3F m_RtCameraLightColor;
 SFVEC3F m_RtLightColorTop;
 SFVEC3F m_RtLightColorBottom;

 std::vector<SFVEC3F> m_RtLightColor;
 std::vector<SFVEC2F> m_RtLightSphericalCoords;

 // Raytracing options
 int m_RtShadowSampleCount;
 int m_RtReflectionSampleCount;
 int m_RtRefractionSampleCount;
 int m_RtRecursiveReflectionCount;
 int m_RtRecursiveRefractionCount;

 float m_RtSpreadShadows;
 float m_RtSpreadReflections;
 float m_RtSpreadRefractions;

private:
 BOARD* m_board;
 S3D_CACHE* m_3dModelManager;
 COLOR_SETTINGS* m_colors;

 std::vector< bool > m_drawFlags;
 GRID3D_TYPE m_gridType;
 RENDER_ENGINE m_renderEngine;
 MATERIAL_MODE m_materialMode;
 ANTIALIASING_MODE m_antiAliasingMode;


 wxPoint m_boardPos; 
 wxSize m_boardSize; 
 SFVEC3F m_boardCenter; 
 BBOX_3D m_boardBoundingBox; 


 MAP_POLY m_layers_poly;

 SHAPE_POLY_SET* m_frontPlatedPadPolys;
 SHAPE_POLY_SET* m_backPlatedPadPolys;

 MAP_POLY m_layerHoleOdPolys;

 MAP_POLY m_layerHoleIdPolys;

 SHAPE_POLY_SET m_nonPlatedThroughHoleOdPolys;

 SHAPE_POLY_SET m_throughHoleOdPolys;

 SHAPE_POLY_SET m_throughHoleViaOdPolys;

 SHAPE_POLY_SET m_throughHoleAnnularRingPolys;

 SHAPE_POLY_SET m_board_poly; 

 MAP_CONTAINER_2D_BASE m_layerMap; 


 BVH_CONTAINER_2D* m_platedPadsFront;
 BVH_CONTAINER_2D* m_platedPadsBack;

 MAP_CONTAINER_2D_BASE m_layerHoleMap;

 BVH_CONTAINER_2D m_throughHoleOds;

 BVH_CONTAINER_2D m_throughHoleAnnularRings;

 BVH_CONTAINER_2D m_throughHoleIds;

 BVH_CONTAINER_2D m_throughHoleViaOds;

 BVH_CONTAINER_2D m_throughHoleViaIds;

 unsigned int m_copperLayersCount;

 double m_biuTo3Dunits;

 std::array<float, PCB_LAYER_ID_COUNT> m_layerZcoordTop;

 std::array<float, PCB_LAYER_ID_COUNT> m_layerZcoordBottom;

 float m_copperThickness3DU;

 float m_epoxyThickness3DU;

 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