BOARD_ADAPTER Class Reference

Helper class to handle information needed to display 3D board. More...

#include <board_adapter.h>

Public Member Functions
	BOARD_ADAPTER ()
	~BOARD_ADAPTER ()
void	Set3dCacheManager (S3D_CACHE *aCachePointer) noexcept
	Update the cache manager pointer. More...
S3D_CACHE *	Get3dCacheManager () const noexcept
	Return the 3D cache manager pointer. More...
bool	GetFlag (DISPLAY3D_FLG aFlag) const
	Get a configuration status of a flag. More...
void	SetFlag (DISPLAY3D_FLG aFlag, bool aState)
	Set the status of a flag. More...
bool	Is3dLayerEnabled (PCB_LAYER_ID aLayer) const
	Check if a layer is enabled. More...
bool	IsFootprintShown (FOOTPRINT_ATTR_T aFPAttributes) const
	Test if footprint should be displayed in relation to attributes and the flags. More...
void	SetBoard (BOARD *aBoard) noexcept
	Set current board to be rendered. More...
const BOARD *	GetBoard () const noexcept
	Get current board to be rendered. More...
void	SetColorSettings (COLOR_SETTINGS *aSettings) noexcept
void	InitSettings (REPORTER *aStatusReporter, REPORTER *aWarningReporter)
	Function to be called by the render when it need to reload the settings for the board. More...
double	BiuTo3dUnits () const noexcept
	Board integer units To 3D units. More...
const BBOX_3D &	GetBBox () const noexcept
	Get the board outling bounding box. More...
float	GetEpoxyThickness () const noexcept
	Get the current epoxy thickness. More...
float	GetNonCopperLayerThickness () const noexcept
	Get the current non copper layers thickness. More...
float	GetCopperThickness () const noexcept
	Get the current copper layer thickness. More...
int	GetHolePlatingThickness () const noexcept
	Get the current copper layer thickness. More...
wxSize	GetBoardSize () const noexcept
	Get the board size. More...
wxPoint	GetBoardPos () const noexcept
	Get the board center. More...
const SFVEC3F &	GetBoardCenter () const noexcept
	The board center position in 3D units. More...
float	GetFootprintZPos (bool aIsFlipped) const
	Get the position of the footprint in 3d integer units considering if it is flipped or not. More...
GRID3D_TYPE	GetGridType () const noexcept
	Get the current grid. More...
void	SetGridType (GRID3D_TYPE aGridType) noexcept
	Set the current grid. More...
ANTIALIASING_MODE	GetAntiAliasingMode () const
	Get the current antialiasing mode value. More...
void	SetAntiAliasingMode (ANTIALIASING_MODE aAAmode)
	Set the current antialiasing mode value. More...
void	SetRenderEngine (RENDER_ENGINE aRenderEngine) noexcept
RENDER_ENGINE	GetRenderEngine () const noexcept
void	SetMaterialMode (MATERIAL_MODE aMaterialMode) noexcept
MATERIAL_MODE	GetMaterialMode () const noexcept
const SHAPE_POLY_SET &	GetBoardPoly () const noexcept
	Get the current polygon of the epoxy board. More...
SFVEC4F	GetLayerColor (PCB_LAYER_ID aLayerId) const
	Get the technical color of a layer. More...
SFVEC4F	GetItemColor (int aItemId) const
	Get the technical color of a layer. More...
SFVEC4F	GetColor (const COLOR4D &aColor) const
float	GetLayerTopZPos (PCB_LAYER_ID aLayerId) const noexcept
	Get the top z position. More...
float	GetLayerBottomZPos (PCB_LAYER_ID aLayerId) const noexcept
	Get the bottom z position. More...
const MAP_CONTAINER_2D_BASE &	GetLayerMap () const noexcept
	Get the map of containers that have the objects per layer. More...
const BVH_CONTAINER_2D *	GetPlatedPadsFront () const noexcept
const BVH_CONTAINER_2D *	GetPlatedPadsBack () const noexcept
const MAP_CONTAINER_2D_BASE &	GetLayerHoleMap () const noexcept
	Get the map of container that have the holes per layer. More...
const BVH_CONTAINER_2D &	GetThroughHoleOds () const noexcept
	Get the inflated through hole outside diameters container. More...
const BVH_CONTAINER_2D &	GetThroughHoleAnnularRings () const noexcept
	Get the through hole annular rings container. More...
const SHAPE_POLY_SET &	GetThroughHoleOdPolys () const noexcept
	Get through hole outside diameter 2D polygons. More...
const SHAPE_POLY_SET &	GetThroughHoleAnnularRingPolys () const noexcept
const SHAPE_POLY_SET &	GetOuterNonPlatedThroughHolePoly () const noexcept
const BVH_CONTAINER_2D &	GetThroughHoleViaOds () const noexcept
const SHAPE_POLY_SET &	GetThroughHoleViaOdPolys () const noexcept
const BVH_CONTAINER_2D &	GetThroughHoleIds () const noexcept
	Get the through hole inner diameter container. More...
unsigned int	GetViaCount () const noexcept
	Get number of vias in this board. More...
unsigned int	GetHoleCount () const noexcept
	Get number of holes in this board. More...
float	GetAverageViaHoleDiameter () const noexcept
	Thee average diameter of the via holes. More...
float	GetAverageHoleDiameter () const noexcept
	Average diameter of through holes. More...
float	GetAverageTrackWidth () const noexcept
	Average width of the tracks. More...
unsigned int	GetCircleSegmentCount (float aDiameter3DU) const
unsigned int	GetCircleSegmentCount (int aDiameterBIU) const
const MAP_POLY &	GetPolyMap () const noexcept
	Get map of polygon's layers. More...
const SHAPE_POLY_SET *	GetFrontPlatedPadPolys ()
const SHAPE_POLY_SET *	GetBackPlatedPadPolys ()
const MAP_POLY &	GetHoleIdPolysMap () const noexcept
const MAP_POLY &	GetHoleOdPolysMap () const noexcept

Public Attributes
SFVEC4F	m_BgColorBot
	background bottom color More...
SFVEC4F	m_BgColorTop
	background top color More...
SFVEC4F	m_BoardBodyColor
	in realistic mode: FR4 board color More...
SFVEC4F	m_SolderMaskColorBot
	in realistic mode: solder mask color ( bot ) More...
SFVEC4F	m_SolderMaskColorTop
	in realistic mode: solder mask color ( top ) More...
SFVEC4F	m_SolderPasteColor
	in realistic mode: solder paste color More...
SFVEC4F	m_SilkScreenColorBot
	in realistic mode: SilkScreen color ( bot ) More...
SFVEC4F	m_SilkScreenColorTop
	in realistic mode: SilkScreen color ( top ) More...
SFVEC4F	m_CopperColor
	in realistic mode: copper color More...
SFVEC3F	m_OpenGlSelectionColor
SFVEC3F	m_RtCameraLightColor
SFVEC3F	m_RtLightColorTop
SFVEC3F	m_RtLightColorBottom
std::vector< SFVEC3F >	m_RtLightColor
std::vector< SFVEC2F >	m_RtLightSphericalCoords
int	m_RtShadowSampleCount
int	m_RtReflectionSampleCount
int	m_RtRefractionSampleCount
int	m_RtRecursiveReflectionCount
int	m_RtRecursiveRefractionCount
float	m_RtSpreadShadows
float	m_RtSpreadReflections
float	m_RtSpreadRefractions

Static Public Attributes
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

Private Member Functions
bool	createBoardPolygon (wxString *aErrorMsg)
	Create the board outline polygon. More...
void	createLayers (REPORTER *aStatusReporter)
void	destroyLayers ()
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)
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

Private Attributes
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
	Board center position in board internal units. More...
wxSize	m_boardSize
	Board size in board internal units. More...
SFVEC3F	m_boardCenter
	3D center position of the board in 3D units. More...
BBOX_3D	m_boardBoundingBox
	3D bounding box of the board in 3D units. More...
MAP_POLY	m_layers_poly
SHAPE_POLY_SET *	m_frontPlatedPadPolys
SHAPE_POLY_SET *	m_backPlatedPadPolys
	Polygon contours for hole outer diameters for each layer. More...
MAP_POLY	m_layerHoleOdPolys
	Polygon contours for hole inner diameters for each layer. More...
MAP_POLY	m_layerHoleIdPolys
	Polygon contours for non plated through hole outer diameters. More...
SHAPE_POLY_SET	m_nonPlatedThroughHoleOdPolys
	Polygon contours for through hole outer diameters. More...
SHAPE_POLY_SET	m_throughHoleOdPolys
	Polygon contours for through holes via outer diameters. More...
SHAPE_POLY_SET	m_throughHoleViaOdPolys
	Polygon contours for through hole via annular rings. More...
SHAPE_POLY_SET	m_throughHoleAnnularRingPolys
SHAPE_POLY_SET	m_board_poly
	Board outline polygon. More...
MAP_CONTAINER_2D_BASE	m_layerMap
	2D elements for each layer. More...
BVH_CONTAINER_2D *	m_platedPadsFront
BVH_CONTAINER_2D *	m_platedPadsBack
	The holes per each layer. More...
MAP_CONTAINER_2D_BASE	m_layerHoleMap
	List of through holes with the radius of the hole inflated with the copper thickness. More...
BVH_CONTAINER_2D	m_throughHoleOds
	List of plated through hole annular rings. More...
BVH_CONTAINER_2D	m_throughHoleAnnularRings
	List of through hole inner diameters. More...
BVH_CONTAINER_2D	m_throughHoleIds
	List of through hole vias with the radius of the hole inflated with the copper thickness. More...
BVH_CONTAINER_2D	m_throughHoleViaOds
	List of through hole via inner diameters. More...
BVH_CONTAINER_2D	m_throughHoleViaIds
	Number of copper layers actually used by the board. More...
unsigned int	m_copperLayersCount
	Scale factor to convert board internal units to 3D units normalized between -1.0 and 1.0. More...
double	m_biuTo3Dunits
	Top (End) Z position of each layer in 3D units. More...
std::array< float, PCB_LAYER_ID_COUNT >	m_layerZcoordTop
	Bottom (Start) Z position of each layer in 3D units. More...
std::array< float, PCB_LAYER_ID_COUNT >	m_layerZcoordBottom
	Copper thickness in 3D units. More...
float	m_copperThickness3DU
	Epoxy thickness in 3D units. More...
float	m_epoxyThickness3DU
	Non copper layers thickness in 3D units. More...
float	m_nonCopperLayerThickness3DU
	solder paste layers thickness in 3D units. More...
float	m_solderPasteLayerThickness3DU
	Number of tracks in the board. More...
unsigned int	m_trackCount
	Track average width. More...
float	m_averageTrackWidth
	Number of through hole vias in the board. More...
unsigned int	m_viaCount
	Computed average diameter of the via holes in 3D units. More...
float	m_averageViaHoleDiameter
	Number of holes in the board. More...
unsigned int	m_holeCount
	Computed average diameter of the holes in 3D units. More...
float	m_averageHoleDiameter

Static Private Attributes
static const wxChar *	m_logTrace = wxT( "KI_TRACE_EDA_CINFO3D_VISU" )
	Trace mask used to enable or disable the trace output of this class. More...

Detailed Description

Helper class to handle information needed to display 3D board.

Definition at line 68 of file board_adapter.h.

Constructor & Destructor Documentation

BOARD_ADAPTER()

BOARD_ADAPTER::BOARD_ADAPTER

(

)

Definition at line 68 of file board_adapter.cpp.

                             :
        m_board( nullptr ),
        m_3dModelManager( nullptr ),
        m_colors( nullptr ),
        m_layerZcoordTop(),
        m_layerZcoordBottom()
{
    wxLogTrace( m_logTrace, wxT( "BOARD_ADAPTER::BOARD_ADAPTER" ) );

    m_gridType = GRID3D_TYPE::NONE;
    m_antiAliasingMode = ANTIALIASING_MODE::AA_8X;
    m_drawFlags.resize( FL_LAST, false );

    if( PgmOrNull() )
        m_colors = Pgm().GetSettingsManager().GetColorSettings();

    m_renderEngine = RENDER_ENGINE::OPENGL_LEGACY;
    m_materialMode = MATERIAL_MODE::NORMAL;

    m_boardPos = wxPoint();
    m_boardSize = wxSize();
    m_boardCenter = SFVEC3F( 0.0f );

    m_boardBoundingBox.Reset();

    m_throughHoleIds.Clear();
    m_throughHoleOds.Clear();
    m_throughHoleAnnularRings.Clear();

    m_copperLayersCount = -1;
    m_epoxyThickness3DU = 0.0f;
    m_copperThickness3DU  = 0.0f;
    m_nonCopperLayerThickness3DU = 0.0f;
    m_solderPasteLayerThickness3DU = 0.0f;
    m_biuTo3Dunits = 1.0;

    m_trackCount = 0;
    m_viaCount = 0;
    m_averageViaHoleDiameter = 0.0f;
    m_holeCount = 0;
    m_averageHoleDiameter = 0.0f;
    m_averageTrackWidth = 0.0f;

    SetFlag( FL_USE_REALISTIC_MODE, true );
    SetFlag( FL_FP_ATTRIBUTES_NORMAL, true );
    SetFlag( FL_SHOW_BOARD_BODY, true );
    SetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS, false );
    SetFlag( FL_FP_ATTRIBUTES_NORMAL, true );
    SetFlag( FL_FP_ATTRIBUTES_NORMAL_INSERT, true );
    SetFlag( FL_FP_ATTRIBUTES_VIRTUAL, true );
    SetFlag( FL_ZONE, true );
    SetFlag( FL_SILKSCREEN, true );
    SetFlag( FL_SOLDERMASK, true );
    SetFlag( FL_SUBTRACT_MASK_FROM_SILK, false );

    SetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS, true );
    SetFlag( FL_RENDER_OPENGL_AA_DISABLE_ON_MOVE, false );
    SetFlag( FL_RENDER_OPENGL_THICKNESS_DISABLE_ON_MOVE, false );
    SetFlag( FL_RENDER_OPENGL_VIAS_DISABLE_ON_MOVE, false );
    SetFlag( FL_RENDER_OPENGL_HOLES_DISABLE_ON_MOVE, false );

    SetFlag( FL_USE_SELECTION, true );
    SetFlag( FL_HIGHLIGHT_ROLLOVER_ITEM, true );

    m_BgColorBot         = SFVEC4F( 0.4, 0.4, 0.5, 1.0 );
    m_BgColorTop         = SFVEC4F( 0.8, 0.8, 0.9, 1.0 );
    m_BoardBodyColor     = SFVEC4F( 0.4, 0.4, 0.5, 0.9 );
    m_SolderMaskColorTop = SFVEC4F( 0.1, 0.2, 0.1, 0.83 );
    m_SolderMaskColorBot = SFVEC4F( 0.1, 0.2, 0.1, 0.83 );
    m_SolderPasteColor   = SFVEC4F( 0.4, 0.4, 0.4, 1.0 );
    m_SilkScreenColorTop = SFVEC4F( 0.9, 0.9, 0.9, 1.0 );
    m_SilkScreenColorBot = SFVEC4F( 0.9, 0.9, 0.9, 1.0 );
    m_CopperColor        = SFVEC4F( 0.75, 0.61, 0.23, 1.0 );

    m_platedPadsFront = nullptr;
    m_platedPadsBack = nullptr;

    m_frontPlatedPadPolys = nullptr;
    m_backPlatedPadPolys = nullptr;

    // Avoid raytracing options not initialized:
    m_RtShadowSampleCount = 0;
    m_RtReflectionSampleCount = 0;
    m_RtRefractionSampleCount = 0;

    m_RtSpreadShadows = 0.0;
    m_RtSpreadReflections = 0.0;
    m_RtSpreadRefractions = 0.0;

    m_RtRecursiveReflectionCount = 0;
    m_RtRecursiveRefractionCount = 0;

    if( !g_ColorsLoaded )
    {
#define ADD_COLOR( list, r, g, b, a, name ) \
    list.push_back( CUSTOM_COLOR_ITEM( r/255.0, g/255.0, b/255.0, a, name ) )

        ADD_COLOR( g_SilkscreenColors,  20,  51,  36, 1.0, "Green" );
        ADD_COLOR( g_SilkscreenColors, 181,  19,  21, 1.0, "Red" );
        ADD_COLOR( g_SilkscreenColors,   2,  59, 162, 1.0, "Blue" );
        ADD_COLOR( g_SilkscreenColors,  11,  11,  11, 1.0, "Black" );
        ADD_COLOR( g_SilkscreenColors, 245, 245, 245, 1.0, "White" );
        ADD_COLOR( g_SilkscreenColors,  32,   2,  53, 1.0, "Purple" );
        ADD_COLOR( g_SilkscreenColors, 194,  195,  0, 1.0, "Yellow" );

        ADD_COLOR( g_MaskColors,  20,  51,  36, 0.83, "Green" );
        ADD_COLOR( g_MaskColors,  91, 168,  12, 0.83, "Light Green" );
        ADD_COLOR( g_MaskColors,  13, 104,  11, 0.83, "Saturated Green" );
        ADD_COLOR( g_MaskColors, 181,  19,  21, 0.83, "Red" );
        ADD_COLOR( g_MaskColors, 210,  40,  14, 0.83, "Light Red" );
        ADD_COLOR( g_MaskColors, 239,  53,  41, 0.83, "Red/Orange" );
        ADD_COLOR( g_MaskColors,   2,  59, 162, 0.83, "Blue" );
        ADD_COLOR( g_MaskColors,  54,  79, 116, 0.83, "Light Blue 1" );
        ADD_COLOR( g_MaskColors,  61,  85, 130, 0.83, "Light Blue 2" );
        ADD_COLOR( g_MaskColors,  21,  70,  80, 0.83, "Green/Blue" );
        ADD_COLOR( g_MaskColors,  11,  11,  11, 0.83, "Black" );
        ADD_COLOR( g_MaskColors, 245, 245, 245, 0.83, "White" );
        ADD_COLOR( g_MaskColors,  32,   2,  53, 0.83, "Purple" );
        ADD_COLOR( g_MaskColors, 119,  31,  91, 0.83, "Light Purple" );
        ADD_COLOR( g_MaskColors, 194,  195,  0, 0.83, "Yellow" );

        ADD_COLOR( g_PasteColors, 128, 128, 128, 1.0, "Grey" );
        ADD_COLOR( g_PasteColors,  90,  90,  90, 1.0, "Dark Grey" );
        ADD_COLOR( g_PasteColors, 213, 213, 213, 1.0, "Silver" );

        ADD_COLOR( g_FinishColors, 184, 115,  50, 1.0, "Copper" );
        ADD_COLOR( g_FinishColors, 178, 156,   0, 1.0, "Gold" );
        ADD_COLOR( g_FinishColors, 213, 213, 213, 1.0, "Silver" );
        ADD_COLOR( g_FinishColors, 160, 160, 160, 1.0, "Tin" );

        ADD_COLOR( g_BoardColors,  51,  43,  22, 0.83, "FR4 natural, dark" );
        ADD_COLOR( g_BoardColors, 109, 116,  75, 0.83, "FR4 natural" );
        ADD_COLOR( g_BoardColors, 252, 252, 250, 0.90, "PTFE natural" );
        ADD_COLOR( g_BoardColors, 205, 130,   0, 0.68, "Polyimide" );
        ADD_COLOR( g_BoardColors,  92,  17,   6, 0.90, "Phenolic natural" );
        ADD_COLOR( g_BoardColors, 146,  99,  47, 0.83, "Brown 1" );
        ADD_COLOR( g_BoardColors, 160, 123,  54, 0.83, "Brown 2" );
        ADD_COLOR( g_BoardColors, 146,  99,  47, 0.83, "Brown 3" );
        ADD_COLOR( g_BoardColors, 213, 213, 213,  1.0, "Aluminum" );

        g_DefaultBackgroundTop = COLOR4D(  0.80, 0.80, 0.90, 1.0 );
        g_DefaultBackgroundBot = COLOR4D(  0.40, 0.40, 0.50, 1.0 );

        g_DefaultSilkscreen =    COLOR4D( 0.94, 0.94, 0.94,  1.0 );
        g_DefaultSolderMask =    COLOR4D( 0.08, 0.20, 0.14, 0.83 );
        g_DefaultSolderPaste =   COLOR4D( 0.50, 0.50, 0.50,  1.0 );
        g_DefaultSurfaceFinish = COLOR4D( 0.75, 0.61, 0.23,  1.0 );
        g_DefaultBoardBody =     COLOR4D( 0.43, 0.45, 0.30, 0.90 );

        g_ColorsLoaded = true;
    }
