BOARD_ADAPTER Class Reference

Class BOARD_ADAPTER 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
	Set3DCacheManager - Update the Cache manager pointer. More...
S3D_CACHE *	Get3DCacheManager () const noexcept
	Get3DCacheManager - Return the 3d cache manager pointer. More...
bool	GetFlag (DISPLAY3D_FLG aFlag) const
	GetFlag - get a configuration status of a flag. More...
void	SetFlag (DISPLAY3D_FLG aFlag, bool aState)
	SetFlag - set the status of a flag. More...
bool	Is3DLayerEnabled (PCB_LAYER_ID aLayer) const
	Is3DLayerEnabled - Check if a layer is enabled. More...
bool	ShouldFPBeDisplayed (FOOTPRINT_ATTR_T aFPAttributes) const
	ShouldFPBeDisplayed - Test if footprint should be displayed in relation to attributes and the flags. More...
void	SetBoard (BOARD *aBoard) noexcept
	SetBoard - Set current board to be rendered. More...
const BOARD *	GetBoard () const noexcept
	GetBoard - Get current board to be rendered. More...
void	SetColorSettings (COLOR_SETTINGS *aSettings) noexcept
void	InitSettings (REPORTER *aStatusReporter, REPORTER *aWarningReporter)
	InitSettings - Function to be called by the render when it need to reload the settings for the board. More...
double	BiuTo3Dunits () const noexcept
	BiuTo3Dunits - Board integer units To 3D units. More...
const CBBOX &	GetBBox3DU () const noexcept
	GetBBox3DU - Get the bbox of the pcb board. More...
float	GetEpoxyThickness3DU () const noexcept
	GetEpoxyThickness3DU - Get the current epoxy thickness. More...
float	GetNonCopperLayerThickness3DU () const noexcept
	GetNonCopperLayerThickness3DU - Get the current non copper layers thickness. More...
float	GetCopperThickness3DU () const noexcept
	GetCopperThickness3DU - Get the current copper layer thickness. More...
int	GetHolePlatingThicknessBIU () const noexcept
	GetCopperThicknessBIU - Get the current copper layer thickness. More...
wxSize	GetBoardSizeBIU () const noexcept
	GetBoardSizeBIU - Get the board size. More...
wxPoint	GetBoardPosBIU () const noexcept
	GetBoardPosBIU - Get the board center. More...
const SFVEC3F &	GetBoardCenter3DU () const noexcept
	GetBoardCenter - the board center position in 3d units. More...
float	GetModulesZcoord3DIU (bool aIsFlipped) const
	GetModulesZcoord3DIU - Get the position of the footprint in 3d integer units considering if it is flipped or not. More...
GRID3D_TYPE	GridGet () const noexcept
	GridGet - get the current grid. More...
void	GridSet (GRID3D_TYPE aGridType) noexcept
	GridSet - set the current grid. More...
ANTIALIASING_MODE	AntiAliasingGet () const
	GridGet - get the current antialiasing mode value. More...
void	AntiAliasingSet (ANTIALIASING_MODE aAAmode)
	AntiAliasingSet - set the current antialiasing mode value. More...
void	RenderEngineSet (RENDER_ENGINE aRenderEngine) noexcept
	RenderEngineSet. More...
RENDER_ENGINE	RenderEngineGet () const noexcept
	RenderEngineGet. More...
void	MaterialModeSet (MATERIAL_MODE aMaterialMode) noexcept
	MaterialModeSet. More...
MATERIAL_MODE	MaterialModeGet () const noexcept
	MaterialModeGet. More...
const SHAPE_POLY_SET &	GetBoardPoly () const noexcept
	GetBoardPoly - Get the current polygon of the epoxy board. More...
SFVEC4F	GetLayerColor (PCB_LAYER_ID aLayerId) const
	GetLayerColor - get the technical color of a layer. More...
SFVEC4F	GetItemColor (int aItemId) const
	GetItemColor - get the technical color of a layer. More...
SFVEC4F	GetColor (COLOR4D aColor) const
	GetColor. More...
float	GetLayerTopZpos3DU (PCB_LAYER_ID aLayerId) const noexcept
	GetLayerTopZpos3DU - Get the top z position. More...
float	GetLayerBottomZpos3DU (PCB_LAYER_ID aLayerId) const noexcept
	GetLayerBottomZpos3DU - Get the bottom z position. More...
const MAP_CONTAINER_2D &	GetMapLayers () const noexcept
	GetMapLayers - Get the map of container that have the objects per layer. More...
const CBVHCONTAINER2D *	GetPlatedPads_Front () const noexcept
const CBVHCONTAINER2D *	GetPlatedPads_Back () const noexcept
const MAP_CONTAINER_2D &	GetMapLayersHoles () const noexcept
	GetMapLayersHoles -Get the map of container that have the holes per layer. More...
const CBVHCONTAINER2D &	GetThroughHole_Outer () const noexcept
	GetThroughHole_Outer - Get the inflated ThroughHole container. More...
const CBVHCONTAINER2D &	GetThroughHole_Outer_Ring () const noexcept
	GetThroughHole_Outer_Ring - Get the ThroughHole container that include the width of the annular ring. More...
const SHAPE_POLY_SET &	GetThroughHole_Outer_poly () const noexcept
const SHAPE_POLY_SET &	GetThroughHole_Outer_Ring_poly () const noexcept
const SHAPE_POLY_SET &	GetThroughHole_Outer_poly_NPTH () const noexcept
const CBVHCONTAINER2D &	GetThroughHole_Vias_Outer () const noexcept
	GetThroughHole_Vias_Outer -. More...
const SHAPE_POLY_SET &	GetThroughHole_Vias_Outer_poly () const noexcept
const CBVHCONTAINER2D &	GetThroughHole_Inner () const noexcept
	GetThroughHole_Inner - Get the ThroughHole container. More...
unsigned int	GetStats_Nr_Vias () const noexcept
	GetStats_Nr_Vias - Get statistics of the nr of vias. More...
unsigned int	GetStats_Nr_Holes () const noexcept
	GetStats_Nr_Holes - Get statistics of the nr of holes. More...
float	GetStats_Med_Via_Hole_Diameter3DU () const noexcept
	GetStats_Med_Via_Hole_Diameter3DU - Average diameter of the via holes. More...
float	GetStats_Med_Hole_Diameter3DU () const noexcept
	GetStats_Med_Hole_Diameter3DU - Average diameter of holes. More...
float	GetStats_Med_Track_Width () const noexcept
	GetStats_Med_Track_Width - Average width of the tracks. More...
unsigned int	GetNrSegmentsCircle (float aDiameter3DU) const
	GetNrSegmentsCircle. More...
unsigned int	GetNrSegmentsCircle (int aDiameterBIU) const
	GetNrSegmentsCircle. More...
const MAP_POLY &	GetPolyMap () const noexcept
	GetPolyMap - Get maps of polygons's layers. More...
const SHAPE_POLY_SET *	GetPolyPlatedPads_Front ()
const SHAPE_POLY_SET *	GetPolyPlatedPads_Back ()
const MAP_POLY &	GetPolyMapHoles_Inner () const noexcept
const MAP_POLY &	GetPolyMapHoles_Outer () 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_opengl_selectionColor
SFVEC3F	m_raytrace_lightColorCamera
SFVEC3F	m_raytrace_lightColorTop
SFVEC3F	m_raytrace_lightColorBottom
std::vector< SFVEC3F >	m_raytrace_lightColor
std::vector< SFVEC2F >	m_raytrace_lightSphericalCoords
int	m_raytrace_nrsamples_shadows
int	m_raytrace_nrsamples_reflections
int	m_raytrace_nrsamples_refractions
float	m_raytrace_spread_shadows
float	m_raytrace_spread_reflections
float	m_raytrace_spread_refractions
int	m_raytrace_recursivelevel_reflections
int	m_raytrace_recursivelevel_refractions

Private Member Functions
bool	createBoardPolygon (wxString *aErrorMsg)
	Create the board outline polygon. More...
