allegro_builder.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright Quilter
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <functional>
#include <memory>
#include <optional>
#include <unordered_map>
#include <utility>
#include <vector>
#include <unordered_set>
 
#include <convert/allegro_pcb_structs.h>
#include <convert/allegro_db.h>
 
#include <board.h>
#include <geometry/shape_line_chain.h>
#include <reporter.h>
#include <progress_reporter.h>
#include <pcb_io/common/plugin_common_layer_mapping.h>
 
 
class BOARD;
class FOOTPRINT;
class NETINFO_ITEM;
class PCB_TEXT;
 
namespace ALLEGRO
{
 
class LAYER_MAPPER;

class BOARD_BUILDER
{
public:
    BOARD_BUILDER( const BRD_DB& aBrdDb, BOARD& aBoard, REPORTER& aReporter,
                   PROGRESS_REPORTER* aProgressReporter,
                   const LAYER_MAPPING_HANDLER& aLayerMappingHandler );
    ~BOARD_BUILDER();
 
    bool BuildBoard();
 
private:
    VECTOR2I scale( const VECTOR2I& aVector ) const;
    VECTOR2I scaleSize( const VECTOR2I& aSize ) const;
    int scale( int aVal ) const;

    template <ALLEGRO_BLOCK_DATA T>
    const T* expectBlockByKey( uint32_t aKey ) const
    {
        // The type code trait
        constexpr uint8_t kType = T::BLOCK_TYPE_CODE;
 
        if( aKey == 0 )
            return nullptr;
 
        const BLOCK_BASE* block = m_brdDb.GetObjectByKey( aKey );
 
        if( !block )
        {
            reportMissingBlock( aKey, kType );
            return nullptr;
        }
 
        if( block->GetBlockType() != kType )
        {
            reportUnexpectedBlockType( block->GetBlockType(), kType, aKey, block->GetOffset() );
            return nullptr;
        }
 
        return &static_cast<const BLOCK<T>&>( *block ).GetData();
    }
 
    void reportMissingBlock( uint32_t aKey, uint8_t aType ) const;
    void reportUnexpectedBlockType( uint8_t aGot, uint8_t aExpected, uint32_t aKey = 0, size_t aOffset = 0,
                                    const wxString& aName = wxEmptyString ) const;
 
    PCB_LAYER_ID getLayer( const LAYER_INFO& aLayerInfo ) const;

    wxString get0x30StringValue( uint32_t a0x30Key ) const;

    std::unique_ptr<PCB_SHAPE> buildLineSegment( const BLK_0x15_16_17_SEGMENT& aSegment, const LAYER_INFO& aLayerInfo,
                                                 PCB_LAYER_ID aLayer, BOARD_ITEM_CONTAINER& aParent );
 
    std::unique_ptr<PCB_SHAPE> buildArc( const BLK_0x01_ARC& aArc, const LAYER_INFO& aLayerInfo, PCB_LAYER_ID aLayer,
                                         BOARD_ITEM_CONTAINER& aParent );

    std::vector<std::unique_ptr<PCB_SHAPE>> buildShapes( const BLK_0x14_GRAPHIC& aGraphicList, BOARD_ITEM_CONTAINER& aParent );
    std::unique_ptr<PCB_TEXT>  buildPcbText( const BLK_0x30_STR_WRAPPER& aStrWrapper, BOARD_ITEM_CONTAINER& aParent );

    std::unique_ptr<PCB_SHAPE> buildRect( const BLK_0x24_RECT& aRect, BOARD_ITEM_CONTAINER& aParent );

    std::unique_ptr<PCB_SHAPE> buildRect( const BLK_0x0E_RECT& aShape, BOARD_ITEM_CONTAINER& aParent );
 

    std::unique_ptr<PCB_SHAPE> buildPolygon( const BLK_0x28_SHAPE& aShape, BOARD_ITEM_CONTAINER& aParent );

    std::vector<std::unique_ptr<PCB_SHAPE>> buildPolygonShapes( const BLK_0x28_SHAPE& aShape,
                                                                BOARD_ITEM_CONTAINER& aParent );

    std::vector<std::unique_ptr<BOARD_ITEM>> buildDrillMarker( const BLK_0x0C_PIN_DEF& aPinDef,
                                                               BOARD_ITEM_CONTAINER&   aParent );

    std::vector<std::unique_ptr<BOARD_ITEM>> buildGraphicItems( const BLOCK_BASE&     aBlock,
                                                                BOARD_ITEM_CONTAINER& aParent );