#undef ADD_COLOR
}

References AA_8X, ADD_COLOR, BVH_CONTAINER_2D::Clear(), FL_CLIP_SILK_ON_VIA_ANNULUS, FL_FP_ATTRIBUTES_NORMAL, FL_FP_ATTRIBUTES_NORMAL_INSERT, FL_FP_ATTRIBUTES_VIRTUAL, FL_HIGHLIGHT_ROLLOVER_ITEM, FL_LAST, FL_RENDER_OPENGL_AA_DISABLE_ON_MOVE, FL_RENDER_OPENGL_COPPER_THICKNESS, FL_RENDER_OPENGL_HOLES_DISABLE_ON_MOVE, FL_RENDER_OPENGL_THICKNESS_DISABLE_ON_MOVE, FL_RENDER_OPENGL_VIAS_DISABLE_ON_MOVE, FL_SHOW_BOARD_BODY, FL_SILKSCREEN, FL_SOLDERMASK, FL_SUBTRACT_MASK_FROM_SILK, FL_USE_REALISTIC_MODE, FL_USE_SELECTION, FL_ZONE, g_BoardColors, g_ColorsLoaded, g_DefaultBackgroundBot, g_DefaultBackgroundTop, g_DefaultBoardBody, g_DefaultSilkscreen, g_DefaultSolderMask, g_DefaultSolderPaste, g_DefaultSurfaceFinish, g_FinishColors, g_MaskColors, g_PasteColors, g_SilkscreenColors, m_antiAliasingMode, m_averageHoleDiameter, m_averageTrackWidth, m_averageViaHoleDiameter, m_backPlatedPadPolys, m_BgColorBot, m_BgColorTop, m_biuTo3Dunits, m_BoardBodyColor, m_boardBoundingBox, m_boardCenter, m_boardPos, m_boardSize, m_colors, m_CopperColor, m_copperLayersCount, m_copperThickness3DU, m_drawFlags, m_epoxyThickness3DU, m_frontPlatedPadPolys, m_gridType, m_holeCount, m_logTrace, m_materialMode, m_nonCopperLayerThickness3DU, m_platedPadsBack, m_platedPadsFront, m_renderEngine, m_RtRecursiveReflectionCount, m_RtRecursiveRefractionCount, m_RtReflectionSampleCount, m_RtRefractionSampleCount, m_RtShadowSampleCount, m_RtSpreadReflections, m_RtSpreadRefractions, m_RtSpreadShadows, m_SilkScreenColorBot, m_SilkScreenColorTop, m_SolderMaskColorBot, m_SolderMaskColorTop, m_SolderPasteColor, m_solderPasteLayerThickness3DU, m_throughHoleAnnularRings, m_throughHoleIds, m_throughHoleOds, m_trackCount, m_viaCount, NONE, NORMAL, OPENGL_LEGACY, Pgm(), PgmOrNull(), BBOX_3D::Reset(), and SetFlag().

~BOARD_ADAPTER()

BOARD_ADAPTER::~BOARD_ADAPTER

(

)

Definition at line 223 of file board_adapter.cpp.

{
    destroyLayers();
}

References destroyLayers().

Member Function Documentation

addFootprintShapesWithClearance()

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

private

Definition at line 164 of file create_3Dgraphic_brd_items.cpp.

{
    std::vector<FP_TEXT*> texts;  // List of FP_TEXT to convert
    FP_SHAPE* outline;

    for( BOARD_ITEM* item : aFootprint->GraphicalItems() )
    {
        switch( item->Type() )
        {
        case PCB_FP_TEXT_T:
        {
            FP_TEXT* text = static_cast<FP_TEXT*>( item );

            if( text->GetLayer() == aLayerId && text->IsVisible() )
                texts.push_back( text );
        }
        break;


        case PCB_FP_SHAPE_T:
        {
            outline = (FP_SHAPE*) item;

            if( outline->GetLayer() != aLayerId )
                break;

            addShapeWithClearance( (const PCB_SHAPE*) outline, aDstContainer, aLayerId, 0 );
        }
        break;

        default:
            break;
        }
    }

    // Convert texts for footprints
    if( aFootprint->Reference().GetLayer() == aLayerId && aFootprint->Reference().IsVisible() )
        texts.push_back( &aFootprint->Reference() );

    if( aFootprint->Value().GetLayer() == aLayerId && aFootprint->Value().IsVisible() )
        texts.push_back( &aFootprint->Value() );

    s_boardItem    = (const BOARD_ITEM *)&aFootprint->Value();
    s_dstcontainer = aDstContainer;
    s_biuTo3Dunits = m_biuTo3Dunits;

    for( FP_TEXT* text : texts )
    {
        s_textWidth = text->GetEffectiveTextPenWidth() + ( 2 * aInflateValue );
        wxSize size = text->GetTextSize();
        bool   isBold = text->IsBold();
        int    penWidth = text->GetEffectiveTextPenWidth();

        if( text->IsMirrored() )
            size.x = -size.x;

        GRText( nullptr, text->GetTextPos(), BLACK, text->GetShownText(), text->GetDrawRotation(),
                size, text->GetHorizJustify(), text->GetVertJustify(), penWidth, text->IsItalic(),
                isBold, addTextSegmToContainer );
    }
}

References addShapeWithClearance(), addTextSegmToContainer(), BLACK, BOARD_ITEM::GetLayer(), FOOTPRINT::GraphicalItems(), GRText(), EDA_TEXT::IsVisible(), m_biuTo3Dunits, PCB_FP_SHAPE_T, PCB_FP_TEXT_T, FOOTPRINT::Reference(), s_biuTo3Dunits, s_boardItem, s_dstcontainer, s_textWidth, text, and FOOTPRINT::Value().

Referenced by createLayers().

addPadsWithClearance()

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

private

Definition at line 483 of file create_3Dgraphic_brd_items.cpp.

{
    for( PAD* pad : aFootprint->Pads() )
    {
        if( !pad->IsOnLayer( aLayerId ) )
            continue;

        // Skip pad annulus when not connected on this layer (if removing is enabled)
        if( !pad->FlashLayer( aLayerId ) && IsCopperLayer( aLayerId ) )
            continue;

        // NPTH pads are not drawn on layers if the
        // shape size and pos is the same as their hole:
        if( aSkipNPTHPadsWihNoCopper && ( pad->GetAttribute() == PAD_ATTRIB::NPTH ) )
        {
            if( pad->GetDrillSize() == pad->GetSize() && pad->GetOffset() == wxPoint( 0, 0 ) )
            {
                switch( pad->GetShape() )
                {
                case PAD_SHAPE::CIRCLE:
                    if( pad->GetDrillShape() == PAD_DRILL_SHAPE_CIRCLE )
                        continue;

                    break;

                case PAD_SHAPE::OVAL:
                    if( pad->GetDrillShape() != PAD_DRILL_SHAPE_CIRCLE )
                        continue;

                    break;

                default:
                    break;
                }
            }
        }

        const bool isPlated = ( ( aLayerId == F_Cu ) && pad->FlashLayer( F_Mask ) ) ||
                              ( ( aLayerId == B_Cu ) && pad->FlashLayer( B_Mask ) );

        if( aSkipPlatedPads && isPlated )
            continue;

        if( aSkipNonPlatedPads && !isPlated )
            continue;

        wxSize margin( aInflateValue, aInflateValue );

        switch( aLayerId )
        {
        case F_Mask:
        case B_Mask:
            margin.x += pad->GetSolderMaskMargin();
            margin.y += pad->GetSolderMaskMargin();
            break;

        case F_Paste:
        case B_Paste:
            margin += pad->GetSolderPasteMargin();
            break;

        default:
            break;
        }

        createPadWithClearance( pad, aDstContainer, aLayerId, margin );
    }
}

References B_Cu, B_Mask, B_Paste, CIRCLE, createPadWithClearance(), F_Cu, F_Mask, F_Paste, IsCopperLayer(), isPlated(), NPTH, OVAL, pad, PAD_DRILL_SHAPE_CIRCLE, and FOOTPRINT::Pads().

Referenced by createLayers().

addShapeWithClearance() [1/3]

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

private

Definition at line 86 of file create_3Dgraphic_brd_items.cpp.

{
    wxSize size = aText->GetTextSize();

    if( aText->IsMirrored() )
        size.x = -size.x;

    s_boardItem    = (const BOARD_ITEM *) &aText;
    s_dstcontainer = aDstContainer;
    s_textWidth    = aText->GetEffectiveTextPenWidth() + ( 2 * aClearanceValue );
    s_biuTo3Dunits = m_biuTo3Dunits;

    // not actually used, but needed by GRText
    const COLOR4D dummy_color;

    // Use the actual text width to generate segments. The segment position depend on
    // text thickness and justification
    bool isBold = aText->IsBold();
    int  penWidth = aText->GetEffectiveTextPenWidth();

    GRText( nullptr, aText->GetTextPos(), dummy_color, aText->GetShownText(),
            aText->GetTextAngle(), size, aText->GetHorizJustify(), aText->GetVertJustify(),
            penWidth, aText->IsItalic(), isBold, addTextSegmToContainer );
}

References addTextSegmToContainer(), EDA_TEXT::GetEffectiveTextPenWidth(), EDA_TEXT::GetHorizJustify(), PCB_TEXT::GetShownText(), EDA_TEXT::GetTextAngle(), EDA_TEXT::GetTextPos(), EDA_TEXT::GetTextSize(), EDA_TEXT::GetVertJustify(), GRText(), EDA_TEXT::IsBold(), EDA_TEXT::IsItalic(), EDA_TEXT::IsMirrored(), m_biuTo3Dunits, s_biuTo3Dunits, s_boardItem, s_dstcontainer, and s_textWidth.

Referenced by addFootprintShapesWithClearance(), addShapeWithClearance(), and createLayers().

addShapeWithClearance() [2/3]

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

private

Definition at line 628 of file create_3Dgraphic_brd_items.cpp.

{
    // The full width of the lines to create
    // The extra 1 protects the inner/outer radius values from degeneracy
    const int linewidth = aShape->GetWidth() + ( 2 * aClearanceValue ) + 1;

    switch( aShape->GetShape() )
    {
    case SHAPE_T::CIRCLE:
    {
        const SFVEC2F center3DU( aShape->GetCenter().x * m_biuTo3Dunits,
                                 -aShape->GetCenter().y * m_biuTo3Dunits );

        float inner_radius = ( aShape->GetRadius() - linewidth / 2 ) * m_biuTo3Dunits;
        float outer_radius = ( aShape->GetRadius() + linewidth / 2 ) * m_biuTo3Dunits;

        if( inner_radius < 0 )
            inner_radius = 0;

        if( aShape->IsFilled() )
            aDstContainer->Add( new FILLED_CIRCLE_2D( center3DU, outer_radius, *aShape ) );
        else
            aDstContainer->Add( new RING_2D( center3DU, inner_radius, outer_radius, *aShape ) );
    }
        break;

    case SHAPE_T::RECT:
        if( aShape->IsFilled() )
        {
            SHAPE_POLY_SET polyList;

            aShape->TransformShapeWithClearanceToPolygon( polyList, aLayerId, 0,
                                                          ARC_HIGH_DEF, ERROR_INSIDE );

            polyList.Simplify( SHAPE_POLY_SET::PM_FAST );

            ConvertPolygonToTriangles( polyList, *aDstContainer, m_biuTo3Dunits, *aShape );
        }
        else
        {
            std::vector<wxPoint> pts = aShape->GetRectCorners();

            const SFVEC2F topLeft3DU(  pts[0].x * m_biuTo3Dunits, -pts[0].y * m_biuTo3Dunits );
            const SFVEC2F topRight3DU( pts[1].x * m_biuTo3Dunits, -pts[1].y * m_biuTo3Dunits );
            const SFVEC2F botRight3DU( pts[2].x * m_biuTo3Dunits, -pts[2].y * m_biuTo3Dunits );
            const SFVEC2F botLeft3DU(  pts[3].x * m_biuTo3Dunits, -pts[3].y * m_biuTo3Dunits );

            aDstContainer->Add( new ROUND_SEGMENT_2D( topLeft3DU, topRight3DU,
                                                      linewidth * m_biuTo3Dunits, *aShape ) );
            aDstContainer->Add( new ROUND_SEGMENT_2D( topRight3DU, botRight3DU,
                                                      linewidth * m_biuTo3Dunits, *aShape ) );
            aDstContainer->Add( new ROUND_SEGMENT_2D( botRight3DU, botLeft3DU,
                                                      linewidth * m_biuTo3Dunits, *aShape ) );
            aDstContainer->Add( new ROUND_SEGMENT_2D( botLeft3DU, topLeft3DU,
                                                      linewidth * m_biuTo3Dunits, *aShape ) );
        }
        break;

    case SHAPE_T::ARC:
    {
        unsigned int segCount = GetCircleSegmentCount( aShape->GetBoundingBox().GetSizeMax() );

        transformArcToSegments( aShape->GetCenter(), aShape->GetStart(), aShape->GetArcAngle(),
                                segCount, linewidth, aDstContainer, *aShape );
    }
    break;

    case SHAPE_T::SEGMENT:
    {
        const SFVEC2F start3DU( aShape->GetStart().x * m_biuTo3Dunits,
                                -aShape->GetStart().y * m_biuTo3Dunits );

        const SFVEC2F end3DU  ( aShape->GetEnd().x * m_biuTo3Dunits,
                                -aShape->GetEnd().y * m_biuTo3Dunits );

        if( Is_segment_a_circle( start3DU, end3DU ) )
        {
            aDstContainer->Add( new FILLED_CIRCLE_2D( start3DU, ( linewidth / 2 ) * m_biuTo3Dunits,
                                                     *aShape ) );
        }
        else
        {
            aDstContainer->Add( new ROUND_SEGMENT_2D( start3DU, end3DU, linewidth * m_biuTo3Dunits,
                                                      *aShape ) );
        }
    }
    break;

    case SHAPE_T::BEZIER:
    case SHAPE_T::POLY:
    {
        SHAPE_POLY_SET polyList;

        aShape->TransformShapeWithClearanceToPolygon( polyList, aLayerId, 0,
                                                      ARC_HIGH_DEF, ERROR_INSIDE );

        polyList.Simplify( SHAPE_POLY_SET::PM_FAST );

        if( polyList.IsEmpty() ) // Just for caution
            break;

        ConvertPolygonToTriangles( polyList, *aDstContainer, m_biuTo3Dunits, *aShape );
    }
    break;

    default:
        wxFAIL_MSG( "BOARD_ADAPTER::addShapeWithClearance no implementation for "
                    + aShape->SHAPE_T_asString() );
        break;
    }
}

References CONTAINER_2D_BASE::Add(), ARC, BEZIER, CIRCLE, ConvertPolygonToTriangles(), ERROR_INSIDE, EDA_SHAPE::GetArcAngle(), PCB_SHAPE::GetBoundingBox(), PCB_SHAPE::GetCenter(), GetCircleSegmentCount(), EDA_SHAPE::GetEnd(), EDA_SHAPE::GetRadius(), EDA_SHAPE::GetRectCorners(), EDA_SHAPE::GetShape(), EDA_RECT::GetSizeMax(), EDA_SHAPE::GetStart(), EDA_SHAPE::GetWidth(), Is_segment_a_circle(), SHAPE_POLY_SET::IsEmpty(), EDA_SHAPE::IsFilled(), m_biuTo3Dunits, SHAPE_POLY_SET::PM_FAST, POLY, RECT, SEGMENT, EDA_SHAPE::SHAPE_T_asString(), SHAPE_POLY_SET::Simplify(), transformArcToSegments(), and PCB_SHAPE::TransformShapeWithClearanceToPolygon().

addShapeWithClearance() [3/3]

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

private

Definition at line 113 of file create_3Dgraphic_brd_items.cpp.

{
    addShapeWithClearance( &aDimension->Text(), aDstContainer, aLayerId, aClearanceValue );

    const int linewidth = aDimension->GetLineThickness() + ( 2 * aClearanceValue );

    for( const std::shared_ptr<SHAPE>& shape : aDimension->GetShapes() )
    {
        switch( shape->Type() )
        {
        case SH_SEGMENT:
        {
            const SEG& seg = static_cast<const SHAPE_SEGMENT*>( shape.get() )->GetSeg();

            const SFVEC2F start3DU( seg.A.x * m_biuTo3Dunits, -seg.A.y * m_biuTo3Dunits );

            const SFVEC2F end3DU( seg.B.x * m_biuTo3Dunits, -seg.B.y * m_biuTo3Dunits );

            aDstContainer->Add( new ROUND_SEGMENT_2D( start3DU, end3DU, linewidth * m_biuTo3Dunits,
                                                      *aDimension ) );
            break;
        }

        case SH_CIRCLE:
        {
            int radius = static_cast<const SHAPE_CIRCLE*>( shape.get() )->GetRadius();
            int deltar = aDimension->GetLineThickness();

            SFVEC2F center( shape->Centre().x * m_biuTo3Dunits,
                            shape->Centre().y * m_biuTo3Dunits );

            aDstContainer->Add( new RING_2D( center, ( radius - deltar ) * m_biuTo3Dunits,
                                             ( radius + deltar ) * m_biuTo3Dunits, *aDimension ) );

            break;
        }

        default:
            break;
        }

    }

}

References SEG::A, CONTAINER_2D_BASE::Add(), addShapeWithClearance(), SEG::B, PCB_DIMENSION_BASE::GetLineThickness(), PCB_DIMENSION_BASE::GetShapes(), m_biuTo3Dunits, SH_CIRCLE, SH_SEGMENT, PCB_DIMENSION_BASE::Text(), VECTOR2< T >::x, and VECTOR2< T >::y.