void	createLayers (REPORTER *aStatusReporter)
void	destroyLayers ()
void	createNewTrack (const TRACK *aTrack, CGENERICCONTAINER2D *aDstContainer, int aClearanceValue)
void	createNewPadWithClearance (const PAD *aPad, CGENERICCONTAINER2D *aDstContainer, PCB_LAYER_ID aLayer, wxSize aClearanceValue) const
COBJECT2D *	createNewPadDrill (const PAD *aPad, int aInflateValue)
void	AddPadsWithClearanceToContainer (const FOOTPRINT *aFootprint, CGENERICCONTAINER2D *aDstContainer, PCB_LAYER_ID aLayerId, int aInflateValue, bool aSkipNPTHPadsWihNoCopper, bool aSkipPlatedPads, bool aSkipNonPlatedPads)
void	AddFPShapesWithClearanceToContainer (const FOOTPRINT *aFootprint, CGENERICCONTAINER2D *aDstContainer, PCB_LAYER_ID aLayerId, int aInflateValue)
void	AddShapeWithClearanceToContainer (const PCB_TEXT *aText, CGENERICCONTAINER2D *aDstContainer, PCB_LAYER_ID aLayerId, int aClearanceValue)
void	AddShapeWithClearanceToContainer (const PCB_SHAPE *aShape, CGENERICCONTAINER2D *aDstContainer, PCB_LAYER_ID aLayerId, int aClearanceValue)
void	AddShapeWithClearanceToContainer (const DIMENSION_BASE *aDimension, CGENERICCONTAINER2D *aDstContainer, PCB_LAYER_ID aLayerId, int aClearanceValue)
void	AddSolidAreasShapesToContainer (const ZONE *aZoneContainer, CGENERICCONTAINER2D *aDstContainer, PCB_LAYER_ID aLayerId)
void	TransformArcToSegments (const wxPoint &aCentre, const wxPoint &aStart, double aArcAngle, int aCircleToSegmentsCount, int aWidth, CGENERICCONTAINER2D *aDstContainer, const BOARD_ITEM &aBoardItem)
void	buildPadShapeThickOutlineAsSegments (const PAD *aPad, CGENERICCONTAINER2D *aDstContainer, int aWidth)
void	buildPadShapeThickOutlineAsPolygon (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_3d_model_manager
COLOR_SETTINGS *	m_colors
std::vector< bool >	m_drawFlags
GRID3D_TYPE	m_3D_grid_type
RENDER_ENGINE	m_render_engine
MATERIAL_MODE	m_material_mode
ANTIALIASING_MODE	m_antialiasing_mode
wxPoint	m_boardPos
	center board actual position in board units More...
wxSize	m_boardSize
	board actual size in board units More...
SFVEC3F	m_boardCenter
	3d center position of the pcb board in 3d units More...
CBBOX	m_boardBoundingBox
	3d bounding box of the pcb board in 3d units More...
MAP_POLY	m_layers_poly
	It contains polygon contours for each layer. More...
SHAPE_POLY_SET *	m_F_Cu_PlatedPads_poly
SHAPE_POLY_SET *	m_B_Cu_PlatedPads_poly
MAP_POLY	m_layers_outer_holes_poly
	It contains polygon contours for holes of each layer (outer holes) More...
MAP_POLY	m_layers_inner_holes_poly
	It contains polygon contours for holes of each layer (inner holes) More...
SHAPE_POLY_SET	m_through_outer_holes_poly_NPTH
	It contains polygon contours for (just) non plated through holes (outer cylinder) More...
SHAPE_POLY_SET	m_through_outer_holes_poly
	It contains polygon contours for through holes (outer cylinder) More...
SHAPE_POLY_SET	m_through_outer_holes_vias_poly
	It contains polygon contours for through holes vias (outer cylinder) More...
SHAPE_POLY_SET	m_through_outer_ring_holes_poly
	It contains polygon contours for through holes vias (outer annular ring) More...
SHAPE_POLY_SET	m_board_poly
	PCB board outline polygon. More...
MAP_CONTAINER_2D	m_layers_container2D
	It contains the 2d elements of each layer. More...
CBVHCONTAINER2D *	m_platedpads_container2D_F_Cu
CBVHCONTAINER2D *	m_platedpads_container2D_B_Cu
MAP_CONTAINER_2D	m_layers_holes2D
	It contains the holes per each layer. More...
CBVHCONTAINER2D	m_through_holes_outer
	It contains the list of throughHoles of the board, the radius of the hole is inflated with the copper tickness. More...
CBVHCONTAINER2D	m_through_holes_outer_ring
	It contains the list of throughHoles of the board, the radius of the hole is inflated with the annular ring size. More...
CBVHCONTAINER2D	m_through_holes_inner
	It contains the list of throughHoles of the board, the radius is the inner hole. More...
CBVHCONTAINER2D	m_through_holes_vias_outer
	It contains the list of throughHoles vias of the board, the radius of the hole is inflated with the copper tickness. More...
CBVHCONTAINER2D	m_through_holes_vias_inner
	It contains the list of throughHoles vias of the board, the radius of the hole. More...
unsigned int	m_copperLayersCount
	Number of copper layers actually used by the board. More...
double	m_biuTo3Dunits
	Normalization scale to convert board internal units to 3D units to normalize 3D units between -1.0 and +1.0. More...
std::array< float, PCB_LAYER_ID_COUNT >	m_layerZcoordTop
	Top (End) Z position of each layer (normalized) More...
std::array< float, PCB_LAYER_ID_COUNT >	m_layerZcoordBottom
	Bottom (Start) Z position of each layer (normalized) More...
float	m_copperThickness3DU
	Copper thickness (normalized) More...
float	m_epoxyThickness3DU
	Epoxy thickness (normalized) More...
float	m_nonCopperLayerThickness3DU
	Non copper layers thickness. More...
float	m_calc_seg_min_factor3DU
	min factor used for cicle segment approximation calculation More...
float	m_calc_seg_max_factor3DU
	max factor used for cicle segment approximation calculation More...
unsigned int	m_stats_nr_tracks
	Number of tracks in the board. More...
float	m_stats_track_med_width
	Track average width. More...
unsigned int	m_stats_nr_vias
	Nr of vias. More...
float	m_stats_via_med_hole_diameter
	Computed medium diameter of the via holes in 3D units. More...
unsigned int	m_stats_nr_holes
	number of holes in the board More...
float	m_stats_hole_med_diameter
	Computed medium diameter of the holes in 3D units. More...

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

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

Definition at line 68 of file board_adapter.h.

Constructor & Destructor Documentation

BOARD_ADAPTER()

BOARD_ADAPTER::BOARD_ADAPTER

(

)

Definition at line 50 of file board_adapter.cpp.

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

    m_3D_grid_type     = GRID3D_TYPE::NONE;
    m_antialiasing_mode = ANTIALIASING_MODE::AA_8X;
    m_drawFlags.resize( FL_LAST, false );

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

    m_render_engine = RENDER_ENGINE::OPENGL_LEGACY;
    m_material_mode = MATERIAL_MODE::NORMAL;

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

    m_boardBoundingBox.Reset();

    m_through_holes_inner.Clear();
    m_through_holes_outer.Clear();
    m_through_holes_outer_ring.Clear();

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

    m_stats_nr_tracks = 0;
    m_stats_nr_vias = 0;
    m_stats_via_med_hole_diameter = 0.0f;
    m_stats_nr_holes = 0;
    m_stats_hole_med_diameter = 0.0f;
    m_stats_track_med_width = 0.0f;

    m_calc_seg_min_factor3DU = 0.0f;
    m_calc_seg_max_factor3DU = 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_platedpads_container2D_F_Cu = nullptr;
    m_platedpads_container2D_B_Cu = nullptr;

    m_F_Cu_PlatedPads_poly = nullptr;
    m_B_Cu_PlatedPads_poly = nullptr;

    // Avoid raytracing options not initialized:
    m_raytrace_nrsamples_shadows = 0;
    m_raytrace_nrsamples_reflections = 0;
    m_raytrace_nrsamples_refractions = 0;

    m_raytrace_spread_shadows = 0.0;
    m_raytrace_spread_reflections = 0.0;
    m_raytrace_spread_refractions = 0.0;

    m_raytrace_recursivelevel_reflections = 0;
    m_raytrace_recursivelevel_refractions = 0;
}

References AA_8X, CBVHCONTAINER2D::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_3D_grid_type, m_antialiasing_mode, m_B_Cu_PlatedPads_poly, m_BgColorBot, m_BgColorTop, m_biuTo3Dunits, m_BoardBodyColor, m_boardBoundingBox, m_boardCenter, m_boardPos, m_boardSize, m_calc_seg_max_factor3DU, m_calc_seg_min_factor3DU, m_colors, m_CopperColor, m_copperLayersCount, m_copperThickness3DU, m_drawFlags, m_epoxyThickness3DU, m_F_Cu_PlatedPads_poly, m_logTrace, m_material_mode, m_nonCopperLayerThickness3DU, m_platedpads_container2D_B_Cu, m_platedpads_container2D_F_Cu, m_raytrace_nrsamples_reflections, m_raytrace_nrsamples_refractions, m_raytrace_nrsamples_shadows, m_raytrace_recursivelevel_reflections, m_raytrace_recursivelevel_refractions, m_raytrace_spread_reflections, m_raytrace_spread_refractions, m_raytrace_spread_shadows, m_render_engine, m_SilkScreenColorBot, m_SilkScreenColorTop, m_SolderMaskColorBot, m_SolderMaskColorTop, m_SolderPasteColor, m_stats_hole_med_diameter, m_stats_nr_holes, m_stats_nr_tracks, m_stats_nr_vias, m_stats_track_med_width, m_stats_via_med_hole_diameter, m_through_holes_inner, m_through_holes_outer, m_through_holes_outer_ring, NONE, NORMAL, OPENGL_LEGACY, Pgm(), PgmOrNull(), CBBOX::Reset(), and SetFlag().

~BOARD_ADAPTER()

BOARD_ADAPTER::~BOARD_ADAPTER

(

)

Definition at line 145 of file board_adapter.cpp.

{
    destroyLayers();
}

References destroyLayers().

Member Function Documentation

AddFPShapesWithClearanceToContainer()

void BOARD_ADAPTER::AddFPShapesWithClearanceToContainer ( const FOOTPRINT *  aFootprint, CGENERICCONTAINER2D *  aDstContainer, PCB_LAYER_ID  aLayerId, int  aInflateValue  )

private

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

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

        default:
            break;
        }
    }

    // Convert texts sur 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( NULL, text->GetTextPos(), BLACK, text->GetShownText(), text->GetDrawRotation(),
                size, text->GetHorizJustify(), text->GetVertJustify(), penWidth, text->IsItalic(),
                forceBold, addTextSegmToContainer );
    }
}

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

Referenced by createLayers().

AddPadsWithClearanceToContainer()

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

private

Definition at line 476 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;
        }

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

References B_Cu, B_Mask, B_Paste, createNewPadWithClearance(), F_Cu, F_Mask, F_Paste, IsCopperLayer(), isPlated(), PAD_ATTRIB_NPTH, PAD_DRILL_SHAPE_CIRCLE, PAD_SHAPE_CIRCLE, PAD_SHAPE_OVAL, and FOOTPRINT::Pads().

Referenced by createLayers().

AddShapeWithClearanceToContainer() [1/3]

void BOARD_ADAPTER::AddShapeWithClearanceToContainer ( const PCB_TEXT *  aText, CGENERICCONTAINER2D *  aDstContainer, PCB_LAYER_ID  aLayerId, int  aClearanceValue  )

private

Definition at line 87 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 AddFPShapesWithClearanceToContainer(), AddShapeWithClearanceToContainer(), and createLayers().

AddShapeWithClearanceToContainer() [2/3]

void BOARD_ADAPTER::AddShapeWithClearanceToContainer ( const PCB_SHAPE *  aShape, CGENERICCONTAINER2D *  aDstContainer, PCB_LAYER_ID  aLayerId, int  aClearanceValue  )

private

Definition at line 625 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 CFILLEDCIRCLE2D( center3DU, outer_radius, *aShape ) );
        else
            aDstContainer->Add( new CRING2D( center3DU, inner_radius, outer_radius, *aShape ) );
    }
        break;

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

            aShape->TransformShapeWithClearanceToPolygon( polyList, aLayerId, linewidth / 2,
                                                          ARC_HIGH_DEF, ERROR_INSIDE );

            polyList.Simplify( SHAPE_POLY_SET::PM_FAST );

            Convert_shape_line_polygon_to_triangles( 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 CROUNDSEGMENT2D( topLeft3DU, topRight3DU,
                                                     linewidth * m_biuTo3Dunits, *aShape ) );
            aDstContainer->Add( new CROUNDSEGMENT2D( topRight3DU, botRight3DU,
                                                     linewidth * m_biuTo3Dunits, *aShape ) );
            aDstContainer->Add( new CROUNDSEGMENT2D( botRight3DU, botLeft3DU,
                                                     linewidth * m_biuTo3Dunits, *aShape ) );
            aDstContainer->Add( new CROUNDSEGMENT2D( botLeft3DU, topLeft3DU,
                                                     linewidth * m_biuTo3Dunits, *aShape ) );
        }
        break;

    case S_ARC:
    {
        unsigned int segCount = GetNrSegmentsCircle( 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 CFILLEDCIRCLE2D( start3DU, ( linewidth / 2 ) * m_biuTo3Dunits,
                                                     *aShape ) );
        }
        else
        {
            aDstContainer->Add( new CROUNDSEGMENT2D( start3DU, end3DU, linewidth * m_biuTo3Dunits,
                                                     *aShape ) );
        }
    }
    break;

    case S_CURVE:
    case S_POLYGON:
    {
        SHAPE_POLY_SET polyList;

        aShape->TransformShapeWithClearanceToPolygon( polyList, aLayerId, linewidth / 2,
                                                      ARC_HIGH_DEF, ERROR_INSIDE );

        polyList.Simplify( SHAPE_POLY_SET::PM_FAST );

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

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

    default:
        wxFAIL_MSG( "BOARD_ADAPTER::AddShapeWithClearanceToContainer no implementation for "
                    + PCB_SHAPE_TYPE_T_asString( aShape->GetShape() ) );
        break;
    }
}