    std::vector<std::unique_ptr<BOARD_ITEM>> buildPadItems( const BLK_0x1C_PADSTACK& aPadstack, FOOTPRINT& aFp,
                                                            const wxString& aPadName, int aNetcode );
    std::unique_ptr<FOOTPRINT>               buildFootprint( const BLK_0x2D_FOOTPRINT_INST& aFpInstance );
    std::vector<std::unique_ptr<BOARD_ITEM>> buildTrack( const BLK_0x05_TRACK& aBlock, int aNetcode );
    std::unique_ptr<BOARD_ITEM>              buildVia( const BLK_0x33_VIA& aBlock, int aNetcode );

    std::optional<std::pair<int, int>> resolveViaSpan( const BLK_0x1C_PADSTACK& aPadstack,
                                                       const VECTOR2I& aViaCenterRaw, int aTotalCu,
                                                       bool& aResolved );

    void collectTrackEndpointCopper();
 
    class ZONE_FILL_HANDLER;

    std::unique_ptr<ZONE> buildZone( const BLOCK_BASE&                     aBoundaryBlock,
                                     const std::vector<const BLOCK_BASE*>& aRelatedBlocks,
                                     ZONE_FILL_HANDLER&                    aZoneFillHandler );
 
    SHAPE_LINE_CHAIN buildOutline( const BLK_0x0E_RECT& aRect ) const;
    SHAPE_LINE_CHAIN buildOutline( const BLK_0x24_RECT& aRect ) const;
    SHAPE_LINE_CHAIN buildOutline( const BLK_0x28_SHAPE& aShape ) const;
 
    SHAPE_POLY_SET shapeToPolySet( const BLK_0x28_SHAPE& aShape ) const;

    SHAPE_POLY_SET tryBuildZoneShape( const BLOCK_BASE& aBlock );

    const SHAPE_LINE_CHAIN& buildSegmentChain( uint32_t aStartKey ) const;

    std::vector<const BLOCK_BASE*> getShapeRelatedBlocks( const BLK_0x28_SHAPE& aShape ) const;

    wxString resolveMatchGroupName( const BLK_0x1B_NET& aNet ) const;

    wxString resolveConstraintSetNameFromField( uint32_t aFieldKey ) const;
 
    void cacheFontDefs();
    void setupLayers();
    void createNets();
    void createTracks();
    void createBoardShapes();
    void createBoardText();
    void createZones();
    void createTables();
    void applyZoneFills();
    void enablePadTeardrops();
    void applyConstraintSets();
    void applyNetConstraints();
    void applyMatchGroups();

    const BLK_0x36_DEF_TABLE::FontDef_X08* getFontDef( unsigned aIndex ) const;

    const BLK_0x07_COMPONENT_INST* getFpInstRef( const BLK_0x2D_FOOTPRINT_INST& aFpInstance ) const;
 
    const BRD_DB&         m_brdDb;
    BOARD&                m_board;
    REPORTER&             m_reporter;
    PROGRESS_REPORTER*    m_progressReporter;
    LAYER_MAPPING_HANDLER m_layerMappingHandler;
 
    // Cached list of font defs in the 0x36 node
    std::vector<const BLK_0x36_DEF_TABLE::FontDef_X08*> m_fontDefList;
 
    // Cached list of KiCad nets corresponding to Allegro 0x1B NET keys
    std::unordered_map<uint32_t, NETINFO_ITEM*> m_netCache;
 
    struct ZoneFillEntry
    {
        const BLK_0x28_SHAPE* shape;
        int                   netCode;
        PCB_LAYER_ID          layer;
    };
 
    std::unordered_map<uint32_t, ZoneFillEntry> m_zoneFillShapes;
 
    // Keys that have been used as zone fills already
    std::unordered_set<uint32_t> m_usedZoneFillShapes;
 
    std::unique_ptr<LAYER_MAPPER> m_layerMapper;
 
    // Cache of computed outlines keyed by shape block key, avoiding redundant geometry rebuilds
    mutable std::unordered_map<uint32_t, SHAPE_LINE_CHAIN> m_outlineCache;
 
    // Cache of segment chains keyed by start key, avoiding redundant hole geometry rebuilds
    mutable std::unordered_map<uint32_t, SHAPE_LINE_CHAIN> m_segChainCache;
 
    // Resolved copper span (0-based) per via padstack key, or nullopt for a through via.
    std::unordered_map<uint32_t, std::optional<std::pair<int, int>>> m_viaSpanCache;
 
    // Packed track segment endpoint -> [min,max] copper layer index of tracks ending there.
    std::unordered_map<int64_t, std::pair<int, int>> m_trackEndpointCopper;
 
    // True once m_trackEndpointCopper has been populated.
    bool m_trackEndpointsCollected = false;
 
    // Conversion factor from internal units to nanometers.
    double m_scale;
};
 
} // namespace ALLEGRO