addSolidAreasShapes()

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

private

Definition at line 746 of file create_3Dgraphic_brd_items.cpp.

{
    // Copy the polys list because we have to simplify it
    SHAPE_POLY_SET polyList = SHAPE_POLY_SET( aZoneContainer->GetFilledPolysList( aLayerId ) );

    // This convert the poly in outline and holes
    ConvertPolygonToTriangles( polyList, *aDstContainer, m_biuTo3Dunits, *aZoneContainer );

    // add filled areas outlines, which are drawn with thick lines segments
    // but only if filled polygons outlines have thickness
    if( !aZoneContainer->GetFilledPolysUseThickness() )
        return;

    float line_thickness = aZoneContainer->GetMinThickness() * m_biuTo3Dunits;

    for( int i = 0; i < polyList.OutlineCount(); ++i )
    {
        // Add outline
        const SHAPE_LINE_CHAIN& pathOutline = polyList.COutline( i );

        for( int j = 0; j < pathOutline.PointCount(); ++j )
        {
            const VECTOR2I& a = pathOutline.CPoint( j );
            const VECTOR2I& b = pathOutline.CPoint( j + 1 );

            SFVEC2F start3DU( a.x * m_biuTo3Dunits, -a.y * m_biuTo3Dunits );
            SFVEC2F end3DU  ( b.x * m_biuTo3Dunits, -b.y * m_biuTo3Dunits );

            if( Is_segment_a_circle( start3DU, end3DU ) )
            {
                float radius = line_thickness/2;

                if( radius > 0.0 )  // degenerated circles crash 3D viewer
                    aDstContainer->Add( new FILLED_CIRCLE_2D( start3DU, radius, *aZoneContainer ) );
            }
            else
            {
                aDstContainer->Add( new ROUND_SEGMENT_2D( start3DU, end3DU, line_thickness,
                                                          *aZoneContainer ) );
            }
        }

        // Add holes (of the poly, ie: the open parts) for this outline
        for( int h = 0; h < polyList.HoleCount( i ); ++h )
        {
            const SHAPE_LINE_CHAIN& pathHole = polyList.CHole( i, h );

            for( int j = 0; j < pathHole.PointCount(); j++ )
            {
                const VECTOR2I& a = pathHole.CPoint( j );
                const VECTOR2I& b = pathHole.CPoint( j + 1 );

                SFVEC2F start3DU( a.x * m_biuTo3Dunits, -a.y * m_biuTo3Dunits );
                SFVEC2F end3DU  ( b.x * m_biuTo3Dunits, -b.y * m_biuTo3Dunits );

                if( Is_segment_a_circle( start3DU, end3DU ) )
                {
                    float radius = line_thickness/2;

                    if( radius > 0.0 )  // degenerated circles crash 3D viewer
                        aDstContainer->Add( new FILLED_CIRCLE_2D( start3DU, radius,
                                                                  *aZoneContainer ) );
                }
                else
                {
                    aDstContainer->Add( new ROUND_SEGMENT_2D( start3DU, end3DU, line_thickness,
                                                              *aZoneContainer ) );
                }
            }
        }
    }
}