References CGENERICCONTAINER2D::Add(), Convert_shape_line_polygon_to_triangles(), ERROR_INSIDE, PCB_SHAPE::GetAngle(), PCB_SHAPE::GetArcStart(), PCB_SHAPE::GetBoundingBox(), PCB_SHAPE::GetCenter(), PCB_SHAPE::GetEnd(), GetNrSegmentsCircle(), 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().

AddShapeWithClearanceToContainer() [3/3]

void BOARD_ADAPTER::AddShapeWithClearanceToContainer ( const DIMENSION_BASE *  aDimension, CGENERICCONTAINER2D *  aDstContainer, PCB_LAYER_ID  aLayerId, int  aClearanceValue  )

private

Definition at line 133 of file create_3Dgraphic_brd_items.cpp.

{
    AddShapeWithClearanceToContainer(&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 CROUNDSEGMENT2D( 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 CRING2D( center, ( radius - deltar ) * m_biuTo3Dunits,
                                             ( radius + deltar ) * m_biuTo3Dunits, *aDimension ) );

            break;
        }

        default:
            break;
        }

    }

}

References SEG::A, CGENERICCONTAINER2D::Add(), AddShapeWithClearanceToContainer(), SEG::B, DIMENSION_BASE::GetLineThickness(), DIMENSION_BASE::GetShapes(), m_biuTo3Dunits, SH_CIRCLE, SH_SEGMENT, DIMENSION_BASE::Text(), VECTOR2< T >::x, and VECTOR2< T >::y.

AddSolidAreasShapesToContainer()

void BOARD_ADAPTER::AddSolidAreasShapesToContainer ( const ZONE *  aZoneContainer, CGENERICCONTAINER2D *  aDstContainer, PCB_LAYER_ID  aLayerId  )

private

Definition at line 746 of file create_3Dgraphic_brd_items.cpp.

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

    // This convert the poly in outline and holes
    Convert_shape_line_polygon_to_triangles( 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 CFILLEDCIRCLE2D( start3DU, radius,
                                                             *aZoneContainer ) );
            }
            else
            {
                aDstContainer->Add( new CROUNDSEGMENT2D( 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 CFILLEDCIRCLE2D( start3DU, radius,
                                                                 *aZoneContainer ) );
                }
                else
                {
                    aDstContainer->Add( new CROUNDSEGMENT2D( start3DU, end3DU, line_thickness,
                                                             *aZoneContainer ) );
                }
            }
        }
    }
}

References CGENERICCONTAINER2D::Add(), SHAPE_POLY_SET::CHole(), Convert_shape_line_polygon_to_triangles(), 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().

AntiAliasingGet()

ANTIALIASING_MODE BOARD_ADAPTER::AntiAliasingGet ( ) const

inline

GridGet - get the current antialiasing mode value.

Returns

antialiasing mode value

Definition at line 260 of file board_adapter.h.

{ return m_antialiasing_mode; }

References m_antialiasing_mode.

Referenced by EDA_3D_VIEWER::SaveSettings(), and DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow().

AntiAliasingSet()

void BOARD_ADAPTER::AntiAliasingSet ( ANTIALIASING_MODE  aAAmode )

inline

AntiAliasingSet - set the current antialiasing mode value.

Parameters

aAAmode

= antialiasing mode value

Definition at line 266 of file board_adapter.h.

{ m_antialiasing_mode = aAAmode; }

References m_antialiasing_mode.

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

BiuTo3Dunits()

double BOARD_ADAPTER::BiuTo3Dunits ( ) const

inlinenoexcept

BiuTo3Dunits - Board integer units To 3D units.

Returns

the conversion factor to transform a position from the board to 3d units

Definition at line 155 of file board_adapter.h.

    {
        return m_biuTo3Dunits;
    }

References m_biuTo3Dunits.

Referenced by C3D_RENDER_OGL_LEGACY::createBoard(), createLayers(), C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads(), C3D_RENDER_OGL_LEGACY::generate_holes_display_list(), C3D_RENDER_OGL_LEGACY::generate_new_3DGrid(), C3D_RENDER_OGL_LEGACY::generateLayerListFromContainer(), C3D_RENDER_RAYTRACING::insert3DPadHole(), C3D_RENDER_RAYTRACING::insert3DViaHole(), C3D_RENDER_RAYTRACING::load_3D_models(), C3D_RENDER_RAYTRACING::Reload(), C3D_RENDER_OGL_LEGACY::render_3D_footprint(), and C3D_RENDER_RAYTRACING::setupMaterials().

buildPadShapeThickOutlineAsPolygon()

void BOARD_ADAPTER::buildPadShapeThickOutlineAsPolygon ( 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 SHAPE_LINE_CHAIN::CPoint(), ERROR_INSIDE, PAD::GetEffectivePolygon(), PAD::GetShape(), PAD::GetSize(), PAD_SHAPE_CIRCLE, SHAPE_LINE_CHAIN::PointCount(), PAD::ShapePos(), TransformOvalToPolygon(), and TransformRingToPolygon().

Referenced by createLayers().

buildPadShapeThickOutlineAsSegments()

void BOARD_ADAPTER::buildPadShapeThickOutlineAsSegments ( const PAD *  aPad, CGENERICCONTAINER2D *  aDstContainer, int  aWidth  )

private

Definition at line 825 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 CRING2D( 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 CFILLEDCIRCLE2D( start3DU, ( aWidth / 2 ) * m_biuTo3Dunits,
                                                     *aPad ) );
        }
        else
        {
            aDstContainer->Add( new CROUNDSEGMENT2D( start3DU, end3DU, aWidth * m_biuTo3Dunits,
                                                     *aPad ) );
        }
    }
}

References CGENERICCONTAINER2D::Add(), SHAPE_LINE_CHAIN::CPoint(), PAD::GetEffectivePolygon(), PAD::GetShape(), PAD::GetSize(), Is_segment_a_circle(), m_biuTo3Dunits, PAD_SHAPE_CIRCLE, SHAPE_LINE_CHAIN::PointCount(), 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;
        }

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

        // 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, 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 124 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_stats_nr_tracks               = 0;
    m_stats_track_med_width         = 0;
    m_stats_nr_vias                 = 0;
    m_stats_via_med_hole_diameter   = 0;
    m_stats_nr_holes                = 0;
    m_stats_hole_med_diameter       = 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_stats_nr_vias++;
            m_stats_via_med_hole_diameter += via->GetDrillValue() * m_biuTo3Dunits;
        }
        else
        {
            m_stats_nr_tracks++;
        }

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

    if( m_stats_nr_tracks )
        m_stats_track_med_width /= (float)m_stats_nr_tracks;

    if( m_stats_nr_vias )
        m_stats_via_med_hole_diameter /= (float)m_stats_nr_vias;

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

        CBVHCONTAINER2D *layerContainer = new CBVHCONTAINER2D;
        m_layers_container2D[curr_layer_id] = layerContainer;

        if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS )
                && ( m_render_engine == 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_F_Cu_PlatedPads_poly = new SHAPE_POLY_SET;
        m_B_Cu_PlatedPads_poly = new SHAPE_POLY_SET;

        m_platedpads_container2D_F_Cu = new CBVHCONTAINER2D;
        m_platedpads_container2D_B_Cu = new CBVHCONTAINER2D;

    }

    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_layers_container2D.find( curr_layer_id ) != m_layers_container2D.end() );

        CBVHCONTAINER2D *layerContainer = m_layers_container2D[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
            createNewTrack( 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         = GetCopperThickness3DU();
                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
                    // /////////////////////////////////////////////////////////

                    CBVHCONTAINER2D *layerHoleContainer = NULL;

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

                    // Add a hole for this layer
                    layerHoleContainer->Add( new CFILLEDCIRCLE2D( 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_through_holes_outer.Add( new CFILLEDCIRCLE2D( via_center,
                                                                    hole_inner_radius + thickness,
                                                                    *track ) );
                    m_through_holes_vias_outer.Add(
                                new CFILLEDCIRCLE2D( via_center,
                                                     hole_inner_radius + thickness,
                                                     *track ) );

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

                    m_through_holes_inner.Add( new CFILLEDCIRCLE2D( via_center,
                                                                    hole_inner_radius,
                                                                    *track ) );

                    //m_through_holes_vias_inner.Add( new CFILLEDCIRCLE2D( 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 contourns

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

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

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

                        layerInnerHolesPoly = new SHAPE_POLY_SET;
                        m_layers_inner_holes_poly[curr_layer_id] = layerInnerHolesPoly;
                    }
                    else
                    {
                        // found
                        layerOuterHolesPoly = m_layers_outer_holes_poly[curr_layer_id];

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

                        layerInnerHolesPoly = m_layers_inner_holes_poly[curr_layer_id];
                    }

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

                    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) + GetHolePlatingThicknessBIU();
                    const int hole_outer_ring_radius = via->GetWidth() / 2.0f;

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

                    // Add same thing for vias only

                    TransformCircleToPolygon( m_through_outer_holes_vias_poly, 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_through_outer_ring_holes_poly,
                                                  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_render_engine == 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 ) ?
                                GetHolePlatingThicknessBIU() : 0;

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

            m_through_holes_outer.Add( createNewPadDrill( pad, inflate ) );

            if( GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) &&
                GetFlag( FL_USE_REALISTIC_MODE ) )
            {
                m_through_holes_outer_ring.Add( createNewPadDrill( pad, inflate ) );
            }

            m_through_holes_inner.Add( createNewPadDrill( pad, 0 ) );
        }
    }

    if( m_stats_nr_holes )
        m_stats_hole_med_diameter /= (float)m_stats_nr_holes;

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

            if( pad->GetAttribute () != PAD_ATTRIB_NPTH )
            {
                if( GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) &&
                    GetFlag( FL_USE_REALISTIC_MODE ) )
                {
                    pad->TransformHoleWithClearanceToPolygon( m_through_outer_ring_holes_poly,
                                                              inflate,
                                                              ARC_HIGH_DEF, ERROR_INSIDE );
                }

                pad->TransformHoleWithClearanceToPolygon( m_through_outer_holes_poly, 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_through_outer_ring_holes_poly, 0,
                                                              ARC_HIGH_DEF, ERROR_INSIDE );
                }

                pad->TransformHoleWithClearanceToPolygon( m_through_outer_holes_poly_NPTH, 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_layers_container2D.find( curr_layer_id ) != m_layers_container2D.end() );

        CBVHCONTAINER2D *layerContainer = m_layers_container2D[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
            AddPadsWithClearanceToContainer( footprint, layerContainer, curr_layer_id, 0,
                                             true, renderPlatedPadsAsPlated, false );

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

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

            AddPadsWithClearanceToContainer( footprint, m_platedpads_container2D_B_Cu, B_Cu,
                                             0, true, false, true );
        }

        m_platedpads_container2D_F_Cu->BuildBVH();
        m_platedpads_container2D_B_Cu->BuildBVH();
    }

    // Add footprints PADs poly contourns (vertical outlines)
    if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS )
            && ( m_render_engine == 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 contourns
            for( FOOTPRINT* footprint : m_board->Footprints() )
            {
                footprint->TransformPadsWithClearanceToPolygon( *m_F_Cu_PlatedPads_poly, F_Cu,
                                                                0, ARC_HIGH_DEF, ERROR_INSIDE,
                                                                true, false, true );

                //transformFPShapesToPolygon( footprint, F_Cu, *m_F_Cu_PlatedPads_poly );

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

                //transformFPShapesToPolygon( footprint, B_Cu, *m_B_Cu_PlatedPads_poly );
            }
        }
    }


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

        CBVHCONTAINER2D *layerContainer = m_layers_container2D[curr_layer_id];

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

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

            case PCB_TEXT_T:
                AddShapeWithClearanceToContainer( 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:
                AddShapeWithClearanceToContainer( 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 contourns (vertical outlines)
    if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS )
            && ( m_render_engine == 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:
                case PCB_TEXT_T:
                    item->TransformShapeWithClearanceToPolygon( *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_layers_container2D.find( layer );

                    if( layerContainer != m_layers_container2D.end() )
                        AddSolidAreasShapesToContainer( 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_render_engine == 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_render_engine == RENDER_ENGINE::OPENGL_LEGACY ) )
    {
        if( GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) &&
            GetFlag( FL_USE_REALISTIC_MODE ) )
        {
            if( m_F_Cu_PlatedPads_poly && ( 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_F_Cu_PlatedPads_poly, SHAPE_POLY_SET::POLYGON_MODE::PM_FAST );

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

            if( m_B_Cu_PlatedPads_poly && ( 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_B_Cu_PlatedPads_poly, SHAPE_POLY_SET::POLYGON_MODE::PM_FAST );

                m_B_Cu_PlatedPads_poly->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_layers_outer_holes_poly.find( layer ) != m_layers_outer_holes_poly.end() )
        {
            // found
            SHAPE_POLY_SET *polyLayer = m_layers_outer_holes_poly[layer];
            polyLayer->Simplify( SHAPE_POLY_SET::PM_FAST );

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

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

    // End Build Copper layers

    // This will make a union of all added contourns
    m_through_outer_holes_poly.Simplify( SHAPE_POLY_SET::PM_FAST );
    m_through_outer_holes_poly_NPTH.Simplify( SHAPE_POLY_SET::PM_FAST );
    m_through_outer_holes_vias_poly.Simplify( SHAPE_POLY_SET::PM_FAST );
    m_through_outer_ring_holes_poly.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;

        CBVHCONTAINER2D *layerContainer = new CBVHCONTAINER2D;
        m_layers_container2D[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:
                AddShapeWithClearanceToContainer( (PCB_SHAPE*) item,
                                                  layerContainer,
                                                  curr_layer_id,
                                                  0 );
                break;

            case PCB_TEXT_T:
                AddShapeWithClearanceToContainer( (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:
                AddShapeWithClearanceToContainer( (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:
            case PCB_TEXT_T:
                item->TransformShapeWithClearanceToPolygon( *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 = g_DrawDefaultLineThickness;

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

                    buildPadShapeThickOutlineAsSegments( pad, layerContainer, linewidth );
                }
            }
            else
            {
                AddPadsWithClearanceToContainer( footprint, layerContainer, curr_layer_id, 0,
                                                 false, false, false );
            }

            AddFPShapesWithClearanceToContainer( 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) )
            {
                const int linewidth = g_DrawDefaultLineThickness;

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

                    buildPadShapeThickOutlineAsPolygon( 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 ) )
                    AddSolidAreasShapesToContainer( 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_through_holes_inner.BuildBVH();
    m_through_holes_outer.BuildBVH();
    m_through_holes_outer_ring.BuildBVH();

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

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

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

References _, CGENERICCONTAINER2D::Add(), AddFPShapesWithClearanceToContainer(), AddPadsWithClearanceToContainer(), AddShapeWithClearanceToContainer(), AddSolidAreasShapesToContainer(), LSET::AllCuMask(), LSET::AllNonCuMask(), arrayDim(), B_Adhes, B_Cu, B_Mask, B_Paste, B_SilkS, BiuTo3Dunits(), SHAPE_POLY_SET::BooleanSubtract(), CBVHCONTAINER2D::BuildBVH(), buildPadShapeThickOutlineAsPolygon(), buildPadShapeThickOutlineAsSegments(), Cmts_User, createNewPadDrill(), createNewTrack(), 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, VIA::FlashLayer(), BOARD::Footprints(), g_DrawDefaultLineThickness, GetCopperThickness3DU(), VIA::GetDrillValue(), GetFlag(), GetHolePlatingThicknessBIU(), GetRunningMicroSecs(), TRACK::GetStart(), VIA::GetViaType(), TRACK::GetWidth(), Is3DLayerEnabled(), IsCopperLayer(), BOARD_ITEM::IsOnLayer(), m_B_Cu_PlatedPads_poly, m_biuTo3Dunits, m_board, m_copperLayersCount, m_F_Cu_PlatedPads_poly, m_layers_container2D, m_layers_holes2D, m_layers_inner_holes_poly, m_layers_outer_holes_poly, m_layers_poly, m_logTrace, m_platedpads_container2D_B_Cu, m_platedpads_container2D_F_Cu, m_render_engine, m_stats_hole_med_diameter, m_stats_nr_holes, m_stats_nr_tracks, m_stats_nr_vias, m_stats_track_med_width, m_stats_via_med_hole_diameter, m_through_holes_inner, m_through_holes_outer, m_through_holes_outer_ring, m_through_holes_vias_outer, m_through_outer_holes_poly, m_through_outer_holes_poly_NPTH, m_through_outer_holes_vias_poly, m_through_outer_ring_holes_poly, Margin, MAX_CU_LAYERS, NULL, OPENGL_LEGACY, 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(), THROUGH, ToLAYER_ID(), BOARD::Tracks(), TransformCircleToPolygon(), transformFPShapesToPolygon(), TRACK::TransformShapeWithClearanceToPolygon(), EDA_ITEM::Type(), and BOARD::Zones().

Referenced by InitSettings().

createNewPadDrill()

COBJECT2D * BOARD_ADAPTER::createNewPadDrill ( const PAD *  aPad, int  aInflateValue  )

private

Definition at line 438 of file create_3Dgraphic_brd_items.cpp.

{
    wxSize drillSize = aPad->GetDrillSize();

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

    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 CFILLEDCIRCLE2D( 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 CROUNDSEGMENT2D( start3DU, end3DU, width * m_biuTo3Dunits, *aPad );
    }

    return NULL;
}

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

Referenced by createLayers().

createNewPadWithClearance()

void BOARD_ADAPTER::createNewPadWithClearance ( const PAD *  aPad, CGENERICCONTAINER2D *  aDstContainer, PCB_LAYER_ID  aLayer, wxSize  aClearanceValue  ) const

private

Definition at line 333 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 whiel 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 CFILLEDCIRCLE2D( start3DU,
                                                             ( width / 2) * m_biuTo3Dunits,
                                                             *aPad ) );
                }
                else
                {
                    aDstContainer->Add( new CROUNDSEGMENT2D( 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 CFILLEDCIRCLE2D( 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;

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

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

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

References SEG::A, CGENERICCONTAINER2D::Add(), SHAPE_POLY_SET::AddOutline(), SHAPE_POLY_SET::Append(), SEG::B, Convert_shape_line_polygon_to_triangles(), dummy(), ERROR_INSIDE, SHAPE_CIRCLE::GetCenter(), PAD::GetEffectiveShape(), SHAPE_RECT::GetPosition(), SHAPE_CIRCLE::GetRadius(), SHAPE_SEGMENT::GetSeg(), PAD::GetShape(), SHAPE_RECT::GetSize(), PAD::GetSize(), SHAPE_SEGMENT::GetWidth(), SHAPE_POLY_SET::Inflate(), Is_segment_a_circle(), SHAPE_POLY_SET::IsEmpty(), m_biuTo3Dunits, SHAPE_POLY_SET::NewOutline(), PAD_SHAPE_CUSTOM, SH_CIRCLE, SH_POLY_SET, SH_RECT, SH_SEGMENT, SH_SIMPLE, SHAPE_TYPE_asString(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by AddPadsWithClearanceToContainer().

createNewTrack()

void BOARD_ADAPTER::createNewTrack ( const TRACK *  aTrack, CGENERICCONTAINER2D *  aDstContainer, int  aClearanceValue  )

private

Definition at line 255 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 CFILLEDCIRCLE2D( 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 CFILLEDCIRCLE2D( start3DU, radius, *aTrack ) );
            }
            else
            {
                const float width = (aTrack->GetWidth() + 2 * aClearanceValue ) * m_biuTo3Dunits;

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

    default:
        break;
    }
}

References CGENERICCONTAINER2D::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 57 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_F_Cu_PlatedPads_poly;
    m_F_Cu_PlatedPads_poly = nullptr;

    delete m_B_Cu_PlatedPads_poly;
    m_B_Cu_PlatedPads_poly = nullptr;

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

        m_layers_inner_holes_poly.clear();
    }

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

        m_layers_outer_holes_poly.clear();
    }

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

        m_layers_container2D.clear();
    }

    delete m_platedpads_container2D_F_Cu;
    m_platedpads_container2D_F_Cu = nullptr;

    delete m_platedpads_container2D_B_Cu;
    m_platedpads_container2D_B_Cu = nullptr;

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

        m_layers_holes2D.clear();
    }

    m_through_holes_inner.Clear();
    m_through_holes_outer.Clear();
    m_through_holes_outer_ring.Clear();
    m_through_holes_vias_outer.Clear();
    m_through_holes_vias_inner.Clear();
    m_through_outer_holes_poly_NPTH.RemoveAllContours();
    m_through_outer_holes_poly.RemoveAllContours();

    m_through_outer_holes_vias_poly.RemoveAllContours();
    m_through_outer_ring_holes_poly.RemoveAllContours();
}

References CBVHCONTAINER2D::Clear(), m_B_Cu_PlatedPads_poly, m_F_Cu_PlatedPads_poly, m_layers_container2D, m_layers_holes2D, m_layers_inner_holes_poly, m_layers_outer_holes_poly, m_layers_poly, m_platedpads_container2D_B_Cu, m_platedpads_container2D_F_Cu, m_through_holes_inner, m_through_holes_outer, m_through_holes_outer_ring, m_through_holes_vias_inner, m_through_holes_vias_outer, m_through_outer_holes_poly, m_through_outer_holes_poly_NPTH, m_through_outer_holes_vias_poly, m_through_outer_ring_holes_poly, and SHAPE_POLY_SET::RemoveAllContours().

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

Get3DCacheManager()

S3D_CACHE* BOARD_ADAPTER::Get3DCacheManager ( ) const

inlinenoexcept

Get3DCacheManager - Return the 3d cache manager pointer.

Returns

Definition at line 89 of file board_adapter.h.

    {
        return m_3d_model_manager;
    }

References m_3d_model_manager.

Referenced by C3D_RENDER_OGL_LEGACY::load_3D_models(), and C3D_RENDER_RAYTRACING::load_3D_models().

GetBBox3DU()

const CBBOX& BOARD_ADAPTER::GetBBox3DU ( ) const

inlinenoexcept

GetBBox3DU - Get the bbox of the pcb board.

Returns

the board bbox in 3d units

Definition at line 164 of file board_adapter.h.

    {
        return m_boardBoundingBox;
    }

References m_boardBoundingBox.

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

GetBoard()

const BOARD* BOARD_ADAPTER::GetBoard ( ) const

inlinenoexcept

GetBoard - Get current board to be rendered.

Returns

BOARD pointer

Definition at line 133 of file board_adapter.h.

    {
        return m_board;
    }

References m_board.

Referenced by C3D_RENDER_RAYTRACING::add_3D_vias_and_pads_to_container(), C3D_RENDER_OGL_LEGACY::createBoard(), C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads(), C3D_RENDER_OGL_LEGACY::load_3D_models(), C3D_RENDER_RAYTRACING::load_3D_models(), C3D_RENDER_RAYTRACING::Reload(), and C3D_RENDER_OGL_LEGACY::render_3D_models_selected().

GetBoardCenter3DU()

const SFVEC3F& BOARD_ADAPTER::GetBoardCenter3DU ( ) const

inlinenoexcept

GetBoardCenter - the board center position in 3d units.

Returns

board center vector position in 3d units

Definition at line 224 of file board_adapter.h.

    {
        return m_boardCenter;
    }

References m_boardCenter.

Referenced by C3D_RENDER_RAYTRACING::Reload(), and C3D_RENDER_OGL_LEGACY::reload().

GetBoardPoly()

const SHAPE_POLY_SET& BOARD_ADAPTER::GetBoardPoly ( ) const

inlinenoexcept

GetBoardPoly - Get the current polygon of the epoxy board.

Returns

the shape polygon

Definition at line 308 of file board_adapter.h.

    {
        return m_board_poly;
    }

References m_board_poly.

Referenced by C3D_RENDER_RAYTRACING::Reload(), and C3D_RENDER_OGL_LEGACY::reload().

GetBoardPosBIU()

wxPoint BOARD_ADAPTER::GetBoardPosBIU ( ) const

inlinenoexcept

GetBoardPosBIU - Get the board center.

Returns

position in BIU units

Definition at line 215 of file board_adapter.h.

    {
        return m_boardPos;
    }

References m_boardPos.

Referenced by C3D_RENDER_OGL_LEGACY::generate_new_3DGrid().

GetBoardSizeBIU()

wxSize BOARD_ADAPTER::GetBoardSizeBIU ( ) const

inlinenoexcept

GetBoardSizeBIU - Get the board size.

Returns

size in BIU units

Definition at line 206 of file board_adapter.h.

    {
        return m_boardSize;
    }

References m_boardSize.

Referenced by C3D_RENDER_OGL_LEGACY::generate_new_3DGrid().

GetColor()

SFVEC4F BOARD_ADAPTER::GetColor

(

COLOR4D

aColor

)

const

GetColor.

Parameters

aColor

the color mapped

Returns

the color in SFVEC3F format

Definition at line 534 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 C3D_RENDER_OGL_LEGACY::generate_new_3DGrid(), GetItemColor(), and EDA_3D_VIEWER::LoadSettings().

GetCopperThickness3DU()

float BOARD_ADAPTER::GetCopperThickness3DU ( ) const

inlinenoexcept

GetCopperThickness3DU - Get the current copper layer thickness.

Returns

thickness in 3d units of copperlayers

Definition at line 191 of file board_adapter.h.

    {
        return m_copperThickness3DU;
    }

References m_copperThickness3DU.

Referenced by createLayers(), C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads(), C3D_RENDER_RAYTRACING::insert3DPadHole(), C3D_RENDER_RAYTRACING::insert3DViaHole(), and C3D_RENDER_RAYTRACING::Reload().

GetEpoxyThickness3DU()

float BOARD_ADAPTER::GetEpoxyThickness3DU ( ) const

inlinenoexcept

GetEpoxyThickness3DU - Get the current epoxy thickness.

Returns

thickness in 3d units

Definition at line 173 of file board_adapter.h.

    {
        return m_epoxyThickness3DU;
    }

References m_epoxyThickness3DU.

Referenced by C3D_RENDER_OGL_LEGACY::render_board_body().

GetFlag()

bool BOARD_ADAPTER::GetFlag

(

DISPLAY3D_FLG

aFlag

)

const

GetFlag - 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 226 of file board_adapter.cpp.

{
    wxASSERT( aFlag < FL_LAST );

    return m_drawFlags[aFlag];
}

References FL_LAST, and m_drawFlags.

Referenced by C3D_RENDER_RAYTRACING::createItemsFromContainer(), createLayers(), EDA_3D_CONDITIONS::flagFunction(), C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads(), C3D_RENDER_RAYTRACING::get_3D_model_material(), C3D_RENDER_OGL_LEGACY::get_layer_color(), GetModulesZcoord3DIU(), InitSettings(), C3D_RENDER_RAYTRACING::insert3DPadHole(), C3D_RENDER_RAYTRACING::insert3DViaHole(), Is3DLayerEnabled(), C3D_RENDER_OGL_LEGACY::load_3D_models(), EDA_3D_CANVAS::OnMouseWheel(), C3D_RENDER_OGL_LEGACY::Redraw(), C3D_RENDER_RAYTRACING::Reload(), C3D_RENDER_OGL_LEGACY::reload(), C3D_RENDER_OGL_LEGACY::render_3D_footprint(), C3D_RENDER_OGL_LEGACY::render_3D_models(), C3D_RENDER_OGL_LEGACY::render_3D_models_selected(), C3D_RENDER_RAYTRACING::rt_render_post_process_blur_finish(), C3D_RENDER_RAYTRACING::rt_render_post_process_shade(), C3D_RENDER_RAYTRACING::rt_render_trace_block(), C3D_RENDER_RAYTRACING::rt_render_tracing(), C3D_RENDER_RAYTRACING::rt_trace_AA_packet(), C3D_RENDER_OGL_LEGACY::set_layer_material(), C3D_RENDER_RAYTRACING::setupMaterials(), C3D_RENDER_OGL_LEGACY::setupMaterials(), C3D_RENDER_RAYTRACING::shadeHit(), ShouldFPBeDisplayed(), EDA_3D_CONTROLLER::ToggleVisibility(), and DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow().

GetHolePlatingThicknessBIU()

int BOARD_ADAPTER::GetHolePlatingThicknessBIU ( ) const

noexcept

GetCopperThicknessBIU - Get the current copper layer thickness.

Returns

thickness in board units

Definition at line 256 of file board_adapter.cpp.

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

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

Referenced by createLayers(), C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads(), C3D_RENDER_RAYTRACING::insert3DPadHole(), and C3D_RENDER_RAYTRACING::insert3DViaHole().

GetItemColor()

SFVEC4F BOARD_ADAPTER::GetItemColor

(

int

aItemId

)

const

GetItemColor - 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 528 of file board_adapter.cpp.

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

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

Referenced by C3D_RENDER_RAYTRACING::insert3DPadHole(), and C3D_RENDER_RAYTRACING::insert3DViaHole().

GetLayerBottomZpos3DU()

float BOARD_ADAPTER::GetLayerBottomZpos3DU ( PCB_LAYER_ID  aLayerId ) const

inlinenoexcept

GetLayerBottomZpos3DU - Get the bottom z position.

Parameters

aLayerId

layer id

Returns

position in 3D units

Definition at line 349 of file board_adapter.h.

    {
        return m_layerZcoordBottom[aLayerId];
    }

References m_layerZcoordBottom.

Referenced by C3D_RENDER_RAYTRACING::createItemsFromContainer(), C3D_RENDER_OGL_LEGACY::get_layer_z_pos(), C3D_RENDER_RAYTRACING::insert3DPadHole(), C3D_RENDER_RAYTRACING::insert3DViaHole(), C3D_RENDER_OGL_LEGACY::Redraw(), and C3D_RENDER_RAYTRACING::Reload().

GetLayerColor()

SFVEC4F BOARD_ADAPTER::GetLayerColor

(

PCB_LAYER_ID

aLayerId

)

const

GetLayerColor - 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 518 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 C3D_RENDER_OGL_LEGACY::get_layer_color(), and C3D_RENDER_RAYTRACING::Reload().

GetLayerTopZpos3DU()

float BOARD_ADAPTER::GetLayerTopZpos3DU ( PCB_LAYER_ID  aLayerId ) const

inlinenoexcept

GetLayerTopZpos3DU - Get the top z position.

Parameters

aLayerId

layer id

Returns

position in 3D units

Definition at line 339 of file board_adapter.h.

    {
        return m_layerZcoordTop[aLayerId];
    }

References m_layerZcoordTop.

Referenced by C3D_RENDER_RAYTRACING::createItemsFromContainer(), C3D_RENDER_OGL_LEGACY::get_layer_z_pos(), C3D_RENDER_OGL_LEGACY::Redraw(), and C3D_RENDER_RAYTRACING::Reload().

GetMapLayers()

const MAP_CONTAINER_2D& BOARD_ADAPTER::GetMapLayers ( ) const

inlinenoexcept

GetMapLayers - Get the map of container that have the objects per layer.

Returns

the map containers of this board

Definition at line 358 of file board_adapter.h.

    {
        return m_layers_container2D;
    }

References m_layers_container2D.

Referenced by C3D_RENDER_RAYTRACING::createItemsFromContainer(), C3D_RENDER_RAYTRACING::Reload(), and C3D_RENDER_OGL_LEGACY::reload().

GetMapLayersHoles()

const MAP_CONTAINER_2D& BOARD_ADAPTER::GetMapLayersHoles ( ) const

inlinenoexcept

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

Returns

the map containers of holes from this board

Definition at line 377 of file board_adapter.h.

    {
        return m_layers_holes2D;
    }

References m_layers_holes2D.

Referenced by C3D_RENDER_RAYTRACING::createItemsFromContainer(), and C3D_RENDER_OGL_LEGACY::reload().

GetModulesZcoord3DIU()

float BOARD_ADAPTER::GetModulesZcoord3DIU

(

bool

aIsFlipped

)

const

GetModulesZcoord3DIU - 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 499 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 C3D_RENDER_RAYTRACING::load_3D_models(), and C3D_RENDER_OGL_LEGACY::render_3D_footprint().

GetNonCopperLayerThickness3DU()

float BOARD_ADAPTER::GetNonCopperLayerThickness3DU ( ) const

inlinenoexcept

GetNonCopperLayerThickness3DU - Get the current non copper layers thickness.

Returns

thickness in 3d units of non copperlayers

Definition at line 182 of file board_adapter.h.

    {
        return m_nonCopperLayerThickness3DU;
    }

References m_nonCopperLayerThickness3DU.

Referenced by C3D_RENDER_OGL_LEGACY::render_solder_mask_layer(), and C3D_RENDER_RAYTRACING::shadeHit().

GetNrSegmentsCircle() [1/2]

unsigned int BOARD_ADAPTER::GetNrSegmentsCircle

(

float

aDiameter3DU

)

const

GetNrSegmentsCircle.

Parameters

aDiameter3DU

diameter in 3DU

Returns

number of sides that should be used in that circle

Definition at line 261 of file board_adapter.cpp.

{
    wxASSERT( aDiameter3DU > 0.0f );

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

References m_biuTo3Dunits.

Referenced by C3D_RENDER_OGL_LEGACY::add_object_to_triangle_layer(), AddShapeWithClearanceToContainer(), and C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads().

GetNrSegmentsCircle() [2/2]

unsigned int BOARD_ADAPTER::GetNrSegmentsCircle

(

int

aDiameterBIU

)

const

GetNrSegmentsCircle.

Parameters

aDiameterBIU

diameter in board internal units

Returns

number of sides that should be used in that circle

Definition at line 269 of file board_adapter.cpp.

{
    wxASSERT( aDiameterBIU > 0 );

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

References GetArcToSegmentCount().

GetPlatedPads_Back()

const CBVHCONTAINER2D* BOARD_ADAPTER::GetPlatedPads_Back ( ) const

inlinenoexcept

Definition at line 368 of file board_adapter.h.

    {
        return m_platedpads_container2D_B_Cu;
    }

References m_platedpads_container2D_B_Cu.

Referenced by C3D_RENDER_RAYTRACING::Reload(), and C3D_RENDER_OGL_LEGACY::reload().

GetPlatedPads_Front()

const CBVHCONTAINER2D* BOARD_ADAPTER::GetPlatedPads_Front ( ) const

inlinenoexcept

Definition at line 363 of file board_adapter.h.

    {
        return m_platedpads_container2D_F_Cu;
    }

References m_platedpads_container2D_F_Cu.

Referenced by C3D_RENDER_RAYTRACING::Reload(), and C3D_RENDER_OGL_LEGACY::reload().

GetPolyMap()

const MAP_POLY& BOARD_ADAPTER::GetPolyMap ( ) const

inlinenoexcept

GetPolyMap - Get maps of polygons's layers.

Returns

the map with polygons's layers

Definition at line 502 of file board_adapter.h.

    {
        return m_layers_poly;
    }

References m_layers_poly.

Referenced by C3D_RENDER_OGL_LEGACY::reload().

GetPolyMapHoles_Inner()

const MAP_POLY& BOARD_ADAPTER::GetPolyMapHoles_Inner ( ) const

inlinenoexcept

Definition at line 517 of file board_adapter.h.

    {
        return m_layers_inner_holes_poly;
    }

References m_layers_inner_holes_poly.

Referenced by C3D_RENDER_OGL_LEGACY::reload().

GetPolyMapHoles_Outer()

const MAP_POLY& BOARD_ADAPTER::GetPolyMapHoles_Outer ( ) const

inlinenoexcept

Definition at line 522 of file board_adapter.h.

    {
        return m_layers_outer_holes_poly;
    }

References m_layers_outer_holes_poly.

Referenced by C3D_RENDER_OGL_LEGACY::reload().

GetPolyPlatedPads_Back()

const SHAPE_POLY_SET* BOARD_ADAPTER::GetPolyPlatedPads_Back ( )

inline

Definition at line 512 of file board_adapter.h.

    {
        return m_B_Cu_PlatedPads_poly;
    }

References m_B_Cu_PlatedPads_poly.

Referenced by C3D_RENDER_OGL_LEGACY::reload().

GetPolyPlatedPads_Front()

const SHAPE_POLY_SET* BOARD_ADAPTER::GetPolyPlatedPads_Front ( )

inline

Definition at line 507 of file board_adapter.h.

    {
        return m_F_Cu_PlatedPads_poly;
    }

References m_F_Cu_PlatedPads_poly.

Referenced by C3D_RENDER_OGL_LEGACY::reload().

GetStats_Med_Hole_Diameter3DU()

float BOARD_ADAPTER::GetStats_Med_Hole_Diameter3DU ( ) const

inlinenoexcept

GetStats_Med_Hole_Diameter3DU - Average diameter of holes.

Returns

dimension in 3D units

Definition at line 470 of file board_adapter.h.

    {
        return m_stats_hole_med_diameter;
    }

References m_stats_hole_med_diameter.

Referenced by C3D_RENDER_RAYTRACING::Reload().

GetStats_Med_Track_Width()

float BOARD_ADAPTER::GetStats_Med_Track_Width ( ) const

inlinenoexcept

GetStats_Med_Track_Width - Average width of the tracks.

Returns

dimensions in 3D units

Definition at line 479 of file board_adapter.h.

    {
        return m_stats_track_med_width;
    }

References m_stats_track_med_width.

GetStats_Med_Via_Hole_Diameter3DU()

float BOARD_ADAPTER::GetStats_Med_Via_Hole_Diameter3DU ( ) const

inlinenoexcept

GetStats_Med_Via_Hole_Diameter3DU - Average diameter of the via holes.

Returns

dimension in 3D units

Definition at line 461 of file board_adapter.h.

    {
        return m_stats_via_med_hole_diameter;
    }

References m_stats_via_med_hole_diameter.

Referenced by C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads(), and C3D_RENDER_RAYTRACING::Reload().

GetStats_Nr_Holes()

unsigned int BOARD_ADAPTER::GetStats_Nr_Holes ( ) const

inlinenoexcept

GetStats_Nr_Holes - Get statistics of the nr of holes.

Returns

number of holes

Definition at line 452 of file board_adapter.h.

    {
        return m_stats_nr_holes;
    }

References m_stats_nr_holes.

Referenced by C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads(), and C3D_RENDER_RAYTRACING::Reload().

GetStats_Nr_Vias()

unsigned int BOARD_ADAPTER::GetStats_Nr_Vias ( ) const

inlinenoexcept

GetStats_Nr_Vias - Get statistics of the nr of vias.

Returns

number of vias

Definition at line 443 of file board_adapter.h.

    {
        return m_stats_nr_vias;
    }

References m_stats_nr_vias.

Referenced by C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads(), and C3D_RENDER_RAYTRACING::Reload().

GetThroughHole_Inner()

const CBVHCONTAINER2D& BOARD_ADAPTER::GetThroughHole_Inner ( ) const

inlinenoexcept

GetThroughHole_Inner - Get the ThroughHole container.

Returns

a container with holes

Definition at line 434 of file board_adapter.h.

    {
        return m_through_holes_inner;
    }

References m_through_holes_inner.

Referenced by C3D_RENDER_RAYTRACING::insert3DPadHole(), and C3D_RENDER_OGL_LEGACY::reload().

GetThroughHole_Outer()

const CBVHCONTAINER2D& BOARD_ADAPTER::GetThroughHole_Outer ( ) const

inlinenoexcept

GetThroughHole_Outer - Get the inflated ThroughHole container.

Returns

a container with holes

Definition at line 386 of file board_adapter.h.

    {
        return m_through_holes_outer;
    }

References m_through_holes_outer.

Referenced by C3D_RENDER_RAYTRACING::createItemsFromContainer(), C3D_RENDER_RAYTRACING::Reload(), and C3D_RENDER_OGL_LEGACY::reload().

GetThroughHole_Outer_poly()

const SHAPE_POLY_SET& BOARD_ADAPTER::GetThroughHole_Outer_poly ( ) const

inlinenoexcept

Definition at line 401 of file board_adapter.h.

    {
        return m_through_outer_holes_poly;
    }

References m_through_outer_holes_poly.

Referenced by C3D_RENDER_OGL_LEGACY::reload().

GetThroughHole_Outer_poly_NPTH()

const SHAPE_POLY_SET& BOARD_ADAPTER::GetThroughHole_Outer_poly_NPTH ( ) const

inlinenoexcept

Definition at line 411 of file board_adapter.h.

    {
        return m_through_outer_holes_poly_NPTH;
    }

References m_through_outer_holes_poly_NPTH.

Referenced by C3D_RENDER_OGL_LEGACY::reload().

GetThroughHole_Outer_Ring()

const CBVHCONTAINER2D& BOARD_ADAPTER::GetThroughHole_Outer_Ring ( ) const

inlinenoexcept

GetThroughHole_Outer_Ring - Get the ThroughHole container that include the width of the annular ring.

Returns

a container with holes.

Definition at line 396 of file board_adapter.h.

    {
        return m_through_holes_outer_ring;
    }

References m_through_holes_outer_ring.

Referenced by C3D_RENDER_RAYTRACING::createItemsFromContainer(), and C3D_RENDER_OGL_LEGACY::reload().

GetThroughHole_Outer_Ring_poly()

const SHAPE_POLY_SET& BOARD_ADAPTER::GetThroughHole_Outer_Ring_poly ( ) const

inlinenoexcept

Definition at line 406 of file board_adapter.h.

    {
        return m_through_outer_ring_holes_poly;
    }

References m_through_outer_ring_holes_poly.

Referenced by C3D_RENDER_OGL_LEGACY::reload().

GetThroughHole_Vias_Outer()

const CBVHCONTAINER2D& BOARD_ADAPTER::GetThroughHole_Vias_Outer ( ) const

inlinenoexcept

GetThroughHole_Vias_Outer -.

Returns

a container with via THT holes only

Definition at line 420 of file board_adapter.h.

    {
        return m_through_holes_vias_outer;
    }

References m_through_holes_vias_outer.

Referenced by C3D_RENDER_OGL_LEGACY::reload().

GetThroughHole_Vias_Outer_poly()

const SHAPE_POLY_SET& BOARD_ADAPTER::GetThroughHole_Vias_Outer_poly ( ) const

inlinenoexcept

Definition at line 425 of file board_adapter.h.

    {
        return m_through_outer_holes_vias_poly;
    }

References m_through_outer_holes_vias_poly.

Referenced by C3D_RENDER_OGL_LEGACY::reload().

GridGet()

GRID3D_TYPE BOARD_ADAPTER::GridGet ( ) const

inlinenoexcept

GridGet - get the current grid.

Returns

space type of the grid

Definition at line 242 of file board_adapter.h.

    {
        return m_3D_grid_type;
    }

References m_3D_grid_type.

Referenced by EDA_3D_CONDITIONS::gridSizeFunction(), C3D_RENDER_OGL_LEGACY::Redraw(), and EDA_3D_VIEWER::SaveSettings().

GridSet()

void BOARD_ADAPTER::GridSet ( GRID3D_TYPE  aGridType )

inlinenoexcept

GridSet - set the current grid.

Parameters

aGridType

= the type space of the grid

Definition at line 251 of file board_adapter.h.

    {
        m_3D_grid_type = aGridType;
    }

References m_3D_grid_type.

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

InitSettings()

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

InitSettings - 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 277 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 convertion 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;

    // 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:
        case B_Paste:
            zposBottom = zpos_copperTop_back;
            zposTop    = zpos_copperTop_back - m_nonCopperLayerThickness3DU;
            break;

        case F_Mask:
        case F_Paste:
            zposTop    = zpos_copperTop_front + m_nonCopperLayerThickness3DU;
            zposBottom = zpos_copperTop_front;
            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 = CBBOX( 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, MAX_CU_LAYERS, Millimeter2iu(), PCB_LAYER_ID_COUNT, RANGE_SCALE_3D, REPORTER::Report(), RPT_SEVERITY_WARNING, and TECH_LAYER_THICKNESS.

Referenced by C3D_RENDER_RAYTRACING::Reload(), and C3D_RENDER_OGL_LEGACY::reload().

Is3DLayerEnabled()

bool BOARD_ADAPTER::Is3DLayerEnabled

(

PCB_LAYER_ID

aLayer

)

const

Is3DLayerEnabled - 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 );

    DISPLAY3D_FLG flg;

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

    case B_Paste:
    case F_Paste:
        flg = FL_SOLDERPASTE;
        break;

    case B_SilkS:
    case F_SilkS:
        flg = FL_SILKSCREEN;
        break;

    case B_Mask:
    case F_Mask:
        flg = FL_SOLDERMASK;
        break;

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

        flg = FL_COMMENTS;
        break;

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

        flg = FL_ECO;
        break;

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

        return true;
        break;

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

        return true;
        break;

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

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

    // The layer has a flag, return the flag
    return GetFlag( flg );
}

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::IsLayerVisible(), m_board, Margin, and PCB_LAYER_ID_COUNT.

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

MaterialModeGet()

MATERIAL_MODE BOARD_ADAPTER::MaterialModeGet ( ) const

inlinenoexcept

MaterialModeGet.

Returns

material rendering mode

Definition at line 299 of file board_adapter.h.

    {
        return m_material_mode;
    }

References m_material_mode.

Referenced by C3D_RENDER_RAYTRACING::add_3D_models(), C3D_RENDER_RAYTRACING::get_3D_model_material(), C3D_RENDER_OGL_LEGACY::load_3D_models(), EDA_3D_CONDITIONS::materialModeFunction(), and EDA_3D_VIEWER::SaveSettings().

MaterialModeSet()

void BOARD_ADAPTER::MaterialModeSet ( MATERIAL_MODE  aMaterialMode )

inlinenoexcept

MaterialModeSet.

Parameters

aMaterialMode

= the render material mode

Definition at line 290 of file board_adapter.h.

    {
        m_material_mode = aMaterialMode;
    }

References m_material_mode.

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

RenderEngineGet()

RENDER_ENGINE BOARD_ADAPTER::RenderEngineGet ( ) const

inlinenoexcept

RenderEngineGet.

Returns

render engine on use

Definition at line 281 of file board_adapter.h.

    {
        return m_render_engine;
    }

References m_render_engine.

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

RenderEngineSet()

void BOARD_ADAPTER::RenderEngineSet ( RENDER_ENGINE  aRenderEngine )

inlinenoexcept

RenderEngineSet.

Parameters

aRenderEngine

= the render engine mode selected

Definition at line 272 of file board_adapter.h.

    {
        m_render_engine = aRenderEngine;
    }

References m_render_engine.

Referenced by EDA_3D_CANVAS::DoRePaint(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::OnDisableRayTracing(), and EDA_3D_VIEWER::OnRenderEngineSelection().

Set3DCacheManager()

void BOARD_ADAPTER::Set3DCacheManager ( S3D_CACHE *  aCachePointer )

inlinenoexcept

Set3DCacheManager - Update the Cache manager pointer.

Parameters

aCachePointer

the pointer to the 3d cache manager

Definition at line 80 of file board_adapter.h.

    {
        m_3d_model_manager = aCachePointer;
    }

References m_3d_model_manager.

Referenced by EDA_3D_CANVAS::ReloadRequest().

SetBoard()

void BOARD_ADAPTER::SetBoard ( BOARD *  aBoard )

inlinenoexcept

SetBoard - Set current board to be rendered.

Parameters

aBoard

board to process

Definition at line 124 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 138 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
	)

SetFlag - set the status of a flag.

Parameters

aFlag	the flag to get the status
aState	status to set

Definition at line 234 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().

ShouldFPBeDisplayed()

bool BOARD_ADAPTER::ShouldFPBeDisplayed

(

FOOTPRINT_ATTR_T

aFPAttributes

)

const

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

Definition at line 241 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 C3D_RENDER_RAYTRACING::load_3D_models(), and C3D_RENDER_OGL_LEGACY::render_3D_models_selected().

TransformArcToSegments()

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

private

Definition at line 551 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 CFILLEDCIRCLE2D( start3DU, ( aWidth / 2 ) * m_biuTo3Dunits,
                                                     aBoardItem ) );
        }
        else
        {
            aDstContainer->Add( new CROUNDSEGMENT2D( 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 CFILLEDCIRCLE2D( start3DU,
                                                     ( aWidth / 2 ) * m_biuTo3Dunits,
                                                     aBoardItem ) );
        }
        else
        {
            aDstContainer->Add( new CROUNDSEGMENT2D( start3DU,
                                                     end3DU,
                                                     aWidth * m_biuTo3Dunits,
                                                     aBoardItem ) );
        }
    }
}

References CGENERICCONTAINER2D::Add(), Is_segment_a_circle(), m_biuTo3Dunits, and RotatePoint().

Referenced by AddShapeWithClearanceToContainer(), and createNewTrack().

transformFPShapesToPolygon()

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

private

Definition at line 63 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_3D_grid_type

GRID3D_TYPE BOARD_ADAPTER::m_3D_grid_type

private

Definition at line 629 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), GridGet(), and GridSet().

m_3d_model_manager

S3D_CACHE* BOARD_ADAPTER::m_3d_model_manager

private

Definition at line 623 of file board_adapter.h.

Referenced by Get3DCacheManager(), and Set3DCacheManager().

m_antialiasing_mode

ANTIALIASING_MODE BOARD_ADAPTER::m_antialiasing_mode

private

Definition at line 632 of file board_adapter.h.

Referenced by AntiAliasingGet(), AntiAliasingSet(), and BOARD_ADAPTER().

m_B_Cu_PlatedPads_poly

SHAPE_POLY_SET* BOARD_ADAPTER::m_B_Cu_PlatedPads_poly

private

Definition at line 656 of file board_adapter.h.

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

m_BgColorBot

SFVEC4F BOARD_ADAPTER::m_BgColorBot

background bottom color

Definition at line 587 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::Process_Special_Functions(), C3D_RENDER_OGL_LEGACY::Redraw(), C3D_RENDER_RAYTRACING::Redraw(), C3D_RENDER_RAYTRACING::render(), C3D_RENDER_RAYTRACING::render_preview(), and EDA_3D_VIEWER::SaveSettings().

m_BgColorTop

SFVEC4F BOARD_ADAPTER::m_BgColorTop

background top color

Definition at line 588 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), EDA_3D_VIEWER::Process_Special_Functions(), C3D_RENDER_OGL_LEGACY::Redraw(), C3D_RENDER_RAYTRACING::Redraw(), C3D_RENDER_RAYTRACING::Reload(), C3D_RENDER_RAYTRACING::render(), C3D_RENDER_RAYTRACING::render_preview(), EDA_3D_VIEWER::SaveSettings(), and C3D_RENDER_RAYTRACING::setupMaterials().

m_biuTo3Dunits

double BOARD_ADAPTER::m_biuTo3Dunits

private

Normalization scale to convert board internal units to 3D units to normalize 3D units between -1.0 and +1.0.

Definition at line 719 of file board_adapter.h.

Referenced by AddFPShapesWithClearanceToContainer(), AddShapeWithClearanceToContainer(), AddSolidAreasShapesToContainer(), BiuTo3Dunits(), BOARD_ADAPTER(), buildPadShapeThickOutlineAsSegments(), createLayers(), createNewPadDrill(), createNewPadWithClearance(), createNewTrack(), GetNrSegmentsCircle(), InitSettings(), and TransformArcToSegments().

m_board

BOARD* BOARD_ADAPTER::m_board

private

Definition at line 622 of file board_adapter.h.

Referenced by createBoardPolygon(), createLayers(), GetBoard(), GetHolePlatingThicknessBIU(), InitSettings(), Is3DLayerEnabled(), and SetBoard().

m_board_poly

SHAPE_POLY_SET BOARD_ADAPTER::m_board_poly

private

PCB board outline polygon.

Definition at line 677 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 589 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), EDA_3D_VIEWER::LoadSettings(), C3D_RENDER_OGL_LEGACY::Redraw(), C3D_RENDER_RAYTRACING::Reload(), C3D_RENDER_OGL_LEGACY::render_board_body(), EDA_3D_VIEWER::SaveSettings(), EDA_3D_VIEWER::Set3DBoardBodyColorFromUser(), and C3D_RENDER_RAYTRACING::setupMaterials().

m_boardBoundingBox

CBBOX BOARD_ADAPTER::m_boardBoundingBox

private

3d bounding box of the pcb board in 3d units

Definition at line 650 of file board_adapter.h.

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

m_boardCenter

SFVEC3F BOARD_ADAPTER::m_boardCenter

private

3d center position of the pcb board in 3d units

Definition at line 644 of file board_adapter.h.

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

m_boardPos

wxPoint BOARD_ADAPTER::m_boardPos

private

center board actual position in board units

Definition at line 638 of file board_adapter.h.

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

m_boardSize

wxSize BOARD_ADAPTER::m_boardSize

private

board actual size in board units

Definition at line 641 of file board_adapter.h.

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

m_calc_seg_max_factor3DU

float BOARD_ADAPTER::m_calc_seg_max_factor3DU

private

max factor used for cicle segment approximation calculation

Definition at line 740 of file board_adapter.h.

Referenced by BOARD_ADAPTER().

m_calc_seg_min_factor3DU

float BOARD_ADAPTER::m_calc_seg_min_factor3DU

private

min factor used for cicle segment approximation calculation

Definition at line 737 of file board_adapter.h.

Referenced by BOARD_ADAPTER().

m_colors

COLOR_SETTINGS* BOARD_ADAPTER::m_colors

private

Definition at line 624 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 595 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), C3D_RENDER_OGL_LEGACY::get_layer_color(), C3D_RENDER_RAYTRACING::insert3DPadHole(), C3D_RENDER_RAYTRACING::insert3DViaHole(), EDA_3D_VIEWER::LoadSettings(), C3D_RENDER_RAYTRACING::Reload(), EDA_3D_VIEWER::SaveSettings(), EDA_3D_VIEWER::Set3DCopperColorFromUser(), C3D_RENDER_RAYTRACING::setupMaterials(), and C3D_RENDER_OGL_LEGACY::setupMaterials().

m_copperLayersCount

unsigned int BOARD_ADAPTER::m_copperLayersCount

private

Number of copper layers actually used by the board.

Definition at line 715 of file board_adapter.h.

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

m_copperThickness3DU

float BOARD_ADAPTER::m_copperThickness3DU

private

Copper thickness (normalized)

Definition at line 728 of file board_adapter.h.

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

m_drawFlags

std::vector< bool > BOARD_ADAPTER::m_drawFlags

private

Definition at line 628 of file board_adapter.h.

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

m_epoxyThickness3DU

float BOARD_ADAPTER::m_epoxyThickness3DU

private

Epoxy thickness (normalized)

Definition at line 731 of file board_adapter.h.

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

m_F_Cu_PlatedPads_poly

SHAPE_POLY_SET* BOARD_ADAPTER::m_F_Cu_PlatedPads_poly

private

Definition at line 655 of file board_adapter.h.

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

m_layers_container2D

MAP_CONTAINER_2D BOARD_ADAPTER::m_layers_container2D

private

It contains the 2d elements of each layer.

Definition at line 683 of file board_adapter.h.

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

m_layers_holes2D

MAP_CONTAINER_2D BOARD_ADAPTER::m_layers_holes2D

private

It contains the holes per each layer.

Definition at line 689 of file board_adapter.h.

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

m_layers_inner_holes_poly

MAP_POLY BOARD_ADAPTER::m_layers_inner_holes_poly

private

It contains polygon contours for holes of each layer (inner holes)

Definition at line 662 of file board_adapter.h.

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

m_layers_outer_holes_poly

MAP_POLY BOARD_ADAPTER::m_layers_outer_holes_poly

private

It contains polygon contours for holes of each layer (outer holes)

Definition at line 659 of file board_adapter.h.

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

m_layers_poly

MAP_POLY BOARD_ADAPTER::m_layers_poly

private

It contains polygon contours for each layer.

Definition at line 653 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

Bottom (Start) Z position of each layer (normalized)

Definition at line 725 of file board_adapter.h.

Referenced by GetLayerBottomZpos3DU(), GetModulesZcoord3DIU(), and InitSettings().

m_layerZcoordTop

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

private

Top (End) Z position of each layer (normalized)

Definition at line 722 of file board_adapter.h.

Referenced by GetLayerTopZpos3DU(), GetModulesZcoord3DIU(), and InitSettings().

m_logTrace

const wxChar * BOARD_ADAPTER::m_logTrace = wxT( "KI_TRACE_EDA_CINFO3D_VISU" )

staticprivate

Trace mask used to enable or disable the trace output of this class.

The debug output can be turned on by setting the WXTRACE environment variable to "KI_TRACE_EDA_CINFO3D_VISU". See the wxWidgets documentation on wxLogTrace for more information.

Definition at line 769 of file board_adapter.h.

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

m_material_mode

MATERIAL_MODE BOARD_ADAPTER::m_material_mode

private

Definition at line 631 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), MaterialModeGet(), and MaterialModeSet().

m_nonCopperLayerThickness3DU

float BOARD_ADAPTER::m_nonCopperLayerThickness3DU

private

Non copper layers thickness.

Definition at line 734 of file board_adapter.h.

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

m_opengl_selectionColor

SFVEC3F BOARD_ADAPTER::m_opengl_selectionColor

Definition at line 597 of file board_adapter.h.

Referenced by EDA_3D_VIEWER::LoadSettings(), C3D_RENDER_OGL_LEGACY::render_3D_footprint(), EDA_3D_VIEWER::SaveSettings(), DIALOG_3D_VIEW_OPTIONS::TransferColorDataToWindow(), and DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow().

m_platedpads_container2D_B_Cu

CBVHCONTAINER2D* BOARD_ADAPTER::m_platedpads_container2D_B_Cu

private

Definition at line 686 of file board_adapter.h.

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

m_platedpads_container2D_F_Cu

CBVHCONTAINER2D* BOARD_ADAPTER::m_platedpads_container2D_F_Cu

private

Definition at line 685 of file board_adapter.h.

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

m_raytrace_lightColor

std::vector<SFVEC3F> BOARD_ADAPTER::m_raytrace_lightColor

Definition at line 605 of file board_adapter.h.

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

m_raytrace_lightColorBottom

SFVEC3F BOARD_ADAPTER::m_raytrace_lightColorBottom

Definition at line 603 of file board_adapter.h.

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

m_raytrace_lightColorCamera

SFVEC3F BOARD_ADAPTER::m_raytrace_lightColorCamera

Definition at line 601 of file board_adapter.h.

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

m_raytrace_lightColorTop

SFVEC3F BOARD_ADAPTER::m_raytrace_lightColorTop

Definition at line 602 of file board_adapter.h.

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

m_raytrace_lightSphericalCoords

std::vector<SFVEC2F> BOARD_ADAPTER::m_raytrace_lightSphericalCoords

Definition at line 606 of file board_adapter.h.

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

m_raytrace_nrsamples_reflections

int BOARD_ADAPTER::m_raytrace_nrsamples_reflections

Definition at line 610 of file board_adapter.h.

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

m_raytrace_nrsamples_refractions

int BOARD_ADAPTER::m_raytrace_nrsamples_refractions

Definition at line 611 of file board_adapter.h.

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

m_raytrace_nrsamples_shadows

int BOARD_ADAPTER::m_raytrace_nrsamples_shadows

Definition at line 609 of file board_adapter.h.

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

m_raytrace_recursivelevel_reflections

int BOARD_ADAPTER::m_raytrace_recursivelevel_reflections

Definition at line 617 of file board_adapter.h.

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

m_raytrace_recursivelevel_refractions

int BOARD_ADAPTER::m_raytrace_recursivelevel_refractions

Definition at line 618 of file board_adapter.h.

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

m_raytrace_spread_reflections

float BOARD_ADAPTER::m_raytrace_spread_reflections

Definition at line 614 of file board_adapter.h.

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

m_raytrace_spread_refractions

float BOARD_ADAPTER::m_raytrace_spread_refractions

Definition at line 615 of file board_adapter.h.

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

m_raytrace_spread_shadows

float BOARD_ADAPTER::m_raytrace_spread_shadows

Definition at line 613 of file board_adapter.h.

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

m_render_engine

RENDER_ENGINE BOARD_ADAPTER::m_render_engine

private

Definition at line 630 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), createLayers(), RenderEngineGet(), and RenderEngineSet().

m_SilkScreenColorBot

SFVEC4F BOARD_ADAPTER::m_SilkScreenColorBot

in realistic mode: SilkScreen color ( bot )

Definition at line 593 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), C3D_RENDER_OGL_LEGACY::get_layer_color(), EDA_3D_VIEWER::LoadSettings(), C3D_RENDER_RAYTRACING::Reload(), EDA_3D_VIEWER::SaveSettings(), EDA_3D_VIEWER::Set3DSilkScreenColorFromUser(), C3D_RENDER_OGL_LEGACY::setupMaterials(), and EDA_3D_VIEWER::SynchroniseColoursWithBoard().

m_SilkScreenColorTop

SFVEC4F BOARD_ADAPTER::m_SilkScreenColorTop

in realistic mode: SilkScreen color ( top )

Definition at line 594 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), C3D_RENDER_OGL_LEGACY::get_layer_color(), EDA_3D_VIEWER::LoadSettings(), C3D_RENDER_RAYTRACING::Reload(), EDA_3D_VIEWER::SaveSettings(), EDA_3D_VIEWER::Set3DSilkScreenColorFromUser(), C3D_RENDER_RAYTRACING::setupMaterials(), C3D_RENDER_OGL_LEGACY::setupMaterials(), and EDA_3D_VIEWER::SynchroniseColoursWithBoard().

m_SolderMaskColorBot

SFVEC4F BOARD_ADAPTER::m_SolderMaskColorBot

in realistic mode: solder mask color ( bot )

Definition at line 590 of file board_adapter.h.

Referenced by BOARD_ADAPTER(), C3D_RENDER_OGL_LEGACY::get_layer_color(), EDA_3D_VIEWER::LoadSettings(), C3D_RENDER_RAYTRACING::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