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 (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

Private Member Functions
bool	createBoardPolygon (wxString *aErrorMsg)
	Create the board outline polygon. More...
void	createLayers (REPORTER *aStatusReporter)
void	destroyLayers ()
void	createTrack (const TRACK *aTrack, CONTAINER_2D_BASE *aDstContainer, int aClearanceValue)
void	createPadWithClearance (const PAD *aPad, CONTAINER_2D_BASE *aDstContainer, PCB_LAYER_ID aLayer, 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 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 67 of file board_adapter.h.

Constructor & Destructor Documentation

BOARD_ADAPTER()

BOARD_ADAPTER::BOARD_ADAPTER

(

)

Definition at line 52 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 );

    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;
}

References AA_8X, BVH_CONTAINER_2D::Clear(), FL_CLIP_SILK_ON_VIA_ANNULUS, FL_FP_ATTRIBUTES_NORMAL, FL_FP_ATTRIBUTES_NORMAL_INSERT, FL_FP_ATTRIBUTES_VIRTUAL, 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, 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 145 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 180 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   forceBold = true;
        int    penWidth = 0;        // force max width for bold

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

        GRText( nullptr, text->GetTextPos(), BLACK, text->GetShownText(), text->GetDrawRotation(),
                size, text->GetHorizJustify(), text->GetVertJustify(), penWidth, text->IsItalic(),
                forceBold, 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 497 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, createPadWithClearance(), F_Cu, F_Mask, F_Paste, IsCopperLayer(), isPlated(), pad, PAD_ATTRIB_NPTH, PAD_DRILL_SHAPE_CIRCLE, PAD_SHAPE_CIRCLE, PAD_SHAPE_OVAL, 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 85 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 = COLOR4D::BLACK;
    bool          forceBold = true;
    int           penWidth = 0;         // force max width for bold

    if( aText->IsMultilineAllowed() )
    {
        wxArrayString strings_list;
        wxStringSplit( aText->GetShownText(), strings_list, '\n' );
        std::vector<wxPoint> positions;
        positions.reserve( strings_list.Count() );
        aText->GetLinePositions( positions, strings_list.Count() );

        for( unsigned ii = 0; ii < strings_list.Count(); ++ii )
        {
            wxString txt = strings_list.Item( ii );

            GRText( nullptr, positions[ii], dummy_color, txt, aText->GetTextAngle(), size,
                    aText->GetHorizJustify(), aText->GetVertJustify(), penWidth,
                    aText->IsItalic(), forceBold, addTextSegmToContainer );
        }
    }
    else
    {
        GRText( nullptr, aText->GetTextPos(), dummy_color, aText->GetShownText(),
                aText->GetTextAngle(), size, aText->GetHorizJustify(), aText->GetVertJustify(),
                penWidth, aText->IsItalic(), forceBold, addTextSegmToContainer );
    }
}

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

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 640 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 S_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 S_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 S_ARC:
    {
        unsigned int segCount = GetCircleSegmentCount( aShape->GetBoundingBox().GetSizeMax() );

        transformArcToSegments( aShape->GetCenter(), aShape->GetArcStart(), aShape->GetAngle(),
                                segCount, linewidth, aDstContainer, *aShape );
    }
    break;

    case S_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 S_CURVE:
    case S_POLYGON:
    {
        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 "
                    + PCB_SHAPE_TYPE_T_asString( aShape->GetShape() ) );
        break;
    }
}

References CONTAINER_2D_BASE::Add(), ConvertPolygonToTriangles(), ERROR_INSIDE, PCB_SHAPE::GetAngle(), PCB_SHAPE::GetArcStart(), PCB_SHAPE::GetBoundingBox(), PCB_SHAPE::GetCenter(), GetCircleSegmentCount(), PCB_SHAPE::GetEnd(), PCB_SHAPE::GetRadius(), PCB_SHAPE::GetRectCorners(), PCB_SHAPE::GetShape(), EDA_RECT::GetSizeMax(), PCB_SHAPE::GetStart(), PCB_SHAPE::GetWidth(), Is_segment_a_circle(), SHAPE_POLY_SET::IsEmpty(), PCB_SHAPE::IsFilled(), m_biuTo3Dunits, PCB_SHAPE_TYPE_T_asString(), SHAPE_POLY_SET::PM_FAST, S_ARC, S_CIRCLE, S_CURVE, S_POLYGON, S_RECT, S_SEGMENT, SHAPE_POLY_SET::Simplify(), transformArcToSegments(), and PCB_SHAPE::TransformShapeWithClearanceToPolygon().

addShapeWithClearance() [3/3]

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

private

Definition at line 129 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, DIMENSION_BASE::GetLineThickness(), DIMENSION_BASE::GetShapes(), m_biuTo3Dunits, SH_CIRCLE, SH_SEGMENT, 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 758 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 158 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::loadModels(), 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 ERROR_INSIDE, PAD::GetEffectivePolygon(), PAD::GetShape(), PAD::GetSize(), PAD_SHAPE_CIRCLE, 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 833 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(), PAD::GetEffectivePolygon(), PAD::GetShape(), PAD::GetSize(), Is_segment_a_circle(), m_biuTo3Dunits, PAD_SHAPE_CIRCLE, 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 459 of file board_adapter.cpp.

{
    m_board_poly.RemoveAllContours();

    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 125 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;

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

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

        // Note: a 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 VIA *via = static_cast< const 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 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 VIA *via = dyn_cast< const 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 TRACK *track = trackList[trackIdx];

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

            // ADD VIAS and THT
            if( track->Type() == PCB_VIA_T )
            {
                const VIA*    via               = static_cast<const VIA*>( track );
                const VIATYPE viatype           = via->GetViaType();
                const float   holediameter      = via->GetDrillValue() * BiuTo3dUnits();
                const float   thickness         = GetCopperThickness();
                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 TRACK *track = trackList[trackIdx];

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

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

                if( viatype != VIATYPE::THROUGH )
                {
                    // Add 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 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 VIA *via = dyn_cast< const 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() : 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<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<const ZONE*, PCB_LAYER_ID>> zones;

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

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

        size_t parallelThreadCount = 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 ) )
                {
                    const ZONE* zone = zones[areaId].first;

                    if( zone == nullptr )
                        break;

                    PCB_LAYER_ID layer = zones[areaId].second;

                    auto layerContainer = m_layerMap.find( layer );

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

                threadsFinished++;
            } );

            t.detach();
        }

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

    }

    if( GetFlag( FL_ZONE ) && GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS )
      && ( m_renderEngine == RENDER_ENGINE::OPENGL_LEGACY ) )
    {
        // Add copper zones
        for( ZONE* zone : m_board->Zones() )
        {
            if( zone == nullptr )
                break;

            for( PCB_LAYER_ID layer : zone->GetLayerSet().Seq() )
            {
                auto layerContainer = m_layers_poly.find( layer );

                if( layerContainer != m_layers_poly.end() )
                    zone->TransformSolidAreasShapesToPolygon( layer, *layerContainer->second );
            }
        }
    }

    // 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() ) )
            {
                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() ) )
            {
                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 )
        {
            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;

        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<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(), GetCopperThickness(), 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, OPENGL_LEGACY, pad, PAD_ATTRIB_NPTH, 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(), TRACK::TransformShapeWithClearanceToPolygon(), 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, wxSize  aClearanceValue  ) const

private

Definition at line 324 of file create_3Dgraphic_brd_items.cpp.

{
    SHAPE_POLY_SET poly;

    // 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( ( aClearanceValue.x < 0 || aClearanceValue.x != aClearanceValue.y )
            && aPad->GetShape() != PAD_SHAPE_CUSTOM )
    {
        PAD dummy( *aPad );
        dummy.SetSize( aPad->GetSize() + aClearanceValue + aClearanceValue );
        dummy.TransformShapeWithClearanceToPolygon( poly, aLayer, 0, ARC_HIGH_DEF, ERROR_INSIDE );
        aClearanceValue = { 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() + aClearanceValue.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() + aClearanceValue.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() + aClearanceValue.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( aClearanceValue.x )
            poly.Inflate( aClearanceValue.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(), 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_ARC::GetWidth(), SHAPE_SEGMENT::GetWidth(), SHAPE_POLY_SET::Inflate(), Is_segment_a_circle(), SHAPE_POLY_SET::IsEmpty(), m_biuTo3Dunits, SHAPE_POLY_SET::NewOutline(), PAD_SHAPE_CUSTOM, 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 459 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 TRACK *  aTrack, CONTAINER_2D_BASE *  aDstContainer, int  aClearanceValue  )

private

Definition at line 245 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 ARC* arc = static_cast<const 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(), ARC::GetAngle(), GetArcToSegmentCount(), ARC::GetCenter(), TRACK::GetEnd(), ARC::GetRadius(), TRACK::GetStart(), 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 58 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 87 of file board_adapter.h.

    {
        return m_3dModelManager;
    }

References m_3dModelManager.

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

GetAntiAliasingMode()

ANTIALIASING_MODE BOARD_ADAPTER::GetAntiAliasingMode ( ) const

inline

Get the current antialiasing mode value.

Returns

antialiasing mode value

Definition at line 274 of file board_adapter.h.

{ return m_antiAliasingMode; }

References m_antiAliasingMode.

Referenced by EDA_3D_VIEWER::SaveSettings(), and DIALOG_3D_VIEW_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 499 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 509 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 489 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 541 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 168 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 135 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_LEGACY::load3dModels(), RENDER_3D_RAYTRACE::loadModels(), 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 235 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 320 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 225 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 215 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 256 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 264 of file board_adapter.cpp.

{
    wxASSERT( aDiameterBIU > 0 );

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

References GetArcToSegmentCount().

GetColor()

SFVEC4F BOARD_ADAPTER::GetColor

(

COLOR4D

aColor

)

const

Parameters

aColor

the color mapped.

Returns

the color in SFVEC3F format

Definition at line 537 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::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 198 of file board_adapter.h.

    {
        return m_copperThickness3DU;
    }

References m_copperThickness3DU.

Referenced by createLayers(), RENDER_3D_LEGACY::generateViasAndPads(), 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 178 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 215 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_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(), and DIALOG_3D_VIEW_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 502 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::loadModels(), and RENDER_3D_LEGACY::renderFootprint().

GetFrontPlatedPadPolys()

const SHAPE_POLY_SET* BOARD_ADAPTER::GetFrontPlatedPadPolys ( )

inline

Definition at line 536 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 254 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::SaveSettings().

GetHoleCount()

unsigned int BOARD_ADAPTER::GetHoleCount ( ) const

inlinenoexcept

Get number of holes in this board.

Returns

number of holes.

Definition at line 479 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 546 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 551 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 250 of file board_adapter.cpp.

{
    return m_board->GetDesignSettings().GetHolePlatingThickness();
}

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

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 531 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 364 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 521 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 394 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 374 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 353 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 310 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(), and EDA_3D_VIEWER::SaveSettings().

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 188 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 436 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 384 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 379 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 531 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 294 of file board_adapter.h.

    {
        return m_renderEngine;
    }

References m_renderEngine.

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

GetThroughHoleAnnularRingPolys()

const SHAPE_POLY_SET& BOARD_ADAPTER::GetThroughHoleAnnularRingPolys ( ) const

inlinenoexcept

Definition at line 431 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 414 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 459 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 426 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 404 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 449 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 444 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 469 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 272 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->IsFootprintHolder() || !GetFlag( FL_USE_REALISTIC_MODE )
            || !succeedToGetBoardPolygon )
        boardEdgesOnly = false;

    EDA_RECT 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->GetCopperLayerCount();

    // 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->GetDesignSettings().GetBoardThickness() * 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 );
}

References _, B_Adhes, B_Cu, B_Mask, B_Paste, B_SilkS, EDA_RECT::Centre(), BOARD::ComputeBoundingBox(), COPPER_THICKNESS, createBoardPolygon(), createLayers(), F_Adhes, F_Cu, F_Mask, F_Paste, F_SilkS, FL_USE_REALISTIC_MODE, BOARD_DESIGN_SETTINGS::GetBoardThickness(), BOARD::GetCopperLayerCount(), BOARD::GetDesignSettings(), GetFlag(), EDA_RECT::GetHeight(), GetRunningMicroSecs(), EDA_RECT::GetSize(), EDA_RECT::GetWidth(), EDA_RECT::Inflate(), BOARD::IsFootprintHolder(), layerThicknessMargin, m_biuTo3Dunits, m_board, m_boardBoundingBox, m_boardCenter, m_boardPos, m_boardSize, m_copperLayersCount, m_copperThickness3DU, m_epoxyThickness3DU, m_layerZcoordBottom, m_layerZcoordTop, m_logTrace, m_nonCopperLayerThickness3DU, m_solderPasteLayerThickness3DU, MAX_CU_LAYERS, Millimeter2iu(), PCB_LAYER_ID_COUNT, 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 151 of file board_adapter.cpp.

{
    wxASSERT( aLayer < PCB_LAYER_ID_COUNT );

    if( !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->IsLayerVisible( aLayer ) || GetFlag( FL_USE_REALISTIC_MODE );

    default:
        // the layer is an internal copper layer, used the visibility
        return 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 231 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::loadModels(), 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 79 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 281 of file board_adapter.h.

{ m_antiAliasingMode = aAAmode; }

References m_antiAliasingMode.

Referenced by EDA_3D_VIEWER::LoadSettings(), and DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow().

SetBoard()

void BOARD_ADAPTER::SetBoard ( BOARD *  aBoard )

inlinenoexcept

Set current board to be rendered.

Parameters

aBoard

board to process.

Definition at line 125 of file board_adapter.h.

    {
        m_board = aBoard;
    }

References m_board.

Referenced by EDA_3D_CANVAS::ReloadRequest().

SetColorSettings()

void BOARD_ADAPTER::SetColorSettings ( COLOR_SETTINGS *  aSettings )

inlinenoexcept

Definition at line 140 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 223 of file board_adapter.cpp.

{
    wxASSERT( aFlag < FL_LAST );

    m_drawFlags[aFlag] = aState;
}

References FL_LAST, and m_drawFlags.

Referenced by BOARD_ADAPTER(), PANEL_PREV_3D::loadCommonSettings(), EDA_3D_VIEWER::loadCommonSettings(), PANEL_PREV_3D::PANEL_PREV_3D(), EDA_3D_CONTROLLER::ToggleVisibility(), and DIALOG_3D_VIEW_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 264 of file board_adapter.h.

    {
        m_gridType = aGridType;
    }

References m_gridType.

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

SetMaterialMode()

void BOARD_ADAPTER::SetMaterialMode ( MATERIAL_MODE  aMaterialMode )

inlinenoexcept

Parameters

aMaterialMode

the render material mode.

Definition at line 302 of file board_adapter.h.

    {
        m_materialMode = aMaterialMode;
    }

References m_materialMode.

Referenced by EDA_3D_VIEWER::LoadSettings(), and EDA_3D_CONTROLLER::SetMaterial().

SetRenderEngine()

void BOARD_ADAPTER::SetRenderEngine ( RENDER_ENGINE  aRenderEngine )

inlinenoexcept

Parameters

aRenderEngine

the render engine mode selected.

Definition at line 286 of file board_adapter.h.

    {
        m_renderEngine = aRenderEngine;
    }

References m_renderEngine.

Referenced by EDA_3D_CANVAS::DoRePaint(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::OnDisableRayTracing(), and EDA_3D_VIEWER::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 571 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(), 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 );
            }
        }
    }
}

References ERROR_INSIDE, BOARD_ITEM::GetLayer(), FOOTPRINT::GraphicalItems(), PCB_FP_SHAPE_T, and PCB_SHAPE::TransformShapeWithClearanceToPolygon().

Referenced by createLayers().

Member Data Documentation

m_3dModelManager

S3D_CACHE* BOARD_ADAPTER::m_3dModelManager

private

Definition at line 642 of file board_adapter.h.

Referenced by Get3dCacheManager(), and Set3dCacheManager().

m_antiAliasingMode

ANTIALIASING_MODE BOARD_ADAPTER::m_antiAliasingMode

private

Definition at line 649 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), GetAntiAliasingMode(), and SetAntiAliasingMode().

m_averageHoleDiameter

float BOARD_ADAPTER::m_averageHoleDiameter

private

Definition at line 748 of file board_adapter.h.

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

m_averageTrackWidth

float BOARD_ADAPTER::m_averageTrackWidth

private

Number of through hole vias in the board.

Definition at line 736 of file board_adapter.h.

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

m_averageViaHoleDiameter

float BOARD_ADAPTER::m_averageViaHoleDiameter

private

Number of holes in the board.

Definition at line 742 of file board_adapter.h.

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

m_backPlatedPadPolys

SHAPE_POLY_SET* BOARD_ADAPTER::m_backPlatedPadPolys

private

Polygon contours for hole outer diameters for each layer.

Definition at line 662 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), createLayers(), destroyLayers(), and GetBackPlatedPadPolys().

m_BgColorBot

SFVEC4F BOARD_ADAPTER::m_BgColorBot

background bottom color

Definition at line 609 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::Process_Special_Functions(), RENDER_3D_LEGACY::Redraw(), RENDER_3D_RAYTRACE::Redraw(), RENDER_3D_RAYTRACE::render(), RENDER_3D_RAYTRACE::renderPreview(), and EDA_3D_VIEWER::SaveSettings().

m_BgColorTop

SFVEC4F BOARD_ADAPTER::m_BgColorTop

background top color

Definition at line 610 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::Process_Special_Functions(), RENDER_3D_LEGACY::Redraw(), RENDER_3D_RAYTRACE::Redraw(), RENDER_3D_RAYTRACE::Reload(), RENDER_3D_RAYTRACE::render(), RENDER_3D_RAYTRACE::renderPreview(), EDA_3D_VIEWER::SaveSettings(), and RENDER_3D_RAYTRACE::setupMaterials().

m_biuTo3Dunits

double BOARD_ADAPTER::m_biuTo3Dunits

private

Top (End) Z position of each layer in 3D units.

Definition at line 712 of file board_adapter.h.

Referenced by addFootprintShapesWithClearance(), addShapeWithClearance(), addSolidAreasShapes(), BiuTo3dUnits(), BOARD_ADAPTER(), buildPadOutlineAsSegments(), createLayers(), createPadWithClearance(), createPadWithDrill(), createTrack(), GetCircleSegmentCount(), InitSettings(), and transformArcToSegments().

m_board

BOARD* BOARD_ADAPTER::m_board

private

Definition at line 641 of file board_adapter.h.

Referenced by createBoardPolygon(), createLayers(), GetBoard(), GetHolePlatingThickness(), InitSettings(), Is3dLayerEnabled(), and SetBoard().

m_board_poly

SHAPE_POLY_SET BOARD_ADAPTER::m_board_poly

private

Board outline polygon.

Definition at line 682 of file board_adapter.h.

Referenced by createBoardPolygon(), and GetBoardPoly().

m_BoardBodyColor

SFVEC4F BOARD_ADAPTER::m_BoardBodyColor

in realistic mode: FR4 board color

Definition at line 611 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), RENDER_3D_LEGACY::Redraw(), RENDER_3D_RAYTRACE::Reload(), RENDER_3D_LEGACY::renderBoardBody(), EDA_3D_VIEWER::SaveSettings(), EDA_3D_VIEWER::Set3DBoardBodyColorFromUser(), and RENDER_3D_RAYTRACE::setupMaterials().

m_boardBoundingBox

BBOX_3D BOARD_ADAPTER::m_boardBoundingBox

private

3D bounding box of the board in 3D units.

Polygon contours for each layer.

Definition at line 655 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), GetBBox(), and InitSettings().

m_boardCenter

SFVEC3F BOARD_ADAPTER::m_boardCenter

private

3D center position of the board in 3D units.

Definition at line 654 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), GetBoardCenter(), and InitSettings().

m_boardPos

wxPoint BOARD_ADAPTER::m_boardPos

private

Board center position in board internal units.

Definition at line 652 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), GetBoardPos(), and InitSettings().

m_boardSize

wxSize BOARD_ADAPTER::m_boardSize

private

Board size in board internal units.

Definition at line 653 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), GetBoardSize(), and InitSettings().

m_colors

COLOR_SETTINGS* BOARD_ADAPTER::m_colors

private

Definition at line 643 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), GetItemColor(), GetLayerColor(), and SetColorSettings().

m_CopperColor

SFVEC4F BOARD_ADAPTER::m_CopperColor

in realistic mode: copper color

Definition at line 617 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), RENDER_3D_LEGACY::getLayerColor(), RENDER_3D_RAYTRACE::insertHole(), EDA_3D_VIEWER::LoadSettings(), RENDER_3D_RAYTRACE::Reload(), EDA_3D_VIEWER::SaveSettings(), EDA_3D_VIEWER::Set3DCopperColorFromUser(), RENDER_3D_RAYTRACE::setupMaterials(), and RENDER_3D_LEGACY::setupMaterials().

m_copperLayersCount

unsigned int BOARD_ADAPTER::m_copperLayersCount

private

Scale factor to convert board internal units to 3D units normalized between -1.0 and 1.0.

Definition at line 709 of file board_adapter.h.

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

m_copperThickness3DU

float BOARD_ADAPTER::m_copperThickness3DU

private

Epoxy thickness in 3D units.

Definition at line 721 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), GetCopperThickness(), and InitSettings().

m_drawFlags

std::vector< bool > BOARD_ADAPTER::m_drawFlags

private

Definition at line 645 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), GetFlag(), and SetFlag().

m_epoxyThickness3DU

float BOARD_ADAPTER::m_epoxyThickness3DU

private

Non copper layers thickness in 3D units.

Definition at line 724 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), GetEpoxyThickness(), and InitSettings().

m_frontPlatedPadPolys

SHAPE_POLY_SET* BOARD_ADAPTER::m_frontPlatedPadPolys

private

Definition at line 661 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), createLayers(), destroyLayers(), and GetFrontPlatedPadPolys().

m_gridType

GRID3D_TYPE BOARD_ADAPTER::m_gridType

private

Definition at line 646 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), GetGridType(), and SetGridType().

m_holeCount

unsigned int BOARD_ADAPTER::m_holeCount

private

Computed average diameter of the holes in 3D units.

Definition at line 745 of file board_adapter.h.

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

m_layerHoleIdPolys

MAP_POLY BOARD_ADAPTER::m_layerHoleIdPolys

private

Polygon contours for non plated through hole outer diameters.

Definition at line 668 of file board_adapter.h.

Referenced by createLayers(), destroyLayers(), and GetHoleIdPolysMap().

m_layerHoleMap

MAP_CONTAINER_2D_BASE BOARD_ADAPTER::m_layerHoleMap

private

List of through holes with the radius of the hole inflated with the copper thickness.

Definition at line 691 of file board_adapter.h.

Referenced by createLayers(), destroyLayers(), and GetLayerHoleMap().

m_layerHoleOdPolys

MAP_POLY BOARD_ADAPTER::m_layerHoleOdPolys

private

Polygon contours for hole inner diameters for each layer.

Definition at line 665 of file board_adapter.h.

Referenced by createLayers(), destroyLayers(), and GetHoleOdPolysMap().

m_layerMap

MAP_CONTAINER_2D_BASE BOARD_ADAPTER::m_layerMap

private

2D elements for each layer.

Definition at line 684 of file board_adapter.h.

Referenced by createLayers(), destroyLayers(), and GetLayerMap().

m_layers_poly

MAP_POLY BOARD_ADAPTER::m_layers_poly

private

Definition at line 659 of file board_adapter.h.

Referenced by createLayers(), destroyLayers(), and GetPolyMap().

m_layerZcoordBottom

std::array<float, PCB_LAYER_ID_COUNT> BOARD_ADAPTER::m_layerZcoordBottom

private

Copper thickness in 3D units.

Definition at line 718 of file board_adapter.h.

Referenced by GetFootprintZPos(), GetLayerBottomZPos(), and InitSettings().

m_layerZcoordTop

std::array<float, PCB_LAYER_ID_COUNT> BOARD_ADAPTER::m_layerZcoordTop

private

Bottom (Start) Z position of each layer in 3D units.

Definition at line 715 of file board_adapter.h.

Referenced by GetFootprintZPos(), GetLayerTopZPos(), and InitSettings().

m_materialMode

MATERIAL_MODE BOARD_ADAPTER::m_materialMode

private

Definition at line 648 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), GetMaterialMode(), and SetMaterialMode().

m_nonCopperLayerThickness3DU

float BOARD_ADAPTER::m_nonCopperLayerThickness3DU

private

solder paste layers thickness in 3D units.

Definition at line 727 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), GetNonCopperLayerThickness(), and InitSettings().

m_nonPlatedThroughHoleOdPolys

SHAPE_POLY_SET BOARD_ADAPTER::m_nonPlatedThroughHoleOdPolys

private

Polygon contours for through hole outer diameters.

Definition at line 671 of file board_adapter.h.

Referenced by createLayers(), destroyLayers(), and GetOuterNonPlatedThroughHolePoly().

m_OpenGlSelectionColor

SFVEC3F BOARD_ADAPTER::m_OpenGlSelectionColor

Definition at line 619 of file board_adapter.h.

Referenced by EDA_3D_VIEWER::LoadSettings(), RENDER_3D_LEGACY::renderFootprint(), EDA_3D_VIEWER::SaveSettings(), DIALOG_3D_VIEW_OPTIONS::TransferColorDataToWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow().

m_platedPadsBack

BVH_CONTAINER_2D* BOARD_ADAPTER::m_platedPadsBack

private

The holes per each layer.

Definition at line 688 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), createLayers(), destroyLayers(), and GetPlatedPadsBack().

m_platedPadsFront

BVH_CONTAINER_2D* BOARD_ADAPTER::m_platedPadsFront

private

Definition at line 687 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), createLayers(), destroyLayers(), and GetPlatedPadsFront().

m_renderEngine

RENDER_ENGINE BOARD_ADAPTER::m_renderEngine

private

Definition at line 647 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), createLayers(), GetRenderEngine(), and SetRenderEngine().

m_RtCameraLightColor

SFVEC3F BOARD_ADAPTER::m_RtCameraLightColor

Definition at line 622 of file board_adapter.h.

Referenced by EDA_3D_VIEWER::LoadSettings(), DIALOG_3D_VIEW_OPTIONS::OnLightsResetToDefaults(), RENDER_3D_RAYTRACE::Reload(), EDA_3D_VIEWER::SaveSettings(), DIALOG_3D_VIEW_OPTIONS::TransferColorDataToWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow().

m_RtLightColor

std::vector<SFVEC3F> BOARD_ADAPTER::m_RtLightColor

Definition at line 626 of file board_adapter.h.

Referenced by EDA_3D_VIEWER::LoadSettings(), DIALOG_3D_VIEW_OPTIONS::OnLightsResetToDefaults(), RENDER_3D_RAYTRACE::Reload(), EDA_3D_VIEWER::SaveSettings(), DIALOG_3D_VIEW_OPTIONS::TransferColorDataToWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow().

m_RtLightColorBottom

SFVEC3F BOARD_ADAPTER::m_RtLightColorBottom

Definition at line 624 of file board_adapter.h.

Referenced by EDA_3D_VIEWER::LoadSettings(), DIALOG_3D_VIEW_OPTIONS::OnLightsResetToDefaults(), RENDER_3D_RAYTRACE::Reload(), EDA_3D_VIEWER::SaveSettings(), DIALOG_3D_VIEW_OPTIONS::TransferColorDataToWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow().

m_RtLightColorTop

SFVEC3F BOARD_ADAPTER::m_RtLightColorTop

Definition at line 623 of file board_adapter.h.

Referenced by EDA_3D_VIEWER::LoadSettings(), DIALOG_3D_VIEW_OPTIONS::OnLightsResetToDefaults(), RENDER_3D_RAYTRACE::Reload(), EDA_3D_VIEWER::SaveSettings(), DIALOG_3D_VIEW_OPTIONS::TransferColorDataToWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow().

m_RtLightSphericalCoords

std::vector<SFVEC2F> BOARD_ADAPTER::m_RtLightSphericalCoords

Definition at line 627 of file board_adapter.h.

Referenced by EDA_3D_VIEWER::LoadSettings(), DIALOG_3D_VIEW_OPTIONS::OnLightsResetToDefaults(), RENDER_3D_RAYTRACE::Reload(), EDA_3D_VIEWER::SaveSettings(), DIALOG_3D_VIEW_OPTIONS::TransferColorDataToWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow().

m_RtRecursiveReflectionCount

int BOARD_ADAPTER::m_RtRecursiveReflectionCount

Definition at line 633 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::SaveSettings(), RENDER_3D_RAYTRACE::setupMaterials(), DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow().

m_RtRecursiveRefractionCount

int BOARD_ADAPTER::m_RtRecursiveRefractionCount

Definition at line 634 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::SaveSettings(), RENDER_3D_RAYTRACE::setupMaterials(), DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow().

m_RtReflectionSampleCount

int BOARD_ADAPTER::m_RtReflectionSampleCount

Definition at line 631 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::SaveSettings(), RENDER_3D_RAYTRACE::setupMaterials(), DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow().

m_RtRefractionSampleCount

int BOARD_ADAPTER::m_RtRefractionSampleCount

Definition at line 632 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::SaveSettings(), RENDER_3D_RAYTRACE::setupMaterials(), DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow().

m_RtShadowSampleCount

int BOARD_ADAPTER::m_RtShadowSampleCount

Definition at line 630 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::SaveSettings(), RENDER_3D_RAYTRACE::shadeHit(), DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow().

m_RtSpreadReflections

float BOARD_ADAPTER::m_RtSpreadReflections

Definition at line 637 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::SaveSettings(), RENDER_3D_RAYTRACE::shadeHit(), DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow().

m_RtSpreadRefractions

float BOARD_ADAPTER::m_RtSpreadRefractions

Definition at line 638 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::SaveSettings(), RENDER_3D_RAYTRACE::shadeHit(), DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow().

m_RtSpreadShadows

float BOARD_ADAPTER::m_RtSpreadShadows

Definition at line 636 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::SaveSettings(), RENDER_3D_RAYTRACE::shadeHit(), DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow().

m_SilkScreenColorBot

SFVEC4F BOARD_ADAPTER::m_SilkScreenColorBot

in realistic mode: SilkScreen color ( bot )

Definition at line 615 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), RENDER_3D_LEGACY::getLayerColor(), EDA_3D_VIEWER::LoadSettings(), RENDER_3D_RAYTRACE::Reload(), EDA_3D_VIEWER::SaveSettings(), EDA_3D_VIEWER::Set3DSilkScreenColorFromUser(), RENDER_3D_LEGACY::setupMaterials(), and EDA_3D_VIEWER::SynchroniseColoursWithBoard().

m_SilkScreenColorTop

SFVEC4F BOARD_ADAPTER::m_SilkScreenColorTop

in realistic mode: SilkScreen color ( top )

Definition at line 616 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), RENDER_3D_LEGACY::getLayerColor(), EDA_3D_VIEWER::LoadSettings(), RENDER_3D_RAYTRACE::Reload(), EDA_3D_VIEWER::SaveSettings(), EDA_3D_VIEWER::Set3DSilkScreenColorFromUser(), RENDER_3D_RAYTRACE::setupMaterials(), RENDER_3D_LEGACY::setupMaterials(), and EDA_3D_VIEWER::SynchroniseColoursWithBoard().

m_SolderMaskColorBot

SFVEC4F BOARD_ADAPTER::m_SolderMaskColorBot

in realistic mode: solder mask color ( bot )

Definition at line 612 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), RENDER_3D_LEGACY::getLayerColor(), EDA_3D_VIEWER::LoadSettings(), RENDER_3D_RAYTRACE::Reload(), EDA_3D_VIEWER::Set3DSolderMaskColorFromUser(), and EDA_3D_VIEWER::SynchroniseColoursWithBoard().

m_SolderMaskColorTop

SFVEC4F BOARD_ADAPTER::m_SolderMaskColorTop

in realistic mode: solder mask color ( top )

Definition at line 613 of file board_adapter.h.

Referenced by