References CONTAINER_2D_BASE::Add(), SHAPE_POLY_SET::CHole(), ConvertPolygonToTriangles(), SHAPE_POLY_SET::COutline(), SHAPE_LINE_CHAIN::CPoint(), ZONE::GetFilledPolysList(), ZONE::GetFilledPolysUseThickness(), ZONE::GetMinThickness(), SHAPE_POLY_SET::HoleCount(), Is_segment_a_circle(), m_biuTo3Dunits, SHAPE_POLY_SET::OutlineCount(), SHAPE_LINE_CHAIN::PointCount(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by createLayers().

BiuTo3dUnits()

double BOARD_ADAPTER::BiuTo3dUnits ( ) const

inlinenoexcept

Board integer units To 3D units.

Returns

the conversion factor to transform a position from the board to 3D units.

Definition at line 159 of file board_adapter.h.

    {
        return m_biuTo3Dunits;
    }

References m_biuTo3Dunits.

Referenced by RENDER_3D_LEGACY::createBoard(), createLayers(), RENDER_3D_LEGACY::generate3dGrid(), RENDER_3D_LEGACY::generateHoles(), RENDER_3D_LEGACY::generateLayerList(), RENDER_3D_LEGACY::generateViasAndPads(), RENDER_3D_RAYTRACE::insertHole(), RENDER_3D_RAYTRACE::load3DModels(), RENDER_3D_RAYTRACE::Reload(), RENDER_3D_LEGACY::renderFootprint(), and RENDER_3D_RAYTRACE::setupMaterials().

buildPadOutlineAsPolygon()

void BOARD_ADAPTER::buildPadOutlineAsPolygon ( const PAD *  aPad, SHAPE_POLY_SET &  aCornerBuffer, int  aWidth  ) const

private

Definition at line 37 of file create_layer_poly.cpp.

{
    if( aPad->GetShape() == PAD_SHAPE::CIRCLE )    // Draw a ring
    {
        TransformRingToPolygon( aCornerBuffer, aPad->ShapePos(), aPad->GetSize().x / 2,
                                aWidth, ARC_HIGH_DEF, ERROR_INSIDE );
        return;
    }

    // For other shapes, add outlines as thick segments in polygon buffer
    const std::shared_ptr<SHAPE_POLY_SET>& corners = aPad->GetEffectivePolygon();
    const SHAPE_LINE_CHAIN&                path = corners->COutline( 0 );

    for( int ii = 0; ii < path.PointCount(); ++ii )
    {
        const VECTOR2I& a = path.CPoint( ii );
        const VECTOR2I& b = path.CPoint( ii + 1 );

        TransformOvalToPolygon( aCornerBuffer, (wxPoint) a, (wxPoint) b, aWidth, ARC_HIGH_DEF,
                                ERROR_INSIDE );
    }
}

References CIRCLE, ERROR_INSIDE, PAD::GetEffectivePolygon(), PAD::GetShape(), PAD::GetSize(), path, PAD::ShapePos(), TransformOvalToPolygon(), and TransformRingToPolygon().

Referenced by createLayers().

buildPadOutlineAsSegments()

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

private

Definition at line 821 of file create_3Dgraphic_brd_items.cpp.

{
    if( aPad->GetShape() == PAD_SHAPE::CIRCLE )    // Draw a ring
    {
        const SFVEC2F center3DU( aPad->ShapePos().x * m_biuTo3Dunits,
                                 -aPad->ShapePos().y * m_biuTo3Dunits );

        const int radius = aPad->GetSize().x / 2;
        const float inner_radius = ( radius - aWidth / 2 ) * m_biuTo3Dunits;
        const float outer_radius = ( radius + aWidth / 2 ) * m_biuTo3Dunits;

        aDstContainer->Add( new RING_2D( center3DU, inner_radius, outer_radius, *aPad ) );

        return;
    }

    // For other shapes, add outlines as thick segments in polygon buffer
    const std::shared_ptr<SHAPE_POLY_SET>& corners = aPad->GetEffectivePolygon();
    const SHAPE_LINE_CHAIN&                path = corners->COutline( 0 );

    for( int j = 0; j < path.PointCount(); j++ )
    {
        const VECTOR2I& a = path.CPoint( j );
        const VECTOR2I& b = path.CPoint( j + 1 );

        SFVEC2F start3DU( a.x * m_biuTo3Dunits, -a.y * m_biuTo3Dunits );
        SFVEC2F end3DU  ( b.x * m_biuTo3Dunits, -b.y * m_biuTo3Dunits );

        if( Is_segment_a_circle( start3DU, end3DU ) )
        {
            aDstContainer->Add( new FILLED_CIRCLE_2D( start3DU, ( aWidth / 2 ) * m_biuTo3Dunits,
                                                      *aPad ) );
        }
        else
        {
            aDstContainer->Add( new ROUND_SEGMENT_2D( start3DU, end3DU, aWidth * m_biuTo3Dunits,
                                                      *aPad ) );
        }
    }
}

References CONTAINER_2D_BASE::Add(), CIRCLE, PAD::GetEffectivePolygon(), PAD::GetShape(), PAD::GetSize(), Is_segment_a_circle(), m_biuTo3Dunits, path, PAD::ShapePos(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by createLayers().

createBoardPolygon()

bool BOARD_ADAPTER::createBoardPolygon ( wxString *  aErrorMsg )

private

Create the board outline polygon.

Returns

false if the outline could not be created

Definition at line 695 of file board_adapter.cpp.

{
    m_board_poly.RemoveAllContours();

    if( !m_board )
        return false;

    bool success;

    if( m_board->IsFootprintHolder() )
    {
        if( !m_board->GetFirstFootprint() )
        {
            if( aErrorMsg )
                *aErrorMsg = _( "No footprint loaded." );

            return false;
        }

        int chainingEpsilon = Millimeter2iu( 0.02 );  // max dist from one endPt to next startPt

        success = BuildFootprintPolygonOutlines( m_board, m_board_poly,
                                                 m_board->GetDesignSettings().m_MaxError,
                                                 chainingEpsilon );

        // Make polygon strictly simple to avoid issues (especially in 3D viewer)
        m_board_poly.Simplify( SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );

        if( !success && aErrorMsg )
        {
            *aErrorMsg = _( "Footprint outline is missing or malformed. Run Footprint Checker for "
                            "a full analysis." );
        }
    }
    else
    {
        success = m_board->GetBoardPolygonOutlines( m_board_poly );

        if( !success && aErrorMsg )
            *aErrorMsg = _( "Board outline is missing or malformed. Run DRC for a full analysis." );
    }

    return success;
}

References _, BuildFootprintPolygonOutlines(), BOARD::GetBoardPolygonOutlines(), BOARD::GetDesignSettings(), BOARD::GetFirstFootprint(), BOARD::IsFootprintHolder(), m_board, m_board_poly, BOARD_DESIGN_SETTINGS::m_MaxError, Millimeter2iu(), SHAPE_POLY_SET::PM_STRICTLY_SIMPLE, SHAPE_POLY_SET::RemoveAllContours(), and SHAPE_POLY_SET::Simplify().

Referenced by InitSettings().

createLayers()

void BOARD_ADAPTER::createLayers ( REPORTER *  aStatusReporter )

private

Definition at line 127 of file create_layer_items.cpp.

{
    destroyLayers();

    // Build Copper layers
    // Based on:
    //    https://github.com/KiCad/kicad-source-mirror/blob/master/3d-viewer/3d_draw.cpp#L692

#ifdef PRINT_STATISTICS_3D_VIEWER
    unsigned stats_startCopperLayersTime = GetRunningMicroSecs();

    unsigned start_Time = stats_startCopperLayersTime;
#endif

    PCB_LAYER_ID cu_seq[MAX_CU_LAYERS];
    LSET         cu_set = LSET::AllCuMask( m_copperLayersCount );

    m_trackCount               = 0;
    m_averageTrackWidth        = 0;
    m_viaCount                 = 0;
    m_averageViaHoleDiameter   = 0;
    m_holeCount                = 0;
    m_averageHoleDiameter      = 0;

    if( !m_board )
        return;

    // Prepare track list, convert in a vector. Calc statistic for the holes
    std::vector<const PCB_TRACK*> trackList;
    trackList.clear();
    trackList.reserve( m_board->Tracks().size() );

    for( PCB_TRACK* track : m_board->Tracks() )
    {
        if( !Is3dLayerEnabled( track->GetLayer() ) ) // Skip non enabled layers
            continue;

        // Note: a PCB_TRACK holds normal segment tracks and also vias circles (that have also
        // drill values)
        trackList.push_back( track );

        if( track->Type() == PCB_VIA_T )
        {
            const PCB_VIA *via = static_cast< const PCB_VIA*>( track );
            m_viaCount++;
            m_averageViaHoleDiameter += via->GetDrillValue() * m_biuTo3Dunits;
        }
        else
        {
            m_trackCount++;
        }

        m_averageTrackWidth += track->GetWidth() * m_biuTo3Dunits;
    }

    if( m_trackCount )
        m_averageTrackWidth /= (float)m_trackCount;

    if( m_viaCount )
        m_averageViaHoleDiameter /= (float)m_viaCount;

    // Prepare copper layers index and containers
    std::vector< PCB_LAYER_ID > layer_id;
    layer_id.clear();
    layer_id.reserve( m_copperLayersCount );

    for( unsigned i = 0; i < arrayDim( cu_seq ); ++i )
        cu_seq[i] = ToLAYER_ID( B_Cu - i );

    for( LSEQ cu = cu_set.Seq( cu_seq, arrayDim( cu_seq ) ); cu; ++cu )
    {
        const PCB_LAYER_ID curr_layer_id = *cu;

        if( !Is3dLayerEnabled( curr_layer_id ) ) // Skip non enabled layers
            continue;

        layer_id.push_back( curr_layer_id );

        BVH_CONTAINER_2D *layerContainer = new BVH_CONTAINER_2D;
        m_layerMap[curr_layer_id] = layerContainer;

        if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS )
          && ( m_renderEngine == RENDER_ENGINE::OPENGL_LEGACY ) )
        {
            SHAPE_POLY_SET* layerPoly    = new SHAPE_POLY_SET;
            m_layers_poly[curr_layer_id] = layerPoly;
        }
    }

    if( GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) && GetFlag( FL_USE_REALISTIC_MODE ) )
    {
        m_frontPlatedPadPolys = new SHAPE_POLY_SET;
        m_backPlatedPadPolys = new SHAPE_POLY_SET;

        m_platedPadsFront = new BVH_CONTAINER_2D;
        m_platedPadsBack = new BVH_CONTAINER_2D;

    }

    if( aStatusReporter )
        aStatusReporter->Report( _( "Create tracks and vias" ) );

    // Create tracks as objects and add it to container
    for( PCB_LAYER_ID curr_layer_id : layer_id )
    {
        wxASSERT( m_layerMap.find( curr_layer_id ) != m_layerMap.end() );

        BVH_CONTAINER_2D *layerContainer = m_layerMap[curr_layer_id];

        // Add track segments shapes and via annulus shapes
        unsigned int nTracks = trackList.size();

        for( unsigned int trackIdx = 0; trackIdx < nTracks; ++trackIdx )
        {
            const PCB_TRACK *track = trackList[trackIdx];

            // NOTE: Vias can be on multiple layers
            if( !track->IsOnLayer( curr_layer_id ) )
                continue;

            // Skip vias annulus when not connected on this layer (if removing is enabled)
            const PCB_VIA *via = dyn_cast< const PCB_VIA*>( track );

            if( via && !via->FlashLayer( curr_layer_id ) && IsCopperLayer( curr_layer_id ) )
                continue;

            // Add object item to layer container
            createTrack( track, layerContainer, 0.0f );
        }
    }

    // Create VIAS and THTs objects and add it to holes containers
    for( PCB_LAYER_ID curr_layer_id : layer_id )
    {
        // ADD TRACKS
        unsigned int nTracks = trackList.size();

        for( unsigned int trackIdx = 0; trackIdx < nTracks; ++trackIdx )
        {
            const PCB_TRACK *track = trackList[trackIdx];

            if( !track->IsOnLayer( curr_layer_id ) )
                continue;

            // ADD VIAS and THT
            if( track->Type() == PCB_VIA_T )
            {
                const PCB_VIA* via               = static_cast<const PCB_VIA*>( track );
                const VIATYPE  viatype           = via->GetViaType();
                const float    holediameter      = via->GetDrillValue() * BiuTo3dUnits();

                // holes and layer copper extend half info cylinder wall to hide transition
                const float    thickness         = GetHolePlatingThickness() * BiuTo3dUnits() / 2.0f;
                const float    hole_inner_radius = holediameter / 2.0f;
                const float    ring_radius       = via->GetWidth() * BiuTo3dUnits() / 2.0f;

                const SFVEC2F via_center( via->GetStart().x * m_biuTo3Dunits,
                                          -via->GetStart().y * m_biuTo3Dunits );

                if( viatype != VIATYPE::THROUGH )
                {

                    // Add hole objects
                    BVH_CONTAINER_2D *layerHoleContainer = nullptr;

                    // Check if the layer is already created
                    if( m_layerHoleMap.find( curr_layer_id ) == m_layerHoleMap.end() )
                    {
                        // not found, create a new container
                        layerHoleContainer = new BVH_CONTAINER_2D;
                        m_layerHoleMap[curr_layer_id] = layerHoleContainer;
                    }
                    else
                    {
                        // found
                        layerHoleContainer = m_layerHoleMap[curr_layer_id];
                    }

                    // Add a hole for this layer
                    layerHoleContainer->Add( new FILLED_CIRCLE_2D( via_center,
                                                                   hole_inner_radius + thickness,
                                                                   *track ) );
                }
                else if( curr_layer_id == layer_id[0] ) // it only adds once the THT holes
                {
                    // Add through hole object
                    m_throughHoleOds.Add( new FILLED_CIRCLE_2D( via_center,
                                                                     hole_inner_radius + thickness,
                                                                     *track ) );
                    m_throughHoleViaOds.Add( new FILLED_CIRCLE_2D( via_center,
                                                                   hole_inner_radius + thickness,
                                                                   *track ) );

                    if( GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) &&
                        GetFlag( FL_USE_REALISTIC_MODE ) )
                    {
                        m_throughHoleAnnularRings.Add( new FILLED_CIRCLE_2D( via_center,
                                                                              ring_radius,
                                                                              *track ) );
                    }

                    m_throughHoleIds.Add( new FILLED_CIRCLE_2D( via_center, hole_inner_radius,
                                                                     *track ) );
                }
            }
        }
    }

    // Create VIAS and THTs objects and add it to holes containers
    for( PCB_LAYER_ID curr_layer_id : layer_id )
    {
        // ADD TRACKS
        const unsigned int nTracks = trackList.size();

        for( unsigned int trackIdx = 0; trackIdx < nTracks; ++trackIdx )
        {
            const PCB_TRACK *track = trackList[trackIdx];

            if( !track->IsOnLayer( curr_layer_id ) )
                continue;

            // ADD VIAS and THT
            if( track->Type() == PCB_VIA_T )
            {
                const PCB_VIA* via = static_cast<const PCB_VIA*>( track );
                const VIATYPE  viatype = via->GetViaType();

                if( viatype != VIATYPE::THROUGH )
                {
                    // Add PCB_VIA hole contours

                    // Add outer holes of VIAs
                    SHAPE_POLY_SET *layerOuterHolesPoly = nullptr;
                    SHAPE_POLY_SET *layerInnerHolesPoly = nullptr;

                    // Check if the layer is already created
                    if( m_layerHoleOdPolys.find( curr_layer_id ) ==
                        m_layerHoleOdPolys.end() )
                    {
                        // not found, create a new container
                        layerOuterHolesPoly = new SHAPE_POLY_SET;
                        m_layerHoleOdPolys[curr_layer_id] = layerOuterHolesPoly;

                        wxASSERT( m_layerHoleIdPolys.find( curr_layer_id ) ==
                                  m_layerHoleIdPolys.end() );

                        layerInnerHolesPoly = new SHAPE_POLY_SET;
                        m_layerHoleIdPolys[curr_layer_id] = layerInnerHolesPoly;
                    }
                    else
                    {
                        // found
                        layerOuterHolesPoly = m_layerHoleOdPolys[curr_layer_id];

                        wxASSERT( m_layerHoleIdPolys.find( curr_layer_id ) !=
                                  m_layerHoleIdPolys.end() );

                        layerInnerHolesPoly = m_layerHoleIdPolys[curr_layer_id];
                    }

                    const int holediameter = via->GetDrillValue();
                    const int hole_outer_radius = (holediameter / 2) + GetHolePlatingThickness();

                    TransformCircleToPolygon( *layerOuterHolesPoly, via->GetStart(),
                                              hole_outer_radius, ARC_HIGH_DEF, ERROR_INSIDE );

                    TransformCircleToPolygon( *layerInnerHolesPoly, via->GetStart(),
                                              holediameter / 2, ARC_HIGH_DEF, ERROR_INSIDE );
                }
                else if( curr_layer_id == layer_id[0] ) // it only adds once the THT holes
                {
                    const int holediameter = via->GetDrillValue();
                    const int hole_outer_radius = (holediameter / 2) + GetHolePlatingThickness();
                    const int hole_outer_ring_radius = via->GetWidth() / 2.0f;

                    // Add through hole contours
                    TransformCircleToPolygon( m_throughHoleOdPolys, via->GetStart(),
                                              hole_outer_radius, ARC_HIGH_DEF, ERROR_INSIDE );

                    // Add same thing for vias only
                    TransformCircleToPolygon( m_throughHoleViaOdPolys, via->GetStart(),
                                              hole_outer_radius, ARC_HIGH_DEF, ERROR_INSIDE );

                    if( GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) && GetFlag( FL_USE_REALISTIC_MODE ) )
                    {
                        TransformCircleToPolygon( m_throughHoleAnnularRingPolys,
                                                  via->GetStart(), hole_outer_ring_radius,
                                                  ARC_HIGH_DEF, ERROR_INSIDE );
                    }
                }
            }
        }
    }

    // Creates vertical outline contours of the tracks and add it to the poly of the layer
    if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS )
      && ( m_renderEngine == RENDER_ENGINE::OPENGL_LEGACY ) )
    {
        for( PCB_LAYER_ID curr_layer_id : layer_id )
        {
            wxASSERT( m_layers_poly.find( curr_layer_id ) != m_layers_poly.end() );

            SHAPE_POLY_SET *layerPoly = m_layers_poly[curr_layer_id];

            // ADD TRACKS
            unsigned int nTracks = trackList.size();

            for( unsigned int trackIdx = 0; trackIdx < nTracks; ++trackIdx )
            {
                const PCB_TRACK *track = trackList[trackIdx];

                if( !track->IsOnLayer( curr_layer_id ) )
                    continue;

                // Skip vias annulus when not connected on this layer (if removing is enabled)
                const PCB_VIA *via = dyn_cast<const PCB_VIA*>( track );

                if( via && !via->FlashLayer( curr_layer_id ) && IsCopperLayer( curr_layer_id ) )
                    continue;

                // Add the track/via contour
                track->TransformShapeWithClearanceToPolygon( *layerPoly, curr_layer_id, 0,
                                                             ARC_HIGH_DEF, ERROR_INSIDE );
            }
        }
    }

    // Add holes of footprints
    for( FOOTPRINT* footprint : m_board->Footprints() )
    {
        for( PAD* pad : footprint->Pads() )
        {
            const wxSize padHole = pad->GetDrillSize();

            if( !padHole.x )    // Not drilled pad like SMD pad
                continue;

            // The hole in the body is inflated by copper thickness, if not plated, no copper
            const int inflate = ( pad->GetAttribute () != PAD_ATTRIB::NPTH ) ?
                                GetHolePlatingThickness() / 2 : 0;

            m_holeCount++;
            m_averageHoleDiameter += ( ( pad->GetDrillSize().x +
                                             pad->GetDrillSize().y ) / 2.0f ) * m_biuTo3Dunits;

            m_throughHoleOds.Add( createPadWithDrill( pad, inflate ) );

            if( GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) && GetFlag( FL_USE_REALISTIC_MODE ) )
            {
                m_throughHoleAnnularRings.Add( createPadWithDrill( pad, inflate ) );
            }

            m_throughHoleIds.Add( createPadWithDrill( pad, 0 ) );
        }
    }

    if( m_holeCount )
        m_averageHoleDiameter /= (float)m_holeCount;

    // Add contours of the pad holes (pads can be Circle or Segment holes)
    for( FOOTPRINT* footprint : m_board->Footprints() )
    {
        for( PAD* pad : footprint->Pads() )
        {
            const wxSize padHole = pad->GetDrillSize();

            if( !padHole.x ) // Not drilled pad like SMD pad
                continue;

            // The hole in the body is inflated by copper thickness.
            const int inflate = GetHolePlatingThickness();

            if( pad->GetAttribute () != PAD_ATTRIB::NPTH )
            {
                if( GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) && GetFlag( FL_USE_REALISTIC_MODE ) )
                {
                    pad->TransformHoleWithClearanceToPolygon( m_throughHoleAnnularRingPolys,
                                                              inflate, ARC_HIGH_DEF, ERROR_INSIDE );
                }

                pad->TransformHoleWithClearanceToPolygon( m_throughHoleOdPolys, inflate,
                                                          ARC_HIGH_DEF, ERROR_INSIDE );
            }
            else
            {
                // If not plated, no copper.
                if( GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) && GetFlag( FL_USE_REALISTIC_MODE ) )
                {
                    pad->TransformHoleWithClearanceToPolygon( m_throughHoleAnnularRingPolys, 0,
                                                              ARC_HIGH_DEF, ERROR_INSIDE );
                }

                pad->TransformHoleWithClearanceToPolygon( m_nonPlatedThroughHoleOdPolys, 0,
                                                          ARC_HIGH_DEF, ERROR_INSIDE );
            }
        }
    }

    const bool renderPlatedPadsAsPlated = GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) &&
                                          GetFlag( FL_USE_REALISTIC_MODE );

    // Add footprints PADs objects to containers
    for( PCB_LAYER_ID curr_layer_id : layer_id )
    {
        wxASSERT( m_layerMap.find( curr_layer_id ) != m_layerMap.end() );

        BVH_CONTAINER_2D *layerContainer = m_layerMap[curr_layer_id];

        // ADD PADS
        for( FOOTPRINT* footprint : m_board->Footprints() )
        {
            // Note: NPTH pads are not drawn on copper layers when the pad
            // has same shape as its hole
            addPadsWithClearance( footprint, layerContainer, curr_layer_id, 0,
                                  true, renderPlatedPadsAsPlated, false );

            // Micro-wave footprints may have items on copper layers
            addFootprintShapesWithClearance( footprint, layerContainer, curr_layer_id, 0 );
        }
    }

    if( renderPlatedPadsAsPlated )
    {
        // ADD PLATED PADS
        for( FOOTPRINT* footprint : m_board->Footprints() )
        {
            addPadsWithClearance( footprint, m_platedPadsFront, F_Cu, 0, true, false, true );

            addPadsWithClearance( footprint, m_platedPadsBack, B_Cu, 0, true, false, true );
        }

        m_platedPadsFront->BuildBVH();
        m_platedPadsBack->BuildBVH();
    }

    // Add footprints PADs poly contours (vertical outlines)
    if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS )
      && ( m_renderEngine == RENDER_ENGINE::OPENGL_LEGACY ) )
    {
        for( PCB_LAYER_ID curr_layer_id : layer_id )
        {
            wxASSERT( m_layers_poly.find( curr_layer_id ) != m_layers_poly.end() );

            SHAPE_POLY_SET *layerPoly = m_layers_poly[curr_layer_id];

            // Add pads to polygon list
            for( FOOTPRINT* footprint : m_board->Footprints() )
            {
                // Note: NPTH pads are not drawn on copper layers when the pad
                // has same shape as its hole
                footprint->TransformPadsWithClearanceToPolygon( *layerPoly, curr_layer_id,
                                                                0, ARC_HIGH_DEF, ERROR_INSIDE,
                                                                true, renderPlatedPadsAsPlated,
                                                                false );

                transformFPShapesToPolygon( footprint, curr_layer_id, *layerPoly );
            }
        }

        if( renderPlatedPadsAsPlated )
        {
            // ADD PLATED PADS contours
            for( FOOTPRINT* footprint : m_board->Footprints() )
            {
                footprint->TransformPadsWithClearanceToPolygon( *m_frontPlatedPadPolys, F_Cu,
                                                                0, ARC_HIGH_DEF, ERROR_INSIDE,
                                                                true, false, true );

                footprint->TransformPadsWithClearanceToPolygon( *m_backPlatedPadPolys, B_Cu,
                                                                0, ARC_HIGH_DEF, ERROR_INSIDE,
                                                                true, false, true );
            }
        }
    }

    // Add graphic item on copper layers to object containers
    for( PCB_LAYER_ID curr_layer_id : layer_id )
    {
        wxASSERT( m_layerMap.find( curr_layer_id ) != m_layerMap.end() );

        BVH_CONTAINER_2D *layerContainer = m_layerMap[curr_layer_id];

        // Add graphic items on copper layers (texts and other graphics)
        for( BOARD_ITEM* item : m_board->Drawings() )
        {
            if( !item->IsOnLayer( curr_layer_id ) )
                continue;

            switch( item->Type() )
            {
            case PCB_SHAPE_T:
                addShapeWithClearance( static_cast<PCB_SHAPE*>( item ), layerContainer,
                                       curr_layer_id, 0 );
            break;

            case PCB_TEXT_T:
                addShapeWithClearance( static_cast<PCB_TEXT*>( item ), layerContainer,
                                       curr_layer_id, 0 );
            break;

            case PCB_DIM_ALIGNED_T:
            case PCB_DIM_CENTER_T:
            case PCB_DIM_ORTHOGONAL_T:
            case PCB_DIM_LEADER_T:
                addShapeWithClearance( static_cast<PCB_DIMENSION_BASE*>( item ),
                                       layerContainer, curr_layer_id, 0 );
            break;

            default:
                wxLogTrace( m_logTrace, wxT( "createLayers: item type: %d not implemented" ),
                            item->Type() );
            break;
            }
        }
    }

    // Add graphic item on copper layers to poly contours (vertical outlines)
    if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS )
      && ( m_renderEngine == RENDER_ENGINE::OPENGL_LEGACY ) )
    {
        for( PCB_LAYER_ID cur_layer_id : layer_id )
        {
            wxASSERT( m_layers_poly.find( cur_layer_id ) != m_layers_poly.end() );

            SHAPE_POLY_SET *layerPoly = m_layers_poly[cur_layer_id];

            // Add graphic items on copper layers (texts and other )
            for( BOARD_ITEM* item : m_board->Drawings() )
            {
                if( !item->IsOnLayer( cur_layer_id ) )
                    continue;

                switch( item->Type() )
                {
                case PCB_SHAPE_T:
                    item->TransformShapeWithClearanceToPolygon( *layerPoly, cur_layer_id, 0,
                                                                ARC_HIGH_DEF, ERROR_INSIDE );
                    break;

                case PCB_TEXT_T:
                {
                    PCB_TEXT* text = static_cast<PCB_TEXT*>( item );

                    text->TransformTextShapeWithClearanceToPolygon( *layerPoly, cur_layer_id, 0,
                                                                    ARC_HIGH_DEF, ERROR_INSIDE );
                }
                    break;

                default:
                    wxLogTrace( m_logTrace, wxT( "createLayers: item type: %d not implemented" ),
                                item->Type() );
                    break;
                }
            }
        }
    }

    if( GetFlag( FL_ZONE ) )
    {
        if( aStatusReporter )
            aStatusReporter->Report( _( "Create zones" ) );

        std::vector<std::pair<ZONE*, PCB_LAYER_ID>> zones;
        std::unordered_map<PCB_LAYER_ID, std::unique_ptr<std::mutex>> layer_lock;

        for( ZONE* zone : m_board->Zones() )
        {
            for( PCB_LAYER_ID layer : zone->GetLayerSet().Seq() )
            {
                zones.emplace_back( std::make_pair( zone, layer ) );
                layer_lock.emplace( layer, std::make_unique<std::mutex>() );
            }
        }

        // Add zones objects
        std::atomic<size_t> nextZone( 0 );
        std::atomic<size_t> threadsFinished( 0 );

        size_t parallelThreadCount = std::min<size_t>( zones.size(),
                std::max<size_t>( std::thread::hardware_concurrency(), 2 ) );

        for( size_t ii = 0; ii < parallelThreadCount; ++ii )
        {
            std::thread t = std::thread( [&]()
            {
                for( size_t areaId = nextZone.fetch_add( 1 );
                            areaId < zones.size();
                            areaId = nextZone.fetch_add( 1 ) )
                {
                    ZONE* zone = zones[areaId].first;

                    if( zone == nullptr )
                        break;

                    PCB_LAYER_ID layer = zones[areaId].second;

                    auto layerContainer = m_layerMap.find( layer );
                    auto layerPolyContainer = m_layers_poly.find( layer );

                    if( layerContainer != m_layerMap.end() )
                    {
                        addSolidAreasShapes( zone, layerContainer->second, layer );
                    }

                    if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS )
                      && ( m_renderEngine == RENDER_ENGINE::OPENGL_LEGACY )
                      && layerPolyContainer != m_layers_poly.end() )
                    {
                        auto mut_it = layer_lock.find( layer );

                        std::lock_guard< std::mutex > lock( *( mut_it->second ) );
                        zone->TransformSolidAreasShapesToPolygon( layer, *layerPolyContainer->second );
                    }
                }

                threadsFinished++;
            } );

            t.detach();
        }

        while( threadsFinished < parallelThreadCount )
            std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) );

    }

    // Simplify layer polygons

    if( aStatusReporter )
        aStatusReporter->Report( _( "Simplifying copper layers polygons" ) );

    if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS )
      && ( m_renderEngine == RENDER_ENGINE::OPENGL_LEGACY ) )
    {
        if( GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) && GetFlag( FL_USE_REALISTIC_MODE ) )
        {
            if( m_frontPlatedPadPolys && ( m_layers_poly.find( F_Cu ) != m_layers_poly.end() ) )
            {
                if( aStatusReporter )
                    aStatusReporter->Report( _( "Simplifying polygons on F_Cu" ) );

                SHAPE_POLY_SET *layerPoly_F_Cu = m_layers_poly[F_Cu];
                layerPoly_F_Cu->BooleanSubtract( *m_frontPlatedPadPolys, SHAPE_POLY_SET::PM_FAST );

                 m_frontPlatedPadPolys->Simplify( SHAPE_POLY_SET::PM_FAST );
            }

            if( m_backPlatedPadPolys && ( m_layers_poly.find( B_Cu ) != m_layers_poly.end() ) )
            {
                if( aStatusReporter )
                    aStatusReporter->Report( _( "Simplifying polygons on B_Cu" ) );

                SHAPE_POLY_SET *layerPoly_B_Cu = m_layers_poly[B_Cu];
                layerPoly_B_Cu->BooleanSubtract( *m_backPlatedPadPolys, SHAPE_POLY_SET::PM_FAST );

                m_backPlatedPadPolys->Simplify( SHAPE_POLY_SET::PM_FAST );
            }
        }

        std::vector< PCB_LAYER_ID > &selected_layer_id = layer_id;
        std::vector< PCB_LAYER_ID > layer_id_without_F_and_B;

        if( GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) && GetFlag( FL_USE_REALISTIC_MODE ) )
        {
            layer_id_without_F_and_B.clear();
            layer_id_without_F_and_B.reserve( layer_id.size() );

            for( size_t i = 0; i < layer_id.size(); ++i )
            {
                if( ( layer_id[i] != F_Cu ) && ( layer_id[i] != B_Cu ) )
                    layer_id_without_F_and_B.push_back( layer_id[i] );
            }

            selected_layer_id = layer_id_without_F_and_B;
        }

        if( selected_layer_id.size() > 0 )
        {
            if( aStatusReporter )
                aStatusReporter->Report( wxString::Format(
                                         _( "Simplifying %d copper layers" ),
                                         (int)selected_layer_id.size() ) );

            std::atomic<size_t> nextItem( 0 );
            std::atomic<size_t> threadsFinished( 0 );

            size_t parallelThreadCount = std::min<size_t>(
                    std::max<size_t>( std::thread::hardware_concurrency(), 2 ),
                    selected_layer_id.size() );

            for( size_t ii = 0; ii < parallelThreadCount; ++ii )
            {
                std::thread t = std::thread(
                        [&nextItem, &threadsFinished, &selected_layer_id, this]()
                        {
                            for( size_t i = nextItem.fetch_add( 1 );
                                        i < selected_layer_id.size();
                                        i = nextItem.fetch_add( 1 ) )
                            {
                                auto layerPoly = m_layers_poly.find( selected_layer_id[i] );

                                if( layerPoly != m_layers_poly.end() )
                                    // This will make a union of all added contours
                                    layerPoly->second->Simplify( SHAPE_POLY_SET::PM_FAST );
                            }

                            threadsFinished++;
                        } );

                t.detach();
            }

            while( threadsFinished < parallelThreadCount )
                std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) );
        }
    }

    // Simplify holes polygon contours
    if( aStatusReporter )
        aStatusReporter->Report( _( "Simplify holes contours" ) );

    for( PCB_LAYER_ID layer : layer_id )
    {
        if( m_layerHoleOdPolys.find( layer ) != m_layerHoleOdPolys.end() )
        {
            // found
            SHAPE_POLY_SET *polyLayer = m_layerHoleOdPolys[layer];
            polyLayer->Simplify( SHAPE_POLY_SET::PM_FAST );

            wxASSERT( m_layerHoleIdPolys.find( layer ) != m_layerHoleIdPolys.end() );

            polyLayer = m_layerHoleIdPolys[layer];
            polyLayer->Simplify( SHAPE_POLY_SET::PM_FAST );
        }
    }

    // End Build Copper layers

    // This will make a union of all added contours
    m_throughHoleOdPolys.Simplify( SHAPE_POLY_SET::PM_FAST );
    m_nonPlatedThroughHoleOdPolys.Simplify( SHAPE_POLY_SET::PM_FAST );
    m_throughHoleViaOdPolys.Simplify( SHAPE_POLY_SET::PM_FAST );
    m_throughHoleAnnularRingPolys.Simplify( SHAPE_POLY_SET::PM_FAST );

    // Build Tech layers
    // Based on:
    //    https://github.com/KiCad/kicad-source-mirror/blob/master/3d-viewer/3d_draw.cpp#L1059
    if( aStatusReporter )
        aStatusReporter->Report( _( "Build Tech layers" ) );

    // draw graphic items, on technical layers
    static const PCB_LAYER_ID teckLayerList[] = {
            B_Adhes,
            F_Adhes,
            B_Paste,
            F_Paste,
            B_SilkS,
            F_SilkS,
            B_Mask,
            F_Mask,

            // Aux Layers
            Dwgs_User,
            Cmts_User,
            Eco1_User,
            Eco2_User,
            Edge_Cuts,
            Margin
        };

    // User layers are not drawn here, only technical layers
    for( LSEQ seq = LSET::AllNonCuMask().Seq( teckLayerList, arrayDim( teckLayerList ) );
         seq;
         ++seq )
    {
        const PCB_LAYER_ID curr_layer_id = *seq;

        if( !Is3dLayerEnabled( curr_layer_id ) )
            continue;

        if( aStatusReporter )
            aStatusReporter->Report( wxString::Format(
                                     _( "Build Tech layer %d" ), (int)curr_layer_id ) );

        BVH_CONTAINER_2D *layerContainer = new BVH_CONTAINER_2D;
        m_layerMap[curr_layer_id] = layerContainer;

        SHAPE_POLY_SET *layerPoly = new SHAPE_POLY_SET;
        m_layers_poly[curr_layer_id] = layerPoly;

        // Add drawing objects
        for( BOARD_ITEM* item : m_board->Drawings() )
        {
            if( !item->IsOnLayer( curr_layer_id ) )
                continue;

            switch( item->Type() )
            {
            case PCB_SHAPE_T:
                addShapeWithClearance( static_cast<PCB_SHAPE*>( item ), layerContainer,
                                       curr_layer_id, 0 );
                break;

            case PCB_TEXT_T:
                addShapeWithClearance( static_cast<PCB_TEXT*>( item ), layerContainer,
                                       curr_layer_id, 0 );
                break;

            case PCB_DIM_ALIGNED_T:
            case PCB_DIM_CENTER_T:
            case PCB_DIM_ORTHOGONAL_T:
            case PCB_DIM_LEADER_T:
                addShapeWithClearance( static_cast<PCB_DIMENSION_BASE*>( item ), layerContainer,
                                       curr_layer_id, 0 );
                break;

            default:
                break;
            }
        }

        // Add drawing contours
        for( BOARD_ITEM* item : m_board->Drawings() )
        {
            if( !item->IsOnLayer( curr_layer_id ) )
                continue;

            switch( item->Type() )
            {
            case PCB_SHAPE_T:
                item->TransformShapeWithClearanceToPolygon( *layerPoly, curr_layer_id, 0,
                                                            ARC_HIGH_DEF, ERROR_INSIDE );
                break;

            case PCB_TEXT_T:
            {
                PCB_TEXT* text = static_cast<PCB_TEXT*>( item );

                text->TransformTextShapeWithClearanceToPolygon( *layerPoly, curr_layer_id, 0,
                                                                ARC_HIGH_DEF, ERROR_INSIDE );
            }
                break;

            default:
                break;
            }
        }

        // Add footprints tech layers - objects
        for( FOOTPRINT* footprint : m_board->Footprints() )
        {
            if( ( curr_layer_id == F_SilkS ) || ( curr_layer_id == B_SilkS ) )
            {
                int linewidth = m_board->GetDesignSettings().m_LineThickness[ LAYER_CLASS_SILK ];

                for( PAD* pad : footprint->Pads() )
                {
                    if( !pad->IsOnLayer( curr_layer_id ) )
                        continue;

                    buildPadOutlineAsSegments( pad, layerContainer, linewidth );
                }
            }
            else
            {
                addPadsWithClearance( footprint, layerContainer, curr_layer_id, 0,
                                      false, false, false );
            }

            addFootprintShapesWithClearance( footprint, layerContainer, curr_layer_id, 0 );
        }


        // Add footprints tech layers - contours
        for( FOOTPRINT* footprint : m_board->Footprints() )
        {
            if( ( curr_layer_id == F_SilkS ) || ( curr_layer_id == B_SilkS ) )
            {
                int linewidth = m_board->GetDesignSettings().m_LineThickness[ LAYER_CLASS_SILK ];

                for( PAD* pad : footprint->Pads() )
                {
                    if( !pad->IsOnLayer( curr_layer_id ) )
                        continue;

                    buildPadOutlineAsPolygon( pad, *layerPoly, linewidth );
                }
            }
            else
            {
                footprint->TransformPadsWithClearanceToPolygon( *layerPoly, curr_layer_id, 0,
                                                                ARC_HIGH_DEF, ERROR_INSIDE );
            }

            // On tech layers, use a poor circle approximation, only for texts (stroke font)
            footprint->TransformFPTextWithClearanceToPolygonSet( *layerPoly, curr_layer_id, 0,
                                                                 ARC_HIGH_DEF, ERROR_INSIDE );

            // Add the remaining things with dynamic seg count for circles
            transformFPShapesToPolygon( footprint, curr_layer_id, *layerPoly );
        }


        // Draw non copper zones
        if( GetFlag( FL_ZONE ) )
        {
            for( ZONE* zone : m_board->Zones() )
            {
                if( zone->IsOnLayer( curr_layer_id ) )
                    addSolidAreasShapes( zone, layerContainer, curr_layer_id );
            }

            for( ZONE* zone : m_board->Zones() )
            {
                if( zone->IsOnLayer( curr_layer_id ) )
                    zone->TransformSolidAreasShapesToPolygon( curr_layer_id, *layerPoly );
            }
        }

        // This will make a union of all added contours
        layerPoly->Simplify( SHAPE_POLY_SET::PM_FAST );
    }
    // End Build Tech layers

    // Build BVH (Bounding volume hierarchy) for holes and vias

    if( aStatusReporter )
        aStatusReporter->Report( _( "Build BVH for holes and vias" ) );

    m_throughHoleIds.BuildBVH();
    m_throughHoleOds.BuildBVH();
    m_throughHoleAnnularRings.BuildBVH();

    if( !m_layerHoleMap.empty() )
    {
        for( auto& hole : m_layerHoleMap )
            hole.second->BuildBVH();
    }

    // We only need the Solder mask to initialize the BVH
    // because..?
    if( m_layerMap[B_Mask] )
        m_layerMap[B_Mask]->BuildBVH();

    if( m_layerMap[F_Mask] )
        m_layerMap[F_Mask]->BuildBVH();
}

References _, CONTAINER_2D_BASE::Add(), addFootprintShapesWithClearance(), addPadsWithClearance(), addShapeWithClearance(), addSolidAreasShapes(), LSET::AllCuMask(), LSET::AllNonCuMask(), arrayDim(), B_Adhes, B_Cu, B_Mask, B_Paste, B_SilkS, BiuTo3dUnits(), SHAPE_POLY_SET::BooleanSubtract(), BVH_CONTAINER_2D::BuildBVH(), buildPadOutlineAsPolygon(), buildPadOutlineAsSegments(), Cmts_User, createPadWithDrill(), createTrack(), destroyLayers(), BOARD::Drawings(), Dwgs_User, Eco1_User, Eco2_User, Edge_Cuts, ERROR_INSIDE, F_Adhes, F_Cu, F_Mask, F_Paste, F_SilkS, FL_CLIP_SILK_ON_VIA_ANNULUS, FL_RENDER_OPENGL_COPPER_THICKNESS, FL_RENDER_PLATED_PADS_AS_PLATED, FL_USE_REALISTIC_MODE, FL_ZONE, BOARD::Footprints(), Format(), BOARD::GetDesignSettings(), GetFlag(), GetHolePlatingThickness(), GetRunningMicroSecs(), Is3dLayerEnabled(), IsCopperLayer(), BOARD_ITEM::IsOnLayer(), LAYER_CLASS_SILK, m_averageHoleDiameter, m_averageTrackWidth, m_averageViaHoleDiameter, m_backPlatedPadPolys, m_biuTo3Dunits, m_board, m_copperLayersCount, m_frontPlatedPadPolys, m_holeCount, m_layerHoleIdPolys, m_layerHoleMap, m_layerHoleOdPolys, m_layerMap, m_layers_poly, BOARD_DESIGN_SETTINGS::m_LineThickness, m_logTrace, m_nonPlatedThroughHoleOdPolys, m_platedPadsBack, m_platedPadsFront, m_renderEngine, m_throughHoleAnnularRingPolys, m_throughHoleAnnularRings, m_throughHoleIds, m_throughHoleOdPolys, m_throughHoleOds, m_throughHoleViaOdPolys, m_throughHoleViaOds, m_trackCount, m_viaCount, Margin, MAX_CU_LAYERS, NPTH, OPENGL_LEGACY, pad, PCB_DIM_ALIGNED_T, PCB_DIM_CENTER_T, PCB_DIM_LEADER_T, PCB_DIM_ORTHOGONAL_T, PCB_SHAPE_T, PCB_TEXT_T, PCB_VIA_T, SHAPE_POLY_SET::PM_FAST, REPORTER::Report(), LSET::Seq(), SHAPE_POLY_SET::Simplify(), text, THROUGH, ToLAYER_ID(), BOARD::Tracks(), TransformCircleToPolygon(), transformFPShapesToPolygon(), PCB_TRACK::TransformShapeWithClearanceToPolygon(), ZONE::TransformSolidAreasShapesToPolygon(), EDA_ITEM::Type(), via, and BOARD::Zones().

Referenced by InitSettings().

createPadWithClearance()

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

private

Definition at line 308 of file create_3Dgraphic_brd_items.cpp.

{
    SHAPE_POLY_SET poly;
    wxSize clearance = aClearanceValue;

    // Our shape-based builder can't handle negative or differing x:y clearance values (the
    // former are common for solder paste while the later get generated when a relative paste
    // margin is used with an oblong pad).  So we apply this huge hack and fake a larger pad to
    // run the general-purpose polygon builder on.
    // Of course being a hack it falls down when dealing with custom shape pads (where the size
    // is only the size of the anchor), so for those we punt and just use aClearanceValue.x.

    if( ( clearance.x < 0 || clearance.x != clearance.y )
            && aPad->GetShape() != PAD_SHAPE::CUSTOM )
    {
        PAD dummy( *aPad );
        dummy.SetSize( aPad->GetSize() + clearance + clearance );
        dummy.TransformShapeWithClearanceToPolygon( poly, aLayer, 0, ARC_HIGH_DEF, ERROR_INSIDE );
        clearance = { 0, 0 };
    }
    else
    {
        auto padShapes = std::static_pointer_cast<SHAPE_COMPOUND>( aPad->GetEffectiveShape() );

        for( const SHAPE* shape : padShapes->Shapes() )
        {
            switch( shape->Type() )
            {
            case SH_SEGMENT:
            {
                const SHAPE_SEGMENT* seg = (SHAPE_SEGMENT*) shape;
                const SFVEC2F        start3DU(  seg->GetSeg().A.x * m_biuTo3Dunits,
                                               -seg->GetSeg().A.y * m_biuTo3Dunits );
                const SFVEC2F        end3DU  (  seg->GetSeg().B.x * m_biuTo3Dunits,
                                               -seg->GetSeg().B.y * m_biuTo3Dunits );
                const int            width = seg->GetWidth() + clearance.x * 2;

                 // Cannot add segments that have the same start and end point
                if( Is_segment_a_circle( start3DU, end3DU ) )
                {
                    aDstContainer->Add( new FILLED_CIRCLE_2D( start3DU,
                                                              ( width / 2 ) * m_biuTo3Dunits,
                                                              *aPad ) );
                }
                else
                {
                    aDstContainer->Add( new ROUND_SEGMENT_2D( start3DU, end3DU,
                                                              width * m_biuTo3Dunits,
                                                              *aPad ) );
                }
            }
                break;

            case SH_CIRCLE:
            {
                const SHAPE_CIRCLE* circle = (SHAPE_CIRCLE*) shape;
                const int           radius = circle->GetRadius() + clearance.x;
                const SFVEC2F       center(  circle->GetCenter().x * m_biuTo3Dunits,
                                             -circle->GetCenter().y * m_biuTo3Dunits );

                aDstContainer->Add( new FILLED_CIRCLE_2D( center, radius * m_biuTo3Dunits,
                                                          *aPad ) );
            }
                break;

            case SH_RECT:
            {
                SHAPE_RECT* rect = (SHAPE_RECT*) shape;

                poly.NewOutline();
                poly.Append( rect->GetPosition() );
                poly.Append( rect->GetPosition().x + rect->GetSize().x, rect->GetPosition().y );
                poly.Append( rect->GetPosition() + rect->GetSize() );
                poly.Append( rect->GetPosition().x, rect->GetPosition().y + rect->GetSize().y );
            }
                break;

            case SH_SIMPLE:
                poly.AddOutline( static_cast<const SHAPE_SIMPLE*>( shape )->Vertices() );
                break;

            case SH_POLY_SET:
                poly = *(SHAPE_POLY_SET*) shape;
                break;

            case SH_ARC:
            {
                SHAPE_ARC* arc = (SHAPE_ARC*) shape;
                SHAPE_LINE_CHAIN l = arc->ConvertToPolyline();

                for( int i = 0; i < l.SegmentCount(); i++ )
                {
                    SHAPE_SEGMENT seg( l.Segment( i ).A, l.Segment( i ).B, arc->GetWidth() );
                    const SFVEC2F start3DU(  seg.GetSeg().A.x * m_biuTo3Dunits,
                                             -seg.GetSeg().A.y * m_biuTo3Dunits );
                    const SFVEC2F end3DU( seg.GetSeg().B.x * m_biuTo3Dunits,
                                          -seg.GetSeg().B.y * m_biuTo3Dunits );
                    const int width = arc->GetWidth() + clearance.x * 2;

                     // Cannot add segments that have the same start and end point
                    if( Is_segment_a_circle( start3DU, end3DU ) )
                    {
                        aDstContainer->Add( new FILLED_CIRCLE_2D( start3DU,
                                                                  ( width / 2 ) * m_biuTo3Dunits,
                                                                  *aPad ) );
                    }
                    else
                    {
                        aDstContainer->Add( new ROUND_SEGMENT_2D( start3DU, end3DU,
                                                                  width * m_biuTo3Dunits,
                                                                  *aPad ) );
                    }
                }
            }
                break;

            default:
                wxFAIL_MSG( "BOARD_ADAPTER::createPadWithClearance no implementation for "
                            + SHAPE_TYPE_asString( shape->Type() ) );
                break;
            }
        }
    }

    if( !poly.IsEmpty() )
    {
        if( clearance.x )
            poly.Inflate( clearance.x, 32 );

        // Add the PAD polygon
        ConvertPolygonToTriangles( poly, *aDstContainer, m_biuTo3Dunits, *aPad );
    }
}

References SEG::A, CONTAINER_2D_BASE::Add(), SHAPE_POLY_SET::AddOutline(), SHAPE_POLY_SET::Append(), SEG::B, ConvertPolygonToTriangles(), SHAPE_ARC::ConvertToPolyline(), CUSTOM, dummy(), ERROR_INSIDE, SHAPE_CIRCLE::GetCenter(), PAD::GetEffectiveShape(), SHAPE_RECT::GetPosition(), SHAPE_CIRCLE::GetRadius(), SHAPE_SEGMENT::GetSeg(), PAD::GetShape(), SHAPE_RECT::GetSize(), PAD::GetSize(), SHAPE_SEGMENT::GetWidth(), SHAPE_ARC::GetWidth(), SHAPE_POLY_SET::Inflate(), Is_segment_a_circle(), SHAPE_POLY_SET::IsEmpty(), m_biuTo3Dunits, SHAPE_POLY_SET::NewOutline(), SHAPE_LINE_CHAIN::Segment(), SHAPE_LINE_CHAIN::SegmentCount(), SH_ARC, SH_CIRCLE, SH_POLY_SET, SH_RECT, SH_SEGMENT, SH_SIMPLE, SHAPE_TYPE_asString(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by addPadsWithClearance().

createPadWithDrill()

OBJECT_2D * BOARD_ADAPTER::createPadWithDrill ( const PAD *  aPad, int  aInflateValue  )

private

Definition at line 445 of file create_3Dgraphic_brd_items.cpp.

{
    wxSize drillSize = aPad->GetDrillSize();

    if( !drillSize.x || !drillSize.y )
    {
        wxLogTrace( m_logTrace, wxT( "BOARD_ADAPTER::createPadWithDrill - found an invalid pad" ) );
        return nullptr;
    }

    if( drillSize.x == drillSize.y )    // usual round hole
    {
        const int radius = ( drillSize.x / 2 ) + aInflateValue;

        const SFVEC2F center(  aPad->GetPosition().x * m_biuTo3Dunits,
                              -aPad->GetPosition().y * m_biuTo3Dunits );

        return new FILLED_CIRCLE_2D( center, radius * m_biuTo3Dunits, *aPad );

    }
    else                                // Oblong hole
    {
        const SHAPE_SEGMENT* seg = aPad->GetEffectiveHoleShape();
        float width = seg->GetWidth() + aInflateValue * 2;

        SFVEC2F start3DU(  seg->GetSeg().A.x * m_biuTo3Dunits,
                          -seg->GetSeg().A.y * m_biuTo3Dunits );

        SFVEC2F end3DU (  seg->GetSeg().B.x * m_biuTo3Dunits,
                         -seg->GetSeg().B.y * m_biuTo3Dunits );

        return new ROUND_SEGMENT_2D( start3DU, end3DU, width * m_biuTo3Dunits, *aPad );
    }

    return nullptr;
}

References SEG::A, SEG::B, PAD::GetDrillSize(), PAD::GetEffectiveHoleShape(), PAD::GetPosition(), SHAPE_SEGMENT::GetSeg(), SHAPE_SEGMENT::GetWidth(), m_biuTo3Dunits, m_logTrace, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by createLayers().

createTrack()

void BOARD_ADAPTER::createTrack ( const PCB_TRACK *  aTrack, CONTAINER_2D_BASE *  aDstContainer, int  aClearanceValue  )

private

Definition at line 229 of file create_3Dgraphic_brd_items.cpp.

{
    SFVEC2F start3DU( aTrack->GetStart().x * m_biuTo3Dunits,
                      -aTrack->GetStart().y * m_biuTo3Dunits ); // y coord is inverted

    switch( aTrack->Type() )
    {
    case PCB_VIA_T:
    {
        const float radius = ( ( aTrack->GetWidth() / 2 ) + aClearanceValue ) * m_biuTo3Dunits;
        aDstContainer->Add( new FILLED_CIRCLE_2D( start3DU, radius, *aTrack ) );
        break;
    }

    case PCB_ARC_T:
    {
        const PCB_ARC* arc = static_cast<const PCB_ARC*>( aTrack );
        VECTOR2D center( arc->GetCenter() );
        double arc_angle = arc->GetAngle();
        double radius = arc->GetRadius();
        int arcsegcount = GetArcToSegmentCount( radius, Millimeter2iu( 0.005), arc_angle/10 );
        int circlesegcount;

        // We need a circle to segment count. However, the arc angle can be small, and the
        // radius very big. so we calculate a reasonable value for circlesegcount.
        if( arcsegcount <= 1 )  // The arc will be approximated by a segment
            circlesegcount = 1;
        else
        {
            double cnt = arcsegcount * 3600/std::abs( arc_angle );

#define SEG_CNT_MAX 128
            if( cnt < SEG_CNT_MAX )
            {
                circlesegcount = (int)cnt;

                if( circlesegcount == 0 )
                    circlesegcount = 1;
            }
            else
            {
                circlesegcount = SEG_CNT_MAX;
            }
        }

        transformArcToSegments( wxPoint( center.x, center.y ), arc->GetStart(),
                                arc_angle, circlesegcount,
                                arc->GetWidth() + 2 * aClearanceValue, aDstContainer, *arc );
        break;
    }

    case PCB_TRACE_T:    // Track is a usual straight segment
    {
        SFVEC2F end3DU( aTrack->GetEnd().x * m_biuTo3Dunits, -aTrack->GetEnd().y * m_biuTo3Dunits );

        // Cannot add segments that have the same start and end point
        if( Is_segment_a_circle( start3DU, end3DU ) )
        {
            const float radius = ((aTrack->GetWidth() / 2) + aClearanceValue) * m_biuTo3Dunits;

            aDstContainer->Add( new FILLED_CIRCLE_2D( start3DU, radius, *aTrack ) );
        }
        else
        {
            const float width = (aTrack->GetWidth() + 2 * aClearanceValue ) * m_biuTo3Dunits;

            aDstContainer->Add( new ROUND_SEGMENT_2D( start3DU, end3DU, width, *aTrack ) );
        }

        break;
    }

    default:
        break;
    }
}

References CONTAINER_2D_BASE::Add(), PCB_ARC::GetAngle(), GetArcToSegmentCount(), PCB_ARC::GetCenter(), PCB_TRACK::GetEnd(), PCB_ARC::GetRadius(), PCB_TRACK::GetStart(), PCB_TRACK::GetWidth(), Is_segment_a_circle(), m_biuTo3Dunits, Millimeter2iu(), PCB_ARC_T, PCB_TRACE_T, PCB_VIA_T, SEG_CNT_MAX, transformArcToSegments(), and EDA_ITEM::Type().

Referenced by createLayers().

destroyLayers()

void BOARD_ADAPTER::destroyLayers ( )

private

Definition at line 60 of file create_layer_items.cpp.

{
    if( !m_layers_poly.empty() )
    {
        for( auto& poly : m_layers_poly )
            delete poly.second;

        m_layers_poly.clear();
    }

    delete m_frontPlatedPadPolys;
    m_frontPlatedPadPolys = nullptr;

    delete m_backPlatedPadPolys;
    m_backPlatedPadPolys = nullptr;

    if( !m_layerHoleIdPolys.empty() )
    {
        for( auto& poly : m_layerHoleIdPolys )
            delete poly.second;

        m_layerHoleIdPolys.clear();
    }

    if( !m_layerHoleOdPolys.empty() )
    {
        for( auto& poly : m_layerHoleOdPolys )
            delete poly.second;

        m_layerHoleOdPolys.clear();
    }

    if( !m_layerMap.empty() )
    {
        for( auto& poly : m_layerMap )
            delete poly.second;

        m_layerMap.clear();
    }

    delete m_platedPadsFront;
    m_platedPadsFront = nullptr;

    delete m_platedPadsBack;
    m_platedPadsBack = nullptr;

    if( !m_layerHoleMap.empty() )
    {
        for( auto& poly : m_layerHoleMap )
            delete poly.second;

        m_layerHoleMap.clear();
    }

    m_throughHoleIds.Clear();
    m_throughHoleOds.Clear();
    m_throughHoleAnnularRings.Clear();
    m_throughHoleViaOds.Clear();
    m_throughHoleViaIds.Clear();
    m_nonPlatedThroughHoleOdPolys.RemoveAllContours();
    m_throughHoleOdPolys.RemoveAllContours();

    m_throughHoleViaOdPolys.RemoveAllContours();
    m_throughHoleAnnularRingPolys.RemoveAllContours();
}

References BVH_CONTAINER_2D::Clear(), m_backPlatedPadPolys, m_frontPlatedPadPolys, m_layerHoleIdPolys, m_layerHoleMap, m_layerHoleOdPolys, m_layerMap, m_layers_poly, m_nonPlatedThroughHoleOdPolys, m_platedPadsBack, m_platedPadsFront, m_throughHoleAnnularRingPolys, m_throughHoleAnnularRings, m_throughHoleIds, m_throughHoleOdPolys, m_throughHoleOds, m_throughHoleViaIds, m_throughHoleViaOdPolys, m_throughHoleViaOds, and SHAPE_POLY_SET::RemoveAllContours().

Referenced by createLayers(), and ~BOARD_ADAPTER().

Get3dCacheManager()

S3D_CACHE* BOARD_ADAPTER::Get3dCacheManager ( ) const

inlinenoexcept

Return the 3D cache manager pointer.

Definition at line 88 of file board_adapter.h.

    {
        return m_3dModelManager;
    }

References m_3dModelManager.

Referenced by RENDER_3D_RAYTRACE::load3DModels(), and RENDER_3D_LEGACY::load3dModels().

GetAntiAliasingMode()

ANTIALIASING_MODE BOARD_ADAPTER::GetAntiAliasingMode ( ) const

inline

Get the current antialiasing mode value.

Returns

antialiasing mode value

Definition at line 275 of file board_adapter.h.

{ return m_antiAliasingMode; }

References m_antiAliasingMode.

Referenced by EDA_3D_VIEWER_FRAME::SaveSettings(), and PANEL_3D_OPENGL_OPTIONS::TransferDataToWindow().

GetAverageHoleDiameter()

float BOARD_ADAPTER::GetAverageHoleDiameter ( ) const

inlinenoexcept

Average diameter of through holes.

Returns

the average diameter of through holes in 3D units.

Definition at line 500 of file board_adapter.h.

    {
        return m_averageHoleDiameter;
    }

References m_averageHoleDiameter.

Referenced by RENDER_3D_RAYTRACE::Reload().

GetAverageTrackWidth()

float BOARD_ADAPTER::GetAverageTrackWidth ( ) const

inlinenoexcept

Average width of the tracks.

Returns

average track width in 3D units.

Definition at line 510 of file board_adapter.h.

    {
        return m_averageTrackWidth;
    }

References m_averageTrackWidth.

GetAverageViaHoleDiameter()

float BOARD_ADAPTER::GetAverageViaHoleDiameter ( ) const

inlinenoexcept

Thee average diameter of the via holes.

Returns

via hole average diameter dimension in 3D units.

Definition at line 490 of file board_adapter.h.

    {
        return m_averageViaHoleDiameter;
    }

References m_averageViaHoleDiameter.

Referenced by RENDER_3D_LEGACY::generateViasAndPads(), and RENDER_3D_RAYTRACE::Reload().

GetBackPlatedPadPolys()

const SHAPE_POLY_SET* BOARD_ADAPTER::GetBackPlatedPadPolys ( )

inline

Definition at line 542 of file board_adapter.h.

    {
        return m_backPlatedPadPolys;
    }

References m_backPlatedPadPolys.

Referenced by RENDER_3D_LEGACY::reload().

GetBBox()

const BBOX_3D& BOARD_ADAPTER::GetBBox ( ) const

inlinenoexcept

Get the board outling bounding box.

Returns

the board bounding box in 3D units.

Definition at line 169 of file board_adapter.h.

    {
        return m_boardBoundingBox;
    }

References m_boardBoundingBox.

Referenced by EDA_3D_CANVAS::move_pivot_based_on_cur_mouse_position(), and RENDER_3D_RAYTRACE::Reload().

GetBoard()

const BOARD* BOARD_ADAPTER::GetBoard ( ) const

inlinenoexcept

Get current board to be rendered.

Returns

BOARD pointer

Definition at line 136 of file board_adapter.h.

    {
        return m_board;
    }

References m_board.

Referenced by RENDER_3D_RAYTRACE::addPadsAndVias(), RENDER_3D_LEGACY::createBoard(), RENDER_3D_LEGACY::generateViasAndPads(), RENDER_3D_RAYTRACE::load3DModels(), RENDER_3D_LEGACY::load3dModels(), RENDER_3D_RAYTRACE::Reload(), and RENDER_3D_LEGACY::render3dModelsSelected().

GetBoardCenter()

const SFVEC3F& BOARD_ADAPTER::GetBoardCenter ( ) const

inlinenoexcept

The board center position in 3D units.

Returns

board center vector position in 3D units.

Definition at line 236 of file board_adapter.h.

    {
        return m_boardCenter;
    }

References m_boardCenter.

Referenced by RENDER_3D_RAYTRACE::Reload(), and RENDER_3D_LEGACY::reload().

GetBoardPoly()

const SHAPE_POLY_SET& BOARD_ADAPTER::GetBoardPoly ( ) const

inlinenoexcept

Get the current polygon of the epoxy board.

Returns

the shape polygon

Definition at line 321 of file board_adapter.h.

    {
        return m_board_poly;
    }

References m_board_poly.

Referenced by RENDER_3D_RAYTRACE::Reload(), and RENDER_3D_LEGACY::reload().

GetBoardPos()

wxPoint BOARD_ADAPTER::GetBoardPos ( ) const

inlinenoexcept

Get the board center.

Returns

position in BIU units.

Definition at line 226 of file board_adapter.h.

    {
        return m_boardPos;
    }

References m_boardPos.

Referenced by RENDER_3D_LEGACY::generate3dGrid().

GetBoardSize()

wxSize BOARD_ADAPTER::GetBoardSize ( ) const

inlinenoexcept

Get the board size.

Returns

size in BIU units.

Definition at line 216 of file board_adapter.h.

    {
        return m_boardSize;
    }

References m_boardSize.

Referenced by RENDER_3D_LEGACY::generate3dGrid().

GetCircleSegmentCount() [1/2]

unsigned int BOARD_ADAPTER::GetCircleSegmentCount

(

float

aDiameter3DU

)

const

Parameters

aDiameter3DU

diameter in 3DU.

Returns

number of sides that should be used in a circle with aDiameter3DU.

Definition at line 336 of file board_adapter.cpp.

{
    wxASSERT( aDiameter3DU > 0.0f );

    return GetCircleSegmentCount( (int)( aDiameter3DU / m_biuTo3Dunits ) );
}

References m_biuTo3Dunits.

Referenced by RENDER_3D_LEGACY::addObjectTriangles(), addShapeWithClearance(), and RENDER_3D_LEGACY::generateViasAndPads().

GetCircleSegmentCount() [2/2]

unsigned int BOARD_ADAPTER::GetCircleSegmentCount

(

int

aDiameterBIU

)

const

Parameters

aDiameterBIU

diameter in board internal units.

Returns

number of sides that should be used in circle with aDiameterBIU.

Definition at line 344 of file board_adapter.cpp.

{
    wxASSERT( aDiameterBIU > 0 );

    return GetArcToSegmentCount( aDiameterBIU / 2, ARC_HIGH_DEF, 360.0 );
}

References GetArcToSegmentCount().

GetColor()

SFVEC4F BOARD_ADAPTER::GetColor

(

const COLOR4D &

aColor

)

const

Parameters

[in]

aColor

is the color mapped.

Returns

the color in SFVEC3F format

Definition at line 776 of file board_adapter.cpp.

{
    return SFVEC4F( aColor.r, aColor.g, aColor.b, aColor.a );
}

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, KIGFX::COLOR4D::g, and KIGFX::COLOR4D::r.

Referenced by RENDER_3D_LEGACY::generate3dGrid(), GetItemColor(), and EDA_3D_VIEWER_FRAME::LoadSettings().

GetCopperThickness()

float BOARD_ADAPTER::GetCopperThickness ( ) const

inlinenoexcept

Get the current copper layer thickness.

Returns

thickness in 3D units of copper layers.

Definition at line 199 of file board_adapter.h.

    {
        return m_copperThickness3DU;
    }

References m_copperThickness3DU.

Referenced by RENDER_3D_RAYTRACE::insertHole(), and RENDER_3D_RAYTRACE::Reload().

GetEpoxyThickness()

float BOARD_ADAPTER::GetEpoxyThickness ( ) const

inlinenoexcept

Get the current epoxy thickness.

Returns

epoxy thickness in 3D units.

Definition at line 179 of file board_adapter.h.

    {
        return m_epoxyThickness3DU;
    }

References m_epoxyThickness3DU.

Referenced by RENDER_3D_LEGACY::renderBoardBody().

GetFlag()

bool BOARD_ADAPTER::GetFlag

(

DISPLAY3D_FLG

aFlag

)

const

Get a configuration status of a flag.

Parameters

aFlag

the flag to get the status.

Returns

true if flag is set, false if not.

Definition at line 294 of file board_adapter.cpp.

{
    wxASSERT( aFlag < FL_LAST );

    return m_drawFlags[aFlag];
}

References FL_LAST, and m_drawFlags.

Referenced by RENDER_3D_RAYTRACE::createItemsFromContainer(), createLayers(), EDA_3D_CONDITIONS::flagFunction(), RENDER_3D_LEGACY::generateViasAndPads(), GetFootprintZPos(), RENDER_3D_LEGACY::getLayerColor(), RENDER_3D_RAYTRACE::getModelMaterial(), InitSettings(), RENDER_3D_RAYTRACE::insertHole(), Is3dLayerEnabled(), IsFootprintShown(), RENDER_3D_RAYTRACE::load3DModels(), RENDER_3D_LEGACY::load3dModels(), EDA_3D_CANVAS::OnMouseWheel(), RENDER_3D_RAYTRACE::postProcessBlurFinish(), RENDER_3D_RAYTRACE::postProcessShading(), RENDER_3D_LEGACY::Redraw(), RENDER_3D_RAYTRACE::Reload(), RENDER_3D_LEGACY::reload(), RENDER_3D_LEGACY::render3dModels(), RENDER_3D_LEGACY::render3dModelsSelected(), RENDER_3D_RAYTRACE::renderAntiAliasPackets(), RENDER_3D_RAYTRACE::renderBlockTracing(), RENDER_3D_LEGACY::renderFootprint(), RENDER_3D_RAYTRACE::renderTracing(), RENDER_3D_LEGACY::setLayerMaterial(), RENDER_3D_RAYTRACE::setupMaterials(), RENDER_3D_LEGACY::setupMaterials(), RENDER_3D_RAYTRACE::shadeHit(), EDA_3D_CONTROLLER::ToggleVisibility(), PANEL_3D_OPENGL_OPTIONS::TransferDataToWindow(), PANEL_3D_RAYTRACING_OPTIONS::TransferDataToWindow(), and PANEL_3D_DISPLAY_OPTIONS::TransferDataToWindow().

GetFootprintZPos()

float BOARD_ADAPTER::GetFootprintZPos

(

bool

aIsFlipped

)

const

Get the position of the footprint in 3d integer units considering if it is flipped or not.

Parameters

aIsFlipped

true for use in footprints on Front (top) layer, false if footprint is on back (bottom) layer.

Returns

the Z position of 3D shapes, in 3D integer units.

Definition at line 741 of file board_adapter.cpp.

{
    if( aIsFlipped )
    {
        if( GetFlag( FL_SOLDERPASTE ) )
            return m_layerZcoordBottom[B_SilkS];
        else
            return m_layerZcoordBottom[B_Paste];
    }
    else
    {
        if( GetFlag( FL_SOLDERPASTE ) )
            return m_layerZcoordTop[F_SilkS];
        else
            return m_layerZcoordTop[F_Paste];
    }
}

References B_Paste, B_SilkS, F_Paste, F_SilkS, FL_SOLDERPASTE, GetFlag(), m_layerZcoordBottom, and m_layerZcoordTop.

Referenced by RENDER_3D_RAYTRACE::load3DModels(), and RENDER_3D_LEGACY::renderFootprint().

GetFrontPlatedPadPolys()

const SHAPE_POLY_SET* BOARD_ADAPTER::GetFrontPlatedPadPolys ( )

inline

Definition at line 537 of file board_adapter.h.

    {
        return m_frontPlatedPadPolys;
    }

References m_frontPlatedPadPolys.

Referenced by RENDER_3D_LEGACY::reload().

GetGridType()

GRID3D_TYPE BOARD_ADAPTER::GetGridType ( ) const

inlinenoexcept

Get the current grid.

Returns

space type of the grid.

Definition at line 255 of file board_adapter.h.

    {
        return m_gridType;
    }

References m_gridType.

Referenced by EDA_3D_CONDITIONS::gridSizeFunction(), RENDER_3D_LEGACY::Redraw(), and EDA_3D_VIEWER_FRAME::SaveSettings().

GetHoleCount()

unsigned int BOARD_ADAPTER::GetHoleCount ( ) const

inlinenoexcept

Get number of holes in this board.

Returns

number of holes.

Definition at line 480 of file board_adapter.h.

    {
        return m_holeCount;
    }

References m_holeCount.

Referenced by RENDER_3D_LEGACY::generateViasAndPads(), and RENDER_3D_RAYTRACE::Reload().

GetHoleIdPolysMap()

const MAP_POLY& BOARD_ADAPTER::GetHoleIdPolysMap ( ) const

inlinenoexcept

Definition at line 547 of file board_adapter.h.

    {
        return m_layerHoleIdPolys;
    }

References m_layerHoleIdPolys.

Referenced by RENDER_3D_LEGACY::reload().

GetHoleOdPolysMap()

const MAP_POLY& BOARD_ADAPTER::GetHoleOdPolysMap ( ) const

inlinenoexcept

Definition at line 552 of file board_adapter.h.

    {
        return m_layerHoleOdPolys;
    }

References m_layerHoleOdPolys.

Referenced by RENDER_3D_LEGACY::reload().

GetHolePlatingThickness()

int BOARD_ADAPTER::GetHolePlatingThickness ( ) const

noexcept

Get the current copper layer thickness.

Returns

thickness in board units.

Definition at line 329 of file board_adapter.cpp.

{
    return m_board ? m_board->GetDesignSettings().GetHolePlatingThickness()
                   : 0.035 * PCB_IU_PER_MM;
}

References BOARD::GetDesignSettings(), BOARD_DESIGN_SETTINGS::GetHolePlatingThickness(), m_board, and PCB_IU_PER_MM.

Referenced by createLayers(), RENDER_3D_LEGACY::generateViasAndPads(), and RENDER_3D_RAYTRACE::insertHole().

GetItemColor()

SFVEC4F BOARD_ADAPTER::GetItemColor

(

int

aItemId

)

const

Get the technical color of a layer.

Parameters

aItemId

the item id to get the color information.

Returns

the color in SFVEC3F format.

Definition at line 770 of file board_adapter.cpp.

{
    return GetColor( m_colors->GetColor( aItemId ) );
}

References COLOR_SETTINGS::GetColor(), GetColor(), and m_colors.

Referenced by RENDER_3D_RAYTRACE::insertHole().

GetLayerBottomZPos()

float BOARD_ADAPTER::GetLayerBottomZPos ( PCB_LAYER_ID  aLayerId ) const

inlinenoexcept

Get the bottom z position.

Parameters

aLayerId

layer id.

Returns

position in 3D units.

Definition at line 365 of file board_adapter.h.

    {
        return m_layerZcoordBottom[aLayerId];
    }

References m_layerZcoordBottom.

Referenced by RENDER_3D_RAYTRACE::createItemsFromContainer(), RENDER_3D_LEGACY::getLayerZPos(), RENDER_3D_RAYTRACE::insertHole(), RENDER_3D_LEGACY::Redraw(), and RENDER_3D_RAYTRACE::Reload().

GetLayerColor()

SFVEC4F BOARD_ADAPTER::GetLayerColor

(

PCB_LAYER_ID

aLayerId

)

const

Get the technical color of a layer.

Parameters

aLayerId

the layer to get the color information.

Returns

the color in SFVEC3F format.

Definition at line 760 of file board_adapter.cpp.

{
    wxASSERT( aLayerId < PCB_LAYER_ID_COUNT );

    const COLOR4D color = m_colors->GetColor( aLayerId );

    return SFVEC4F( color.r, color.g, color.b, color.a );
}

References color, COLOR_SETTINGS::GetColor(), m_colors, and PCB_LAYER_ID_COUNT.

Referenced by RENDER_3D_LEGACY::getLayerColor(), and RENDER_3D_RAYTRACE::Reload().

GetLayerHoleMap()

const MAP_CONTAINER_2D_BASE& BOARD_ADAPTER::GetLayerHoleMap ( ) const

inlinenoexcept

Get the map of container that have the holes per layer.

Returns

the map containers of holes from this board.

Definition at line 395 of file board_adapter.h.

    {
        return m_layerHoleMap;
    }

References m_layerHoleMap.

Referenced by RENDER_3D_RAYTRACE::createItemsFromContainer(), and RENDER_3D_LEGACY::reload().

GetLayerMap()

const MAP_CONTAINER_2D_BASE& BOARD_ADAPTER::GetLayerMap ( ) const

inlinenoexcept

Get the map of containers that have the objects per layer.

Returns

the map containers of this board.

Definition at line 375 of file board_adapter.h.

    {
        return m_layerMap;
    }

References m_layerMap.

Referenced by RENDER_3D_RAYTRACE::createItemsFromContainer(), RENDER_3D_RAYTRACE::Reload(), and RENDER_3D_LEGACY::reload().

GetLayerTopZPos()

float BOARD_ADAPTER::GetLayerTopZPos ( PCB_LAYER_ID  aLayerId ) const

inlinenoexcept

Get the top z position.

Parameters

aLayerId

layer id.

Returns

position in 3D units.

Definition at line 354 of file board_adapter.h.

    {
        return m_layerZcoordTop[aLayerId];
    }

References m_layerZcoordTop.

Referenced by RENDER_3D_RAYTRACE::createItemsFromContainer(), RENDER_3D_LEGACY::getLayerZPos(), RENDER_3D_LEGACY::Redraw(), and RENDER_3D_RAYTRACE::Reload().

GetMaterialMode()

MATERIAL_MODE BOARD_ADAPTER::GetMaterialMode ( ) const

inlinenoexcept

Returns

material rendering mode.

Definition at line 311 of file board_adapter.h.

    {
        return m_materialMode;
    }

References m_materialMode.

Referenced by RENDER_3D_RAYTRACE::addModels(), RENDER_3D_RAYTRACE::getModelMaterial(), RENDER_3D_LEGACY::load3dModels(), EDA_3D_CONDITIONS::materialModeFunction(), EDA_3D_VIEWER_FRAME::SaveSettings(), and PANEL_3D_DISPLAY_OPTIONS::TransferDataToWindow().

GetNonCopperLayerThickness()

float BOARD_ADAPTER::GetNonCopperLayerThickness ( ) const

inlinenoexcept

Get the current non copper layers thickness.

Returns

thickness in 3D units of non copper layers.

Definition at line 189 of file board_adapter.h.

    {
        return m_nonCopperLayerThickness3DU;
    }

References m_nonCopperLayerThickness3DU.

Referenced by RENDER_3D_LEGACY::renderSolderMaskLayer(), and RENDER_3D_RAYTRACE::shadeHit().

GetOuterNonPlatedThroughHolePoly()

const SHAPE_POLY_SET& BOARD_ADAPTER::GetOuterNonPlatedThroughHolePoly ( ) const

inlinenoexcept

Definition at line 437 of file board_adapter.h.

    {
        return m_nonPlatedThroughHoleOdPolys;
    }

References m_nonPlatedThroughHoleOdPolys.

Referenced by RENDER_3D_LEGACY::reload().

GetPlatedPadsBack()

const BVH_CONTAINER_2D* BOARD_ADAPTER::GetPlatedPadsBack ( ) const

inlinenoexcept

Definition at line 385 of file board_adapter.h.

    {
        return m_platedPadsBack;
    }

References m_platedPadsBack.

Referenced by RENDER_3D_RAYTRACE::Reload(), and RENDER_3D_LEGACY::reload().

GetPlatedPadsFront()

const BVH_CONTAINER_2D* BOARD_ADAPTER::GetPlatedPadsFront ( ) const

inlinenoexcept

Definition at line 380 of file board_adapter.h.

    {
        return m_platedPadsFront;
    }

References m_platedPadsFront.

Referenced by RENDER_3D_RAYTRACE::Reload(), and RENDER_3D_LEGACY::reload().

GetPolyMap()

const MAP_POLY& BOARD_ADAPTER::GetPolyMap ( ) const

inlinenoexcept

Get map of polygon's layers.

Returns

the map with polygon's layers.

Definition at line 532 of file board_adapter.h.

    {
        return m_layers_poly;
    }

References m_layers_poly.

Referenced by RENDER_3D_LEGACY::reload().

GetRenderEngine()

RENDER_ENGINE BOARD_ADAPTER::GetRenderEngine ( ) const

inlinenoexcept

Returns

render engine on use.

Definition at line 295 of file board_adapter.h.

    {
        return m_renderEngine;
    }

References m_renderEngine.

Referenced by EDA_3D_CANVAS::DoRePaint(), EDA_3D_CANVAS::OnMouseMove(), EDA_3D_VIEWER_FRAME::OnRenderEngineSelection(), EDA_3D_VIEWER_FRAME::Redraw(), EDA_3D_VIEWER_FRAME::refreshRender(), RENDER_3D_RAYTRACE::render(), EDA_3D_CANVAS::RenderEngineChanged(), EDA_3D_CONTROLLER::RotateView(), EDA_3D_VIEWER_FRAME::SaveSettings(), EDA_3D_VIEWER_FRAME::setupUIConditions(), EDA_3D_CONTROLLER::ToggleOrtho(), and EDA_3D_CONTROLLER::ToggleVisibility().

GetThroughHoleAnnularRingPolys()

const SHAPE_POLY_SET& BOARD_ADAPTER::GetThroughHoleAnnularRingPolys ( ) const

inlinenoexcept

Definition at line 432 of file board_adapter.h.

    {
        return m_throughHoleAnnularRingPolys;
    }

References m_throughHoleAnnularRingPolys.

Referenced by RENDER_3D_LEGACY::reload().

GetThroughHoleAnnularRings()

const BVH_CONTAINER_2D& BOARD_ADAPTER::GetThroughHoleAnnularRings ( ) const

inlinenoexcept

Get the through hole annular rings container.

Returns

a container with through hole annular rings.

Definition at line 415 of file board_adapter.h.

    {
        return m_throughHoleAnnularRings;
    }

References m_throughHoleAnnularRings.

Referenced by RENDER_3D_RAYTRACE::createItemsFromContainer(), and RENDER_3D_LEGACY::reload().

GetThroughHoleIds()

const BVH_CONTAINER_2D& BOARD_ADAPTER::GetThroughHoleIds ( ) const

inlinenoexcept

Get the through hole inner diameter container.

Returns

a container with holes inner diameters.

Definition at line 460 of file board_adapter.h.

    {
        return m_throughHoleIds;
    }

References m_throughHoleIds.

Referenced by RENDER_3D_RAYTRACE::insertHole(), and RENDER_3D_LEGACY::reload().

GetThroughHoleOdPolys()

const SHAPE_POLY_SET& BOARD_ADAPTER::GetThroughHoleOdPolys ( ) const

inlinenoexcept

Get through hole outside diameter 2D polygons.

The outside diameter 2D polygon is the hole diameter plus the plating thickness.

Returns

a container with through hold outside diameter 2D polygons.

Definition at line 427 of file board_adapter.h.

    {
        return m_throughHoleOdPolys;
    }

References m_throughHoleOdPolys.

Referenced by RENDER_3D_LEGACY::reload().

GetThroughHoleOds()

const BVH_CONTAINER_2D& BOARD_ADAPTER::GetThroughHoleOds ( ) const

inlinenoexcept

Get the inflated through hole outside diameters container.

Returns

a container with holes.

Definition at line 405 of file board_adapter.h.

    {
        return m_throughHoleOds;
    }

References m_throughHoleOds.

Referenced by RENDER_3D_RAYTRACE::createItemsFromContainer(), RENDER_3D_RAYTRACE::Reload(), and RENDER_3D_LEGACY::reload().

GetThroughHoleViaOdPolys()

const SHAPE_POLY_SET& BOARD_ADAPTER::GetThroughHoleViaOdPolys ( ) const

inlinenoexcept

Definition at line 450 of file board_adapter.h.

    {
        return m_throughHoleViaOdPolys;
    }

References m_throughHoleViaOdPolys.

Referenced by RENDER_3D_LEGACY::reload().

GetThroughHoleViaOds()

const BVH_CONTAINER_2D& BOARD_ADAPTER::GetThroughHoleViaOds ( ) const

inlinenoexcept

Returns

a container with through hole via hole outside diameters.

Definition at line 445 of file board_adapter.h.

    {
        return m_throughHoleViaOds;
    }

References m_throughHoleViaOds.

Referenced by RENDER_3D_LEGACY::reload().

GetViaCount()

unsigned int BOARD_ADAPTER::GetViaCount ( ) const

inlinenoexcept

Get number of vias in this board.

Returns

number of vias.

Definition at line 470 of file board_adapter.h.

    {
        return m_viaCount;
    }

References m_viaCount.

Referenced by RENDER_3D_LEGACY::generateViasAndPads(), and RENDER_3D_RAYTRACE::Reload().

InitSettings()

void BOARD_ADAPTER::InitSettings	(	REPORTER *	aStatusReporter,
		REPORTER *	aWarningReporter
	)

Function to be called by the render when it need to reload the settings for the board.

Parameters

aStatusReporter	the pointer for the status reporter.
aWarningReporter	pointer for the warning reporter.

Definition at line 352 of file board_adapter.cpp.

{
    wxLogTrace( m_logTrace, wxT( "BOARD_ADAPTER::InitSettings" ) );

    if( aStatusReporter )
        aStatusReporter->Report( _( "Build board outline" ) );

    wxString msg;

    const bool succeedToGetBoardPolygon = createBoardPolygon( &msg );

    if( aWarningReporter )
    {
        if( !succeedToGetBoardPolygon )
            aWarningReporter->Report( msg, RPT_SEVERITY_WARNING );
        else
            aWarningReporter->Report( wxEmptyString );
    }

    // Calculates the board bounding box (board outlines + items)
    // to ensure any item, even outside the board outlines can be seen
    bool boardEdgesOnly = true;

    if( ( m_board && m_board->IsFootprintHolder() ) || !GetFlag( FL_USE_REALISTIC_MODE )
            || !succeedToGetBoardPolygon )
    {
        boardEdgesOnly = false;
    }

    EDA_RECT bbbox;

    if( m_board )
        bbbox = m_board->ComputeBoundingBox( boardEdgesOnly );

    // Gives a non null size to avoid issues in zoom / scale calculations
    if( ( bbbox.GetWidth() == 0 ) && ( bbbox.GetHeight() == 0 ) )
        bbbox.Inflate( Millimeter2iu( 10 ) );

    m_boardSize = bbbox.GetSize();
    m_boardPos  = bbbox.Centre();

    wxASSERT( (m_boardSize.x > 0) && (m_boardSize.y > 0) );

    m_boardPos.y = -m_boardPos.y; // The y coord is inverted in 3D viewer

    m_copperLayersCount = m_board ? m_board->GetCopperLayerCount() : 2;

    // Ensure the board has 2 sides for 3D views, because it is hard to find
    // a *really* single side board in the true life...
    if( m_copperLayersCount < 2 )
        m_copperLayersCount = 2;

    // Calculate the conversion to apply to all positions.
    m_biuTo3Dunits = RANGE_SCALE_3D / std::max( m_boardSize.x, m_boardSize.y );

    m_epoxyThickness3DU = m_board
                            ? m_board->GetDesignSettings().GetBoardThickness() * m_biuTo3Dunits
                            : 1.6 * PCB_IU_PER_MM * m_biuTo3Dunits;

    // !TODO: use value defined by user (currently use default values by ctor
    m_copperThickness3DU         = COPPER_THICKNESS     * m_biuTo3Dunits;
    m_nonCopperLayerThickness3DU = TECH_LAYER_THICKNESS * m_biuTo3Dunits;
    m_solderPasteLayerThickness3DU = SOLDERPASTE_LAYER_THICKNESS * m_biuTo3Dunits;

    // Init  Z position of each layer
    // calculate z position for each copper layer
    // Zstart = -m_epoxyThickness / 2.0 is the z position of the back (bottom layer) (layer id = 31)
    // Zstart = +m_epoxyThickness / 2.0 is the z position of the front (top layer) (layer id = 0)
    // all unused copper layer z position are set to 0

    //  ____==__________==________==______ <- Bottom = +m_epoxyThickness / 2.0,
    // |                                  |   Top = Bottom + m_copperThickness
    // |__________________________________|
    //   ==         ==         ==     ==   <- Bottom = -m_epoxyThickness / 2.0,
    //                                        Top = Bottom - m_copperThickness

    unsigned int layer;

    for( layer = 0; layer < m_copperLayersCount; ++layer )
    {
        m_layerZcoordBottom[layer] = m_epoxyThickness3DU / 2.0f -
                                     (m_epoxyThickness3DU * layer / (m_copperLayersCount - 1) );

        if( layer < (m_copperLayersCount / 2) )
            m_layerZcoordTop[layer] = m_layerZcoordBottom[layer] + m_copperThickness3DU;
        else
            m_layerZcoordTop[layer] = m_layerZcoordBottom[layer] - m_copperThickness3DU;
    }

    #define layerThicknessMargin 1.1
    const float zpos_offset = m_nonCopperLayerThickness3DU * layerThicknessMargin;

    // Fill remaining unused copper layers and back layer zpos
    // with -m_epoxyThickness / 2.0
    for( ; layer < MAX_CU_LAYERS; layer++ )
    {
        m_layerZcoordBottom[layer] = -(m_epoxyThickness3DU / 2.0f);
        m_layerZcoordTop[layer]    = -(m_epoxyThickness3DU / 2.0f) - m_copperThickness3DU;
    }

    // This is the top of the copper layer thickness.
    const float zpos_copperTop_back  = m_layerZcoordTop[B_Cu];
    const float zpos_copperTop_front = m_layerZcoordTop[F_Cu];

    // calculate z position for each non copper layer
    // Solder mask and Solder paste have the same Z position
    for( int layer_id = MAX_CU_LAYERS; layer_id < PCB_LAYER_ID_COUNT; ++layer_id )
    {
        float zposTop;
        float zposBottom;

        switch( layer_id )
        {
        case B_Adhes:
            zposBottom = zpos_copperTop_back - 2.0f * zpos_offset;
            zposTop    = zposBottom - m_nonCopperLayerThickness3DU;
            break;

        case F_Adhes:
            zposBottom = zpos_copperTop_front + 2.0f * zpos_offset;
            zposTop    = zposBottom + m_nonCopperLayerThickness3DU;
            break;

        case B_Mask:
            zposBottom = zpos_copperTop_back;
            zposTop    = zpos_copperTop_back - m_nonCopperLayerThickness3DU;
            break;

        case B_Paste:
            zposBottom = zpos_copperTop_back;
            zposTop    = zpos_copperTop_back - m_solderPasteLayerThickness3DU;
            break;

        case F_Mask:
            zposBottom = zpos_copperTop_front;
            zposTop    = zpos_copperTop_front + m_nonCopperLayerThickness3DU;
            break;

        case F_Paste:
            zposBottom = zpos_copperTop_front;
            zposTop    = zpos_copperTop_front + m_solderPasteLayerThickness3DU;
            break;

        case B_SilkS:
            zposBottom = zpos_copperTop_back - 1.0f * zpos_offset;
            zposTop    = zposBottom - m_nonCopperLayerThickness3DU;
            break;

        case F_SilkS:
            zposBottom = zpos_copperTop_front + 1.0f * zpos_offset;
            zposTop    = zposBottom + m_nonCopperLayerThickness3DU;
            break;

        // !TODO: review
        default:
            zposTop = zpos_copperTop_front + (layer_id - MAX_CU_LAYERS + 3.0f) * zpos_offset;
            zposBottom = zposTop - m_nonCopperLayerThickness3DU;
            break;
        }

        m_layerZcoordTop[layer_id]    = zposTop;
        m_layerZcoordBottom[layer_id] = zposBottom;
    }

    m_boardCenter = SFVEC3F( m_boardPos.x * m_biuTo3Dunits, m_boardPos.y * m_biuTo3Dunits, 0.0f );

    SFVEC3F boardSize = SFVEC3F( m_boardSize.x * m_biuTo3Dunits, m_boardSize.y * m_biuTo3Dunits,
                                 0.0f );
    boardSize /= 2.0f;

    SFVEC3F boardMin = ( m_boardCenter - boardSize );
    SFVEC3F boardMax = ( m_boardCenter + boardSize );

    boardMin.z = m_layerZcoordTop[B_Adhes];
    boardMax.z = m_layerZcoordTop[F_Adhes];

    m_boardBoundingBox = BBOX_3D( boardMin, boardMax );

#ifdef PRINT_STATISTICS_3D_VIEWER
    unsigned stats_startCreateBoardPolyTime = GetRunningMicroSecs();
#endif

    if( aStatusReporter )
        aStatusReporter->Report( _( "Create layers" ) );

    createLayers( aStatusReporter );

    COLOR_SETTINGS* colors = Pgm().GetSettingsManager().GetColorSettings();

    auto to_SFVEC4F =
            []( const COLOR4D& src )
            {
                return SFVEC4F( src.r, src.g, src.b, src.a );
            };

    m_BgColorTop = to_SFVEC4F( colors->GetColor( LAYER_3D_BACKGROUND_TOP ) );
    m_BgColorBot = to_SFVEC4F( colors->GetColor( LAYER_3D_BACKGROUND_BOTTOM ) );

    m_SolderPasteColor = to_SFVEC4F( colors->GetColor( LAYER_3D_SOLDERPASTE ) );

    if( m_board && colors->GetUseBoardStackupColors() )
    {
        const BOARD_STACKUP& stackup = m_board->GetDesignSettings().GetStackupDescriptor();

        auto findColor =
                []( const wxString& aColorName, const CUSTOM_COLORS_LIST& aColorSet )
                {
                    if( aColorName.StartsWith( "#" ) )
                    {
                        return KIGFX::COLOR4D( wxColour( aColorName ) );
                    }
                    else
                    {
                        for( const CUSTOM_COLOR_ITEM& color : aColorSet )
                        {
                            if( color.m_ColorName == aColorName )
                                return color.m_Color;
                        }
                    }

                    return KIGFX::COLOR4D();
                };

        m_SilkScreenColorTop = to_SFVEC4F( g_DefaultSilkscreen );
        m_SilkScreenColorBot = to_SFVEC4F( g_DefaultSilkscreen );
        m_SolderMaskColorTop = to_SFVEC4F( g_DefaultSolderMask );
        m_SolderMaskColorBot = to_SFVEC4F( g_DefaultSolderMask );

        KIGFX::COLOR4D bodyColor( 0, 0, 0, 0 );

        for( const BOARD_STACKUP_ITEM* stackupItem : stackup.GetList() )
        {
            wxString colorName = stackupItem->GetColor();

            switch( stackupItem->GetType() )
            {
            case BS_ITEM_TYPE_SILKSCREEN:
                if( stackupItem->GetBrdLayerId() == F_SilkS )
                    m_SilkScreenColorTop = to_SFVEC4F( findColor( colorName, g_SilkscreenColors ) );
                else
                    m_SilkScreenColorBot = to_SFVEC4F( findColor( colorName, g_SilkscreenColors ) );
                break;

            case BS_ITEM_TYPE_SOLDERMASK:
                if( stackupItem->GetBrdLayerId() == F_Mask )
                    m_SolderMaskColorTop = to_SFVEC4F( findColor( colorName, g_MaskColors ) );
                else
                    m_SolderMaskColorBot = to_SFVEC4F( findColor( colorName, g_MaskColors ) );

                break;

            case BS_ITEM_TYPE_DIELECTRIC:
            {
                KIGFX::COLOR4D  layerColor = COLOR4D::UNSPECIFIED;
                const wxString& materialName = stackupItem->GetMaterial();

                if( materialName.StartsWith( "FR4" ) )
                {
                    layerColor = findColor( "FR4 natural", g_BoardColors );
                }
                else if( materialName.IsSameAs( "PTFE" )
                      || materialName.IsSameAs( "Teflon" ) )
                {
                    layerColor = findColor( "PTFE natural", g_BoardColors );
                }
                else if( materialName.IsSameAs( "Polyimide" )
                      || materialName.IsSameAs( "Kapton" ) )
                {
                    layerColor = findColor( "Polyimide", g_BoardColors );
                }
                else if( materialName.IsSameAs( "Al" ) )
                {
                    layerColor = findColor( "Aluminum", g_BoardColors );
                }
                else    // A default color value for unknown dielectric material
                        // (i.e. an exotic name entered by hand)
                {
                    layerColor = findColor( "FR4 natural", g_BoardColors );
                }

                if( bodyColor == COLOR4D( 0, 0, 0, 0 ) )
                    bodyColor = layerColor;
                else
                    bodyColor = bodyColor.Mix( layerColor, 1.0 - layerColor.a );

                bodyColor.a += ( 1.0 - bodyColor.a ) * layerColor.a / 2;
                break;
            }

            default:
                break;
            }
        }

        if( bodyColor != COLOR4D( 0, 0, 0, 0 ) )
            m_BoardBodyColor = to_SFVEC4F( bodyColor );
        else
            m_BoardBodyColor = to_SFVEC4F( g_DefaultBoardBody );

        const wxString& finishName = stackup.m_FinishType;

        if( finishName.EndsWith( "OSP" ) )
        {
            m_CopperColor = to_SFVEC4F( findColor( "Copper", g_FinishColors ) );
        }
        else if( finishName.EndsWith( "IG" )
              || finishName.EndsWith( "gold" ) )
        {
            m_CopperColor = to_SFVEC4F( findColor( "Gold", g_FinishColors ) );
        }
        else if( finishName.StartsWith( "HAL" )
              || finishName.StartsWith( "HASL" )
              || finishName.EndsWith( "tin" )
              || finishName.EndsWith( "nickel" ) )
        {
            m_CopperColor = to_SFVEC4F( findColor( "Tin", g_FinishColors ) );
        }
        else if( finishName.EndsWith( "silver" ) )
        {
            m_CopperColor = to_SFVEC4F( findColor( "Silver", g_FinishColors ) );
        }
        else
        {
            m_CopperColor = to_SFVEC4F( g_DefaultSurfaceFinish );
        }
    }
    else
    {
        m_SilkScreenColorBot = to_SFVEC4F( colors->GetColor( LAYER_3D_SILKSCREEN_BOTTOM ) );
        m_SilkScreenColorTop = to_SFVEC4F( colors->GetColor( LAYER_3D_SILKSCREEN_TOP ) );
        m_SolderMaskColorBot = to_SFVEC4F( colors->GetColor( LAYER_3D_SOLDERMASK_BOTTOM ) );
        m_SolderMaskColorTop = to_SFVEC4F( colors->GetColor( LAYER_3D_SOLDERMASK_TOP ) );
        m_CopperColor        = to_SFVEC4F( colors->GetColor( LAYER_3D_COPPER ) );
        m_BoardBodyColor     = to_SFVEC4F( colors->GetColor( LAYER_3D_BOARD ) );
    }
}

References _, KIGFX::COLOR4D::a, B_Adhes, B_Cu, B_Mask, B_Paste, B_SilkS, BS_ITEM_TYPE_DIELECTRIC, BS_ITEM_TYPE_SILKSCREEN, BS_ITEM_TYPE_SOLDERMASK, EDA_RECT::Centre(), color, BOARD::ComputeBoundingBox(), COPPER_THICKNESS, createBoardPolygon(), createLayers(), F_Adhes, F_Cu, F_Mask, F_Paste, F_SilkS, FL_USE_REALISTIC_MODE, g_BoardColors, g_DefaultBoardBody, g_DefaultSilkscreen, g_DefaultSolderMask, g_DefaultSurfaceFinish, g_FinishColors, g_MaskColors, g_SilkscreenColors, BOARD_DESIGN_SETTINGS::GetBoardThickness(), COLOR_SETTINGS::GetColor(), BOARD::GetCopperLayerCount(), BOARD::GetDesignSettings(), GetFlag(), EDA_RECT::GetHeight(), BOARD_STACKUP::GetList(), GetRunningMicroSecs(), EDA_RECT::GetSize(), BOARD_DESIGN_SETTINGS::GetStackupDescriptor(), COLOR_SETTINGS::GetUseBoardStackupColors(), EDA_RECT::GetWidth(), EDA_RECT::Inflate(), BOARD::IsFootprintHolder(), LAYER_3D_BACKGROUND_BOTTOM, LAYER_3D_BACKGROUND_TOP, LAYER_3D_BOARD, LAYER_3D_COPPER, LAYER_3D_SILKSCREEN_BOTTOM, LAYER_3D_SILKSCREEN_TOP, LAYER_3D_SOLDERMASK_BOTTOM, LAYER_3D_SOLDERMASK_TOP, LAYER_3D_SOLDERPASTE, layerThicknessMargin, m_BgColorBot, m_BgColorTop, m_biuTo3Dunits, m_board, m_BoardBodyColor, m_boardBoundingBox, m_boardCenter, m_boardPos, m_boardSize, m_CopperColor, m_copperLayersCount, m_copperThickness3DU, m_epoxyThickness3DU, BOARD_STACKUP::m_FinishType, m_layerZcoordBottom, m_layerZcoordTop, m_logTrace, m_nonCopperLayerThickness3DU, m_SilkScreenColorBot, m_SilkScreenColorTop, m_SolderMaskColorBot, m_SolderMaskColorTop, m_SolderPasteColor, m_solderPasteLayerThickness3DU, MAX_CU_LAYERS, Millimeter2iu(), KIGFX::COLOR4D::Mix(), PCB_IU_PER_MM, PCB_LAYER_ID_COUNT, Pgm(), RANGE_SCALE_3D, REPORTER::Report(), RPT_SEVERITY_WARNING, SOLDERPASTE_LAYER_THICKNESS, and TECH_LAYER_THICKNESS.

Referenced by RENDER_3D_RAYTRACE::Reload(), and RENDER_3D_LEGACY::reload().

Is3dLayerEnabled()

bool BOARD_ADAPTER::Is3dLayerEnabled

(

PCB_LAYER_ID

aLayer

)

const

Check if a layer is enabled.

Parameters

aLayer

layer ID to get status.

Definition at line 229 of file board_adapter.cpp.

{
    wxASSERT( aLayer < PCB_LAYER_ID_COUNT );

    if( m_board && !m_board->IsLayerEnabled( aLayer ) )
        return false;

    // see if layer needs to be shown
    // check the flags
    switch( aLayer )
    {
    case B_Adhes:
    case F_Adhes:
        return GetFlag( FL_ADHESIVE );

    case B_Paste:
    case F_Paste:
        return GetFlag( FL_SOLDERPASTE );

    case B_SilkS:
    case F_SilkS:
        return GetFlag( FL_SILKSCREEN );

    case B_Mask:
    case F_Mask:
        return GetFlag( FL_SOLDERMASK );

    case Dwgs_User:
    case Cmts_User:
        if( GetFlag( FL_USE_REALISTIC_MODE ) )
            return false;

        return GetFlag( FL_COMMENTS );

    case Eco1_User:
    case Eco2_User:
        if( GetFlag( FL_USE_REALISTIC_MODE ) )
            return false;

        return GetFlag( FL_ECO );

    case Edge_Cuts:
        if( GetFlag( FL_SHOW_BOARD_BODY ) || GetFlag( FL_USE_REALISTIC_MODE ) )
            return false;

        return true;

    case Margin:
        if( GetFlag( FL_USE_REALISTIC_MODE ) )
            return false;

        return true;

    case B_Cu:
    case F_Cu:
        return m_board ? m_board->IsLayerVisible( aLayer ) || GetFlag( FL_USE_REALISTIC_MODE )
                       : true;

    default:
        // the layer is an internal copper layer, used the visibility
        return m_board && m_board->IsLayerVisible( aLayer );
    }
}

References B_Adhes, B_Cu, B_Mask, B_Paste, B_SilkS, Cmts_User, Dwgs_User, Eco1_User, Eco2_User, Edge_Cuts, F_Adhes, F_Cu, F_Mask, F_Paste, F_SilkS, FL_ADHESIVE, FL_COMMENTS, FL_ECO, FL_SHOW_BOARD_BODY, FL_SILKSCREEN, FL_SOLDERMASK, FL_SOLDERPASTE, FL_USE_REALISTIC_MODE, GetFlag(), BOARD::IsLayerEnabled(), BOARD::IsLayerVisible(), m_board, Margin, and PCB_LAYER_ID_COUNT.

Referenced by createLayers(), and RENDER_3D_LEGACY::reload().

IsFootprintShown()

bool BOARD_ADAPTER::IsFootprintShown

(

FOOTPRINT_ATTR_T

aFPAttributes

)

const

Test if footprint should be displayed in relation to attributes and the flags.

Definition at line 310 of file board_adapter.cpp.

{
    if( aFPAttributes & FP_SMD )
        return GetFlag( FL_FP_ATTRIBUTES_NORMAL_INSERT );
    else if( aFPAttributes & FP_THROUGH_HOLE )
        return GetFlag( FL_FP_ATTRIBUTES_NORMAL );
    else
        return GetFlag( FL_FP_ATTRIBUTES_VIRTUAL );
}

References FL_FP_ATTRIBUTES_NORMAL, FL_FP_ATTRIBUTES_NORMAL_INSERT, FL_FP_ATTRIBUTES_VIRTUAL, FP_SMD, FP_THROUGH_HOLE, and GetFlag().

Referenced by RENDER_3D_RAYTRACE::load3DModels(), and RENDER_3D_LEGACY::render3dModelsSelected().

Set3dCacheManager()

void BOARD_ADAPTER::Set3dCacheManager ( S3D_CACHE *  aCachePointer )

inlinenoexcept

Update the cache manager pointer.

Parameters

aCachePointer

the pointer to the 3D cache manager.

Definition at line 80 of file board_adapter.h.

    {
        m_3dModelManager = aCachePointer;
    }

References m_3dModelManager.

Referenced by EDA_3D_CANVAS::ReloadRequest().

SetAntiAliasingMode()

void BOARD_ADAPTER::SetAntiAliasingMode ( ANTIALIASING_MODE  aAAmode )

inline

Set the current antialiasing mode value.

Parameters

aAAmode

antialiasing mode value.

Definition at line 282 of file board_adapter.h.

{ m_antiAliasingMode = aAAmode; }

References m_antiAliasingMode.

Referenced by EDA_3D_VIEWER_FRAME::LoadSettings(), and PANEL_3D_OPENGL_OPTIONS::TransferDataFromWindow().

SetBoard()

void BOARD_ADAPTER::SetBoard ( BOARD *  aBoard )

inlinenoexcept

Set current board to be rendered.

Parameters

aBoard

board to process.

Definition at line 126 of file board_adapter.h.

    {
        m_board = aBoard;
    }

References m_board.

Referenced by PANEL_PREVIEW_3D_MODEL::PANEL_PREVIEW_3D_MODEL(), and EDA_3D_CANVAS::ReloadRequest().

SetColorSettings()

void BOARD_ADAPTER::SetColorSettings ( COLOR_SETTINGS *  aSettings )

inlinenoexcept

Definition at line 141 of file board_adapter.h.

    {
        m_colors = aSettings;
    }

References m_colors.

Referenced by EDA_3D_CANVAS::ReloadRequest().

SetFlag()

void BOARD_ADAPTER::SetFlag	(	DISPLAY3D_FLG	aFlag,
		bool	aState
	)

Set the status of a flag.

Parameters

aFlag	the flag to set the status
aState	status to set.

Definition at line 302 of file board_adapter.cpp.

{
    wxASSERT( aFlag < FL_LAST );

    m_drawFlags[aFlag] = aState;
}

References FL_LAST, and m_drawFlags.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER_FRAME::loadCommonSettings(), PANEL_PREVIEW_3D_MODEL::loadSettings(), PANEL_PREVIEW_3D_MODEL::PANEL_PREVIEW_3D_MODEL(), EDA_3D_CONTROLLER::ToggleVisibility(), PANEL_3D_OPENGL_OPTIONS::TransferDataFromWindow(), PANEL_3D_RAYTRACING_OPTIONS::TransferDataFromWindow(), and PANEL_3D_DISPLAY_OPTIONS::TransferDataFromWindow().

SetGridType()

void BOARD_ADAPTER::SetGridType ( GRID3D_TYPE  aGridType )

inlinenoexcept

Set the current grid.

Parameters

aGridType

the type space of the grid.

Definition at line 265 of file board_adapter.h.

    {
        m_gridType = aGridType;
    }

References m_gridType.

Referenced by EDA_3D_VIEWER_FRAME::LoadSettings(), and EDA_3D_CONTROLLER::On3DGridSelection().

SetMaterialMode()

void BOARD_ADAPTER::SetMaterialMode ( MATERIAL_MODE  aMaterialMode )

inlinenoexcept

Parameters

aMaterialMode

the render material mode.

Definition at line 303 of file board_adapter.h.

    {
        m_materialMode = aMaterialMode;
    }

References m_materialMode.

Referenced by PANEL_PREVIEW_3D_MODEL::loadSettings(), EDA_3D_VIEWER_FRAME::LoadSettings(), EDA_3D_CONTROLLER::SetMaterial(), and PANEL_3D_DISPLAY_OPTIONS::TransferDataFromWindow().

SetRenderEngine()

void BOARD_ADAPTER::SetRenderEngine ( RENDER_ENGINE  aRenderEngine )

inlinenoexcept

Parameters

aRenderEngine

the render engine mode selected.

Definition at line 287 of file board_adapter.h.

    {
        m_renderEngine = aRenderEngine;
    }

References m_renderEngine.

Referenced by EDA_3D_CANVAS::DoRePaint(), PANEL_PREVIEW_3D_MODEL::loadSettings(), EDA_3D_VIEWER_FRAME::LoadSettings(), EDA_3D_VIEWER_FRAME::OnDisableRayTracing(), and EDA_3D_VIEWER_FRAME::OnRenderEngineSelection().

transformArcToSegments()

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

private

Definition at line 559 of file create_3Dgraphic_brd_items.cpp.

{
    wxPoint arc_start, arc_end;
    int     delta = 3600 / aCircleToSegmentsCount;   // rotate angle in 0.1 degree

    arc_end = arc_start = aStart;

    if( aArcAngle != 3600 )
    {
        RotatePoint( &arc_end, aCentre, -aArcAngle );
    }

    if( aArcAngle < 0 )
    {
        std::swap( arc_start, arc_end );
        aArcAngle = -aArcAngle;
    }

    // Compute the ends of segments and creates poly
    wxPoint curr_end    = arc_start;
    wxPoint curr_start  = arc_start;

    for( int ii = delta; ii < aArcAngle; ii += delta )
    {
        curr_end = arc_start;
        RotatePoint( &curr_end, aCentre, -ii );

        const SFVEC2F start3DU( curr_start.x * m_biuTo3Dunits, -curr_start.y * m_biuTo3Dunits );
        const SFVEC2F end3DU  ( curr_end.x   * m_biuTo3Dunits, -curr_end.y   * m_biuTo3Dunits );

        if( Is_segment_a_circle( start3DU, end3DU ) )
        {
            aDstContainer->Add( new FILLED_CIRCLE_2D( start3DU, ( aWidth / 2 ) * m_biuTo3Dunits,
                                                      aBoardItem ) );
        }
        else
        {
            aDstContainer->Add( new ROUND_SEGMENT_2D( start3DU, end3DU, aWidth * m_biuTo3Dunits,
                                                      aBoardItem ) );
        }

        curr_start = curr_end;
    }

    if( curr_end != arc_end )
    {
        const SFVEC2F start3DU( curr_end.x * m_biuTo3Dunits, -curr_end.y * m_biuTo3Dunits );
        const SFVEC2F end3DU  ( arc_end.x  * m_biuTo3Dunits, -arc_end.y  * m_biuTo3Dunits );

        if( Is_segment_a_circle( start3DU, end3DU ) )
        {
            aDstContainer->Add( new FILLED_CIRCLE_2D( start3DU, ( aWidth / 2 ) * m_biuTo3Dunits,
                                                      aBoardItem ) );
        }
        else
        {
            aDstContainer->Add( new ROUND_SEGMENT_2D( start3DU, end3DU, aWidth * m_biuTo3Dunits,
                                                      aBoardItem ) );
        }
    }
}

References CONTAINER_2D_BASE::Add(), delta, Is_segment_a_circle(), m_biuTo3Dunits, and RotatePoint().

Referenced by addShapeWithClearance(), and createTrack().

transformFPShapesToPolygon()

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

private

Definition at line 62 of file create_layer_poly.cpp.

{
    for( BOARD_ITEM* item : aFootprint->GraphicalItems() )
    {
        if( item->Type() == PCB_FP_SHAPE_T )
        {
            FP_SHAPE* outline = (FP_SHAPE*) item;

            if( outline->GetLayer() == aLayer )
            {
                outline->TransformShapeWithClearanceToPolygon( aCornerBuffer, aLayer, 0,
                                                               ARC_HIGH_DEF, ERROR_INSIDE );
            }
        }
    }
}