export_vrml.cpp File Reference

#include <exception>
#include <fstream>
#include <iomanip>
#include <vector>
#include <wx/dir.h>
#include "3d_cache/3d_cache.h"
#include "3d_cache/3d_info.h"
#include "board.h"
#include "fp_shape.h"
#include "footprint.h"
#include "pcb_text.h"
#include "track.h"
#include "zone.h"
#include "convert_to_biu.h"
#include <core/arraydim.h>
#include <filename_resolver.h>
#include "plugins/3dapi/ifsg_all.h"
#include "streamwrapper.h"
#include "vrml_layer.h"
#include "pcb_edit_frame.h"
#include <bezier_curves.h>
#include <convert_basic_shapes_to_polygon.h>
#include <geometry/geometry_utils.h>
#include <zone_filler.h>

Go to the source code of this file.

Classes
struct	VRML_COLOR
class	MODEL_VRML

Macros
#define	MIN_VRML_LINEWIDTH   0.05
#define	ART_OFFSET   0.025
#define	PLATE_OFFSET   0.005

Enumerations
enum	VRML_COLOR_INDEX {   VRML_COLOR_NONE = -1, VRML_COLOR_PCB = 0, VRML_COLOR_TRACK, VRML_COLOR_SILK,   VRML_COLOR_TIN, VRML_COLOR_LAST }

Functions
static bool	GetLayer (MODEL_VRML &aModel, LAYER_NUM layer, VRML_LAYER **vlayer)
static void	create_vrml_shell (IFSG_TRANSFORM &PcbOutput, VRML_COLOR_INDEX colorID, VRML_LAYER *layer, double top_z, double bottom_z)
static void	create_vrml_plane (IFSG_TRANSFORM &PcbOutput, VRML_COLOR_INDEX colorID, VRML_LAYER *layer, double aHeight, bool aTopPlane)
static void	write_triangle_bag (std::ostream &aOut_file, const VRML_COLOR &aColor, VRML_LAYER *aLayer, bool aPlane, bool aTop, double aTop_z, double aBottom_z)
static void	write_layers (MODEL_VRML &aModel, BOARD *aPcb, const char *aFileName, OSTREAM *aOutputFile)
static void	compute_layer_Zs (MODEL_VRML &aModel, BOARD *pcb)
static void	export_vrml_line (MODEL_VRML &aModel, LAYER_NUM layer, double startx, double starty, double endx, double endy, double width)
static void	export_vrml_circle (MODEL_VRML &aModel, LAYER_NUM layer, double startx, double starty, double endx, double endy, double width)
static void	export_vrml_arc (MODEL_VRML &aModel, LAYER_NUM layer, double centerx, double centery, double arc_startx, double arc_starty, double width, double arc_angle)
static void	export_vrml_polygon (MODEL_VRML &aModel, LAYER_NUM layer, PCB_SHAPE *aOutline, double aOrientation, wxPoint aPos)
static void	export_vrml_drawsegment (MODEL_VRML &aModel, PCB_SHAPE *drawseg)
static void	vrml_text_callback (int x0, int y0, int xf, int yf, void *aData)
static void	export_vrml_pcbtext (MODEL_VRML &aModel, PCB_TEXT *text)
static void	export_vrml_drawings (MODEL_VRML &aModel, BOARD *pcb)
static void	export_vrml_board (MODEL_VRML &aModel, BOARD *aPcb)
static void	export_round_padstack (MODEL_VRML &aModel, BOARD *pcb, double x, double y, double r, LAYER_NUM bottom_layer, LAYER_NUM top_layer, double hole)
static void	export_vrml_via (MODEL_VRML &aModel, BOARD *aPcb, const VIA *aVia)
static void	export_vrml_tracks (MODEL_VRML &aModel, BOARD *pcb)
static void	export_vrml_zones (MODEL_VRML &aModel, BOARD *aPcb, COMMIT *aCommit)
static void	export_vrml_fp_text (FP_TEXT *item)
static void	export_vrml_fp_shape (MODEL_VRML &aModel, FP_SHAPE *aOutline, FOOTPRINT *aFootprint)
static void	export_vrml_padshape (MODEL_VRML &aModel, VRML_LAYER *aTinLayer, PAD *aPad)
static void	export_vrml_pad (MODEL_VRML &aModel, BOARD *aPcb, PAD *aPad)
static void	build_quat (double x, double y, double z, double a, double q[4])
static void	from_quat (double q[4], double rot[4])
static void	compose_quat (double q1[4], double q2[4], double qr[4])
static void	export_vrml_footprint (MODEL_VRML &aModel, BOARD *aPcb, FOOTPRINT *aFootprint, std::ostream *aOutputFile)
static SGNODE *	getSGColor (VRML_COLOR_INDEX colorIdx)

Variables
static S3D_CACHE *	cache
static bool	USE_INLINES
static bool	USE_DEFS
static bool	USE_RELPATH
static double	WORLD_SCALE = 1.0
static double	BOARD_SCALE
static const int	PRECISION = 6
static wxString	SUBDIR_3D
static wxString	PROJ_DIR
static VRML_COLOR	colors [VRML_COLOR_LAST]
static SGNODE *	sgmaterial [VRML_COLOR_LAST] = { NULL }
static MODEL_VRML *	model_vrml

Macro Definition Documentation

ART_OFFSET

#define ART_OFFSET   0.025

Definition at line 58 of file export_vrml.cpp.

MIN_VRML_LINEWIDTH

#define MIN_VRML_LINEWIDTH   0.05

Definition at line 55 of file export_vrml.cpp.

PLATE_OFFSET

#define PLATE_OFFSET   0.005

Definition at line 60 of file export_vrml.cpp.

Enumeration Type Documentation

VRML_COLOR_INDEX

enum VRML_COLOR_INDEX

Enumerator
VRML_COLOR_NONE
VRML_COLOR_PCB
VRML_COLOR_TRACK
VRML_COLOR_SILK
VRML_COLOR_TIN
VRML_COLOR_LAST

Definition at line 129 of file export_vrml.cpp.

{
    VRML_COLOR_NONE = -1,
    VRML_COLOR_PCB = 0,
    VRML_COLOR_TRACK,
    VRML_COLOR_SILK,
    VRML_COLOR_TIN,
    VRML_COLOR_LAST
};

Function Documentation

build_quat()

static void build_quat ( double  x, double  y, double  z, double  a, double  q[4]  )

static

Definition at line 1374 of file export_vrml.cpp.

{
    double sina = sin( a / 2 );

    q[0] = x * sina;
    q[1] = y * sina;
    q[2] = z * sina;
    q[3] = cos( a / 2 );
}

Referenced by export_vrml_footprint().

compose_quat()

static void compose_quat ( double  q1[4], double  q2[4], double  qr[4]  )

static

Definition at line 1396 of file export_vrml.cpp.

{
    double tmp[4];

    tmp[0] = q2[3] * q1[0] + q2[0] * q1[3] + q2[1] * q1[2] - q2[2] * q1[1];
    tmp[1] = q2[3] * q1[1] + q2[1] * q1[3] + q2[2] * q1[0] - q2[0] * q1[2];
    tmp[2] = q2[3] * q1[2] + q2[2] * q1[3] + q2[0] * q1[1] - q2[1] * q1[0];
    tmp[3] = q2[3] * q1[3] - q2[0] * q1[0] - q2[1] * q1[1] - q2[2] * q1[2];

    qr[0] = tmp[0];
    qr[1] = tmp[1];
    qr[2] = tmp[2];
    qr[3] = tmp[3];
}

Referenced by export_vrml_footprint().

compute_layer_Zs()

static void compute_layer_Zs ( MODEL_VRML &  aModel, BOARD *  pcb  )

static

Definition at line 550 of file export_vrml.cpp.

{
    int copper_layers = pcb->GetCopperLayerCount();

    // We call it 'layer' thickness, but it's the whole board thickness!
    aModel.m_brd_thickness = pcb->GetDesignSettings().GetBoardThickness() * BOARD_SCALE;
    double half_thickness = aModel.m_brd_thickness / 2;

    // Compute each layer's Z value, more or less like the 3d view
    for( LSEQ seq = LSET::AllCuMask().Seq();  seq;  ++seq )
    {
        PCB_LAYER_ID i = *seq;

        if( i < copper_layers )
            aModel.SetLayerZ( i,  half_thickness - aModel.m_brd_thickness * i / (copper_layers - 1) );
        else
            aModel.SetLayerZ( i, - half_thickness );  // bottom layer
    }

    /* To avoid rounding interference, we apply an epsilon to each
     * successive layer */
    double epsilon_z = Millimeter2iu( ART_OFFSET ) * BOARD_SCALE;
    aModel.SetLayerZ( B_Paste, -half_thickness - epsilon_z * 4 );
    aModel.SetLayerZ( B_Adhes, -half_thickness - epsilon_z * 3 );
    aModel.SetLayerZ( B_SilkS, -half_thickness - epsilon_z * 2 );
    aModel.SetLayerZ( B_Mask, -half_thickness - epsilon_z );
    aModel.SetLayerZ( F_Mask, half_thickness + epsilon_z );
    aModel.SetLayerZ( F_SilkS, half_thickness + epsilon_z * 2 );
    aModel.SetLayerZ( F_Adhes, half_thickness + epsilon_z * 3 );
    aModel.SetLayerZ( F_Paste, half_thickness + epsilon_z * 4 );
    aModel.SetLayerZ( Dwgs_User, half_thickness + epsilon_z * 5 );
    aModel.SetLayerZ( Cmts_User, half_thickness + epsilon_z * 6 );
    aModel.SetLayerZ( Eco1_User, half_thickness + epsilon_z * 7 );
    aModel.SetLayerZ( Eco2_User, half_thickness + epsilon_z * 8 );
    aModel.SetLayerZ( Edge_Cuts, 0 );
}

References LSET::AllCuMask(), ART_OFFSET, B_Adhes, B_Mask, B_Paste, B_SilkS, BOARD_SCALE, Cmts_User, Dwgs_User, Eco1_User, Eco2_User, Edge_Cuts, F_Adhes, F_Mask, F_Paste, F_SilkS, BOARD_DESIGN_SETTINGS::GetBoardThickness(), BOARD::GetCopperLayerCount(), BOARD::GetDesignSettings(), MODEL_VRML::m_brd_thickness, Millimeter2iu(), and MODEL_VRML::SetLayerZ().

Referenced by PCB_EDIT_FRAME::ExportVRML_File().

create_vrml_plane()

static void create_vrml_plane ( IFSG_TRANSFORM &  PcbOutput, VRML_COLOR_INDEX  colorID, VRML_LAYER *  layer, double  aHeight, bool  aTopPlane  )

static

Definition at line 1768 of file export_vrml.cpp.

{
    std::vector< double > vertices;
    std::vector< int > idxPlane;

    if( !( *layer ).Get2DTriangles( vertices, idxPlane, top_z, aTopPlane ) )
    {
        return;
    }

    if( ( idxPlane.size() % 3 ) )
    {
        throw( std::runtime_error( "[BUG] index lists are not a multiple of 3 (not a triangle list)" ) );
    }

    std::vector< SGPOINT > vlist;
    size_t nvert = vertices.size() / 3;
    size_t j = 0;

    for( size_t i = 0; i < nvert; ++i, j+= 3 )
        vlist.emplace_back( vertices[j], vertices[j+1], vertices[j+2] );

    // create the intermediate scenegraph
    IFSG_TRANSFORM tx0( PcbOutput.GetRawPtr() );    // tx0 = Transform for this outline
    IFSG_SHAPE shape( tx0 );            // shape will hold (a) all vertices and (b) a local list of normals
    IFSG_FACESET face( shape );         // this face shall represent the top and bottom planes
    IFSG_COORDS cp( face );             // coordinates for all faces
    cp.SetCoordsList( nvert, &vlist[0] );
    IFSG_COORDINDEX coordIdx( face );   // coordinate indices for top and bottom planes only
    coordIdx.SetIndices( idxPlane.size(), &idxPlane[0] );
    IFSG_NORMALS norms( face );         // normals for the top and bottom planes

    // set the normals
    if( aTopPlane )
    {
        for( size_t i = 0; i < nvert; ++i )
            norms.AddNormal( 0.0, 0.0, 1.0 );
    }
    else
    {
        for( size_t i = 0; i < nvert; ++i )
            norms.AddNormal( 0.0, 0.0, -1.0 );
    }

    // assign a color from the palette
    SGNODE* modelColor = getSGColor( colorID );

    if( NULL != modelColor )
    {
        if( NULL == S3D::GetSGNodeParent( modelColor ) )
            shape.AddChildNode( modelColor );
        else
            shape.AddRefNode( modelColor );
    }
}

References IFSG_NORMALS::AddNormal(), IFSG_NODE::GetRawPtr(), getSGColor(), S3D::GetSGNodeParent(), NULL, IFSG_COORDS::SetCoordsList(), and IFSG_INDEX::SetIndices().

Referenced by write_layers().

create_vrml_shell()

static void create_vrml_shell ( IFSG_TRANSFORM &  PcbOutput, VRML_COLOR_INDEX  colorID, VRML_LAYER *  layer, double  top_z, double  bottom_z  )

static

Definition at line 1826 of file export_vrml.cpp.

{
    std::vector< double > vertices;
    std::vector< int > idxPlane;
    std::vector< int > idxSide;

    if( top_z < bottom_z )
    {
        double tmp = top_z;
        top_z = bottom_z;
        bottom_z = tmp;
    }

    if( !( *layer ).Get3DTriangles( vertices, idxPlane, idxSide, top_z, bottom_z )
            || idxPlane.empty() || idxSide.empty() )
    {
        return;
    }

    if( ( idxPlane.size() % 3 ) || ( idxSide.size() % 3 ) )
    {
        throw( std::runtime_error( "[BUG] index lists are not a multiple of 3 (not a "
                                   "triangle list)" ) );
    }

    std::vector< SGPOINT > vlist;
    size_t nvert = vertices.size() / 3;
    size_t j = 0;

    for( size_t i = 0; i < nvert; ++i, j+= 3 )
        vlist.emplace_back( vertices[j], vertices[j+1], vertices[j+2] );

    // create the intermediate scenegraph
    IFSG_TRANSFORM tx0( PcbOutput.GetRawPtr() );    // tx0 = Transform for this outline
    IFSG_SHAPE shape( tx0 );            // shape will hold (a) all vertices and (b) a local list of normals
    IFSG_FACESET face( shape );         // this face shall represent the top and bottom planes
    IFSG_COORDS cp( face );             // coordinates for all faces
    cp.SetCoordsList( nvert, &vlist[0] );
    IFSG_COORDINDEX coordIdx( face );   // coordinate indices for top and bottom planes only
    coordIdx.SetIndices( idxPlane.size(), &idxPlane[0] );
    IFSG_NORMALS norms( face );         // normals for the top and bottom planes

    // number of TOP (and bottom) vertices
    j = nvert / 2;

    // set the TOP normals
    for( size_t i = 0; i < j; ++i )
        norms.AddNormal( 0.0, 0.0, 1.0 );

    // set the BOTTOM normals
    for( size_t i = 0; i < j; ++i )
        norms.AddNormal( 0.0, 0.0, -1.0 );

    // assign a color from the palette
    SGNODE* modelColor = getSGColor( colorID );

    if( NULL != modelColor )
    {
        if( NULL == S3D::GetSGNodeParent( modelColor ) )
            shape.AddChildNode( modelColor );
        else
            shape.AddRefNode( modelColor );
    }

    // create a second shape describing the vertical walls of the extrusion
    // using per-vertex-per-face-normals
    shape.NewNode( tx0 );
    shape.AddRefNode( modelColor );    // set the color to be the same as the top/bottom
    face.NewNode( shape );
    cp.NewNode( face );               // new vertex list
    norms.NewNode( face );            // new normals list
    coordIdx.NewNode( face );         // new index list

    // populate the new per-face vertex list and its indices and normals
    std::vector< int >::iterator sI = idxSide.begin();
    std::vector< int >::iterator eI = idxSide.end();

    size_t sidx = 0;    // index to the new coord set
    SGPOINT p1, p2, p3;
    SGVECTOR vnorm;

    while( sI != eI )
    {
        p1 = vlist[*sI];
        cp.AddCoord( p1 );
        ++sI;

        p2 = vlist[*sI];
        cp.AddCoord( p2 );
        ++sI;

        p3 = vlist[*sI];
        cp.AddCoord( p3 );
        ++sI;

        vnorm.SetVector( S3D::CalcTriNorm( p1, p2, p3 ) );
        norms.AddNormal( vnorm );
        norms.AddNormal( vnorm );
        norms.AddNormal( vnorm );

        coordIdx.AddIndex( (int)sidx );
        ++sidx;
        coordIdx.AddIndex( (int)sidx );
        ++sidx;
        coordIdx.AddIndex( (int)sidx );
        ++sidx;
    }
}

References IFSG_COORDS::AddCoord(), IFSG_INDEX::AddIndex(), IFSG_NORMALS::AddNormal(), S3D::CalcTriNorm(), IFSG_NODE::GetRawPtr(), getSGColor(), S3D::GetSGNodeParent(), IFSG_COORDS::NewNode(), IFSG_COORDINDEX::NewNode(), IFSG_FACESET::NewNode(), IFSG_NORMALS::NewNode(), NULL, IFSG_COORDS::SetCoordsList(), IFSG_INDEX::SetIndices(), and SGVECTOR::SetVector().

Referenced by write_layers().

export_round_padstack()

static void export_round_padstack ( MODEL_VRML &  aModel, BOARD *  pcb, double  x, double  y, double  r, LAYER_NUM  bottom_layer, LAYER_NUM  top_layer, double  hole  )

static

Definition at line 910 of file export_vrml.cpp.

{
    LAYER_NUM   layer = top_layer;
    bool        thru = true;

    // if not a thru hole do not put a hole in the board
    if( top_layer != F_Cu || bottom_layer != B_Cu )
        thru = false;

    if( thru && hole > 0 )
        aModel.m_holes.AddCircle( x, -y, hole, true );

    if( aModel.m_plainPCB )
        return;

    while( true )
    {
        if( layer == B_Cu )
        {
            aModel.m_bot_copper.AddCircle( x, -y, r );

            if( hole > 0 && !thru )
                aModel.m_bot_copper.AddCircle( x, -y, hole, true );

        }
        else if( layer == F_Cu )
        {
            aModel.m_top_copper.AddCircle( x, -y, r );

            if( hole > 0 && !thru )
                aModel.m_top_copper.AddCircle( x, -y, hole, true );

        }

        if( layer == bottom_layer )
            break;

        layer = bottom_layer;
    }
}

References B_Cu, F_Cu, MODEL_VRML::m_bot_copper, MODEL_VRML::m_holes, MODEL_VRML::m_plainPCB, and MODEL_VRML::m_top_copper.

Referenced by export_vrml_via().

export_vrml_arc()

static void export_vrml_arc ( MODEL_VRML &  aModel, LAYER_NUM  layer, double  centerx, double  centery, double  arc_startx, double  arc_starty, double  width, double  arc_angle  )

static

Definition at line 644 of file export_vrml.cpp.

{
    VRML_LAYER* vlayer;

    if( !GetLayer( aModel, layer, &vlayer ) )
        return;

    if( width < aModel.m_minLineWidth )
        width = aModel.m_minLineWidth;

    centery = -centery;
    arc_starty = -arc_starty;

    if( !vlayer->AddArc( centerx, centery, arc_startx, arc_starty, width, -arc_angle, false ) )
        throw( std::runtime_error( vlayer->GetError() ) );

}

References GetLayer(), and MODEL_VRML::m_minLineWidth.

Referenced by export_vrml_drawsegment(), export_vrml_fp_shape(), and export_vrml_tracks().

export_vrml_board()

static void export_vrml_board ( MODEL_VRML &  aModel, BOARD *  aPcb  )

static

Definition at line 859 of file export_vrml.cpp.

{
    SHAPE_POLY_SET  pcbOutlines;      // stores the board main outlines

    if( !aPcb->GetBoardPolygonOutlines( pcbOutlines ) )
    {
        wxLogWarning( _( "Board outline is malformed. Run DRC for a full analysis." ) );
    }

    int seg;

    for( int cnt = 0; cnt < pcbOutlines.OutlineCount(); cnt++ )
    {
        const SHAPE_LINE_CHAIN& outline = pcbOutlines.COutline( cnt );

        seg = aModel.m_board.NewContour();

        for( int j = 0; j < outline.PointCount(); j++ )
        {
            aModel.m_board.AddVertex( seg, (double)outline.CPoint(j).x * BOARD_SCALE,
                                        -((double)outline.CPoint(j).y * BOARD_SCALE ) );

        }

        aModel.m_board.EnsureWinding( seg, false );

        // Generate holes:
        for( int ii = 0; ii < pcbOutlines.HoleCount( cnt ); ii++ )
        {
            const SHAPE_LINE_CHAIN& hole = pcbOutlines.Hole( cnt, ii );

            seg = aModel.m_holes.NewContour();

            if( seg < 0 )
            {
                wxLogError( _( "VRML Export Failed: Could not add holes to contours." ) );
                return;
            }

            for( int j = 0; j < hole.PointCount(); j++ )
            {
                aModel.m_holes.AddVertex( seg, (double) hole.CPoint(j).x * BOARD_SCALE,
                                          -( (double) hole.CPoint(j).y * BOARD_SCALE ) );
            }

            aModel.m_holes.EnsureWinding( seg, true );
        }
    }
}

References _, BOARD_SCALE, SHAPE_POLY_SET::COutline(), SHAPE_LINE_CHAIN::CPoint(), BOARD::GetBoardPolygonOutlines(), SHAPE_POLY_SET::Hole(), SHAPE_POLY_SET::HoleCount(), MODEL_VRML::m_board, MODEL_VRML::m_holes, SHAPE_POLY_SET::OutlineCount(), SHAPE_LINE_CHAIN::PointCount(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by PCB_EDIT_FRAME::ExportVRML_File().

export_vrml_circle()

static void export_vrml_circle ( MODEL_VRML &  aModel, LAYER_NUM  layer, double  startx, double  starty, double  endx, double  endy, double  width  )

static

Definition at line 613 of file export_vrml.cpp.

{
    VRML_LAYER* vlayer;

    if( !GetLayer( aModel, layer, &vlayer ) )
        return;

    if( width < aModel.m_minLineWidth )
        width = aModel.m_minLineWidth;

    starty = -starty;
    endy = -endy;

    double hole, radius;

    radius = Distance( startx, starty, endx, endy ) + ( width / 2);
    hole = radius - width;

    if( !vlayer->AddCircle( startx, starty, radius, false ) )
        throw( std::runtime_error( vlayer->GetError() ) );

    if( hole > 0.0001 )
    {
        if( !vlayer->AddCircle( startx, starty, hole, true ) )
            throw( std::runtime_error( vlayer->GetError() ) );
    }
}

References GetLayer(), and MODEL_VRML::m_minLineWidth.

Referenced by export_vrml_fp_shape().

export_vrml_drawings()

static void export_vrml_drawings ( MODEL_VRML &  aModel, BOARD *  pcb  )

static

Definition at line 831 of file export_vrml.cpp.

{
    // draw graphic items
    for( auto drawing : pcb->Drawings() )
    {
        PCB_LAYER_ID layer = drawing->GetLayer();

        if( layer != F_Cu && layer != B_Cu && layer != B_SilkS && layer != F_SilkS )
            continue;

        switch( drawing->Type() )
        {
        case PCB_SHAPE_T:
            export_vrml_drawsegment( aModel, (PCB_SHAPE*) drawing );
            break;

        case PCB_TEXT_T:
            export_vrml_pcbtext( aModel, (PCB_TEXT*) drawing );
            break;

        default:
            break;
        }
    }
}

References B_Cu, B_SilkS, BOARD::Drawings(), export_vrml_drawsegment(), export_vrml_pcbtext(), F_Cu, F_SilkS, PCB_SHAPE_T, and PCB_TEXT_T.

Referenced by PCB_EDIT_FRAME::ExportVRML_File().

export_vrml_drawsegment()

static void export_vrml_drawsegment ( MODEL_VRML &  aModel, PCB_SHAPE *  drawseg  )

static

Definition at line 702 of file export_vrml.cpp.

{
    LAYER_NUM layer = drawseg->GetLayer();
    double  w   = drawseg->GetWidth() * BOARD_SCALE;
    double  x   = drawseg->GetStart().x * BOARD_SCALE;
    double  y   = drawseg->GetStart().y * BOARD_SCALE;
    double  xf  = drawseg->GetEnd().x * BOARD_SCALE;
    double  yf  = drawseg->GetEnd().y * BOARD_SCALE;
    double  r   = sqrt( pow( x - xf, 2 ) + pow( y - yf, 2 ) );

    // Items on the edge layer are handled elsewhere; just return
    if( layer == Edge_Cuts )
        return;

    switch( drawseg->GetShape() )
    {
    case S_ARC:
        export_vrml_arc( aModel, layer,
                         (double) drawseg->GetCenter().x * BOARD_SCALE,
                         (double) drawseg->GetCenter().y * BOARD_SCALE,
                         (double) drawseg->GetArcStart().x * BOARD_SCALE,
                         (double) drawseg->GetArcStart().y * BOARD_SCALE,
                         w, drawseg->GetAngle() / 10 );
        break;

    case S_CIRCLE:
        // Break circles into two 180 arcs to prevent the vrml hole from obscuring objects
        // within the hole area of the circle.
        export_vrml_arc( aModel, layer, x, y, x, y-r, w, 180.0 );
        export_vrml_arc( aModel, layer, x, y, x, y+r, w, 180.0 );
        break;

    case S_POLYGON:
        export_vrml_polygon( aModel, layer, drawseg, 0.0, wxPoint( 0, 0 ) );
        break;

    case S_SEGMENT:
        export_vrml_line( aModel, layer, x, y, xf, yf, w );
        break;

    case S_CURVE:
    {
        std::vector<VECTOR2D> output;
        std::vector<VECTOR2D> pointCtrl;

        pointCtrl.emplace_back( x, y );
        pointCtrl.emplace_back( drawseg->GetBezControl1().x * BOARD_SCALE,
                drawseg->GetBezControl1().y * BOARD_SCALE );
        pointCtrl.emplace_back( drawseg->GetBezControl2().x * BOARD_SCALE,
                drawseg->GetBezControl2().y * BOARD_SCALE );
        pointCtrl.emplace_back( xf, yf );

        BEZIER_POLY converter( pointCtrl );
        converter.GetPoly( output, w );

        for( size_t i = 1; i < output.size(); ++i )
        {
            export_vrml_line( aModel, layer, output[i - 1].x, output[i - 1].y,
                                             output[i].x, output[i].y, w );
        }

        break;
    }

    case S_RECT:
        export_vrml_line( aModel, layer, x, y, xf, y, w );
        export_vrml_line( aModel, layer, xf, y, xf, yf, w );
        export_vrml_line( aModel, layer, xf, yf, x, yf, w );
        export_vrml_line( aModel, layer, x, yf, x, y, w );
        break;

    default:
        break;
    }
}

References BOARD_SCALE, Edge_Cuts, export_vrml_arc(), export_vrml_line(), export_vrml_polygon(), PCB_SHAPE::GetAngle(), PCB_SHAPE::GetArcStart(), PCB_SHAPE::GetBezControl1(), PCB_SHAPE::GetBezControl2(), PCB_SHAPE::GetCenter(), PCB_SHAPE::GetEnd(), BOARD_ITEM::GetLayer(), BEZIER_POLY::GetPoly(), PCB_SHAPE::GetShape(), PCB_SHAPE::GetStart(), PCB_SHAPE::GetWidth(), S_ARC, S_CIRCLE, S_CURVE, S_POLYGON, S_RECT, and S_SEGMENT.

Referenced by export_vrml_drawings().

export_vrml_footprint()

static void export_vrml_footprint ( MODEL_VRML &  aModel, BOARD *  aPcb, FOOTPRINT *  aFootprint, std::ostream *  aOutputFile  )

static

Definition at line 1412 of file export_vrml.cpp.

{
    if( !aModel.m_plainPCB )
    {
        // Reference and value
        if( aFootprint->Reference().IsVisible() )
            export_vrml_fp_text( &aFootprint->Reference() );

        if( aFootprint->Value().IsVisible() )
            export_vrml_fp_text( &aFootprint->Value() );

        // Export footprint graphics

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

            case PCB_FP_SHAPE_T:
                export_vrml_fp_shape( aModel, static_cast<FP_SHAPE*>( item ), aFootprint );
                break;

            default:
                break;
            }
        }
    }

    // Export pads
    for( PAD* pad : aFootprint->Pads() )
        export_vrml_pad( aModel, aPcb, pad );

    bool isFlipped = aFootprint->GetLayer() == B_Cu;

    // Export the object VRML model(s)
    auto sM = aFootprint->Models().begin();
    auto eM = aFootprint->Models().end();

    wxFileName subdir( SUBDIR_3D, "" );

    while( sM != eM )
    {
        SGNODE* mod3d = (SGNODE*) cache->Load( sM->m_Filename );

        if( NULL == mod3d )
        {
            ++sM;
            continue;
        }

        /* Calculate 3D shape rotation:
         * this is the rotation parameters, with an additional 180 deg rotation
         * for footprints that are flipped
         * When flipped, axis rotation is the horizontal axis (X axis)
         */
        double rotx = -sM->m_Rotation.x;
        double roty = -sM->m_Rotation.y;
        double rotz = -sM->m_Rotation.z;

        if( isFlipped )
        {
            rotx += 180.0;
            roty = -roty;
            rotz = -rotz;
        }

        // Do some quaternion munching
        double q1[4], q2[4], rot[4];
        build_quat( 1, 0, 0, DEG2RAD( rotx ), q1 );
        build_quat( 0, 1, 0, DEG2RAD( roty ), q2 );
        compose_quat( q1, q2, q1 );
        build_quat( 0, 0, 1, DEG2RAD( rotz ), q2 );
        compose_quat( q1, q2, q1 );

        // Note here aFootprint->GetOrientation() is in 0.1 degrees, so footprint rotation
        // has to be converted to radians
        build_quat( 0, 0, 1, DECIDEG2RAD( aFootprint->GetOrientation() ), q2 );
        compose_quat( q1, q2, q1 );
        from_quat( q1, rot );

        double offsetFactor = 1000.0f * IU_PER_MILS / 25.4f;

        // adjust 3D shape local offset position
        // they are given in mm, so they are converted in board IU.
        double offsetx = sM->m_Offset.x * offsetFactor;
        double offsety = sM->m_Offset.y * offsetFactor;
        double offsetz = sM->m_Offset.z * offsetFactor;

        if( isFlipped )
            offsetz = -offsetz;
        else // In normal mode, Y axis is reversed in Pcbnew.
            offsety = -offsety;

        RotatePoint( &offsetx, &offsety, aFootprint->GetOrientation() );

        SGPOINT trans;
        trans.x = ( offsetx + aFootprint->GetPosition().x ) * BOARD_SCALE + aModel.m_tx;
        trans.y = -( offsety + aFootprint->GetPosition().y) * BOARD_SCALE - aModel.m_ty;
        trans.z = (offsetz * BOARD_SCALE ) + aModel.GetLayerZ( aFootprint->GetLayer() );

        if( USE_INLINES )
        {
            wxFileName srcFile = cache->GetResolver()->ResolvePath( sM->m_Filename );
            wxFileName dstFile;
            dstFile.SetPath( SUBDIR_3D );
            dstFile.SetName( srcFile.GetName() );
            dstFile.SetExt( "wrl"  );

            // copy the file if necessary
            wxDateTime srcModTime = srcFile.GetModificationTime();
            wxDateTime destModTime = srcModTime;

            destModTime.SetToCurrent();

            if( dstFile.FileExists() )
                destModTime = dstFile.GetModificationTime();

            if( srcModTime != destModTime )
            {
                wxString fileExt = srcFile.GetExt();
                fileExt.LowerCase();

                // copy VRML models and use the scenegraph library to
                // translate other model types
                if( fileExt == "wrl" )
                {
                    if( !wxCopyFile( srcFile.GetFullPath(), dstFile.GetFullPath() ) )
                        continue;
                }
                else
                {
                    if( !S3D::WriteVRML( dstFile.GetFullPath().ToUTF8(), true, mod3d, USE_DEFS, true ) )
                        continue;
                }
            }

            (*aOutputFile) << "Transform {\n";

            // only write a rotation if it is >= 0.1 deg
            if( std::abs( rot[3] ) > 0.0001745 )
            {
                (*aOutputFile) << "  rotation " << std::setprecision( 5 );
                (*aOutputFile) << rot[0] << " " << rot[1] << " " << rot[2] << " " << rot[3] << "\n";
            }

            (*aOutputFile) << "  translation " << std::setprecision( PRECISION );
            (*aOutputFile) << trans.x << " ";
            (*aOutputFile) << trans.y << " ";
            (*aOutputFile) << trans.z << "\n";

            (*aOutputFile) << "  scale ";
            (*aOutputFile) << sM->m_Scale.x << " ";
            (*aOutputFile) << sM->m_Scale.y << " ";
            (*aOutputFile) << sM->m_Scale.z << "\n";

            (*aOutputFile) << "  children [\n    Inline {\n      url \"";

            if( USE_RELPATH )
            {
                wxFileName tmp = dstFile;
                tmp.SetExt( "" );
                tmp.SetName( "" );
                tmp.RemoveLastDir();
                dstFile.MakeRelativeTo( tmp.GetPath() );
            }

            wxString fn = dstFile.GetFullPath();
            fn.Replace( "\\", "/" );
            (*aOutputFile) << TO_UTF8( fn ) << "\"\n    } ]\n";
            (*aOutputFile) << "  }\n";
        }
        else
        {
            IFSG_TRANSFORM* modelShape = new IFSG_TRANSFORM( aModel.m_OutputPCB.GetRawPtr() );

            // only write a rotation if it is >= 0.1 deg
            if( std::abs( rot[3] ) > 0.0001745 )
                modelShape->SetRotation( SGVECTOR( rot[0], rot[1], rot[2] ), rot[3] );

            modelShape->SetTranslation( trans );
            modelShape->SetScale( SGPOINT( sM->m_Scale.x, sM->m_Scale.y, sM->m_Scale.z ) );

            if( NULL == S3D::GetSGNodeParent( mod3d ) )
            {
                aModel.m_components.push_back( mod3d );
                modelShape->AddChildNode( mod3d );
            }
            else
            {
                modelShape->AddRefNode( mod3d );
            }

        }

        ++sM;
    }
}

References IFSG_NODE::AddChildNode(), IFSG_NODE::AddRefNode(), B_Cu, BOARD_SCALE, build_quat(), cache, compose_quat(), DECIDEG2RAD(), DEG2RAD(), export_vrml_fp_shape(), export_vrml_fp_text(), export_vrml_pad(), from_quat(), BOARD_ITEM::GetLayer(), MODEL_VRML::GetLayerZ(), FOOTPRINT::GetOrientation(), FOOTPRINT::GetPosition(), IFSG_NODE::GetRawPtr(), S3D_CACHE::GetResolver(), S3D::GetSGNodeParent(), FOOTPRINT::GraphicalItems(), EDA_TEXT::IsVisible(), IU_PER_MILS, S3D_CACHE::Load(), MODEL_VRML::m_components, MODEL_VRML::m_OutputPCB, MODEL_VRML::m_plainPCB, MODEL_VRML::m_tx, MODEL_VRML::m_ty, FOOTPRINT::Models(), NULL, FOOTPRINT::Pads(), PCB_FP_SHAPE_T, PCB_FP_TEXT_T, PRECISION, FOOTPRINT::Reference(), FILENAME_RESOLVER::ResolvePath(), RotatePoint(), IFSG_TRANSFORM::SetRotation(), IFSG_TRANSFORM::SetScale(), IFSG_TRANSFORM::SetTranslation(), SUBDIR_3D, TO_UTF8, USE_DEFS, USE_INLINES, USE_RELPATH, FOOTPRINT::Value(), S3D::WriteVRML(), and SGPOINT::x.

Referenced by PCB_EDIT_FRAME::ExportVRML_File().

export_vrml_fp_shape()

static void export_vrml_fp_shape ( MODEL_VRML &  aModel, FP_SHAPE *  aOutline, FOOTPRINT *  aFootprint  )

static

Definition at line 1096 of file export_vrml.cpp.

{
    LAYER_NUM layer = aOutline->GetLayer();
    double  x   = aOutline->GetStart().x * BOARD_SCALE;
    double  y   = aOutline->GetStart().y * BOARD_SCALE;
    double  xf  = aOutline->GetEnd().x * BOARD_SCALE;
    double  yf  = aOutline->GetEnd().y * BOARD_SCALE;
    double  w   = aOutline->GetWidth() * BOARD_SCALE;

    switch( aOutline->GetShape() )
    {
    case S_SEGMENT:
        export_vrml_line( aModel, layer, x, y, xf, yf, w );
        break;

    case S_ARC:
        export_vrml_arc( aModel, layer, x, y, xf, yf, w, aOutline->GetAngle() / 10 );
        break;

    case S_CIRCLE:
        export_vrml_circle( aModel, layer, x, y, xf, yf, w );
        break;

    case S_POLYGON:
        export_vrml_polygon( aModel, layer, aOutline, aFootprint->GetOrientationRadians(),
                             aFootprint->GetPosition() );
        break;

    case S_CURVE:
    {
        std::vector<VECTOR2D> output;
        std::vector<VECTOR2D> pointCtrl;

        pointCtrl.emplace_back( x, y );
        pointCtrl.emplace_back( aOutline->GetBezControl1().x * BOARD_SCALE,
                aOutline->GetBezControl1().y * BOARD_SCALE );
        pointCtrl.emplace_back( aOutline->GetBezControl2().x * BOARD_SCALE,
                aOutline->GetBezControl2().y * BOARD_SCALE );
        pointCtrl.emplace_back( xf, yf );

        BEZIER_POLY converter( pointCtrl );
        converter.GetPoly( output, w );

        for( size_t i = 1; i < output.size(); ++i )
        {
            export_vrml_line( aModel, layer, output[i - 1].x, output[i - 1].y,
                                             output[i].x, output[i].y, w );
        }

        break;
    }

    case S_RECT:
        export_vrml_line( aModel, layer, x, y, xf, y, w );
        export_vrml_line( aModel, layer, xf, y, xf, yf, w );
        export_vrml_line( aModel, layer, xf, yf, x, yf, w );
        export_vrml_line( aModel, layer, x, yf, x, y, w );
        break;

    default:
        break;
    }
}

References BOARD_SCALE, export_vrml_arc(), export_vrml_circle(), export_vrml_line(), export_vrml_polygon(), PCB_SHAPE::GetAngle(), PCB_SHAPE::GetBezControl1(), PCB_SHAPE::GetBezControl2(), PCB_SHAPE::GetEnd(), BOARD_ITEM::GetLayer(), FOOTPRINT::GetOrientationRadians(), BEZIER_POLY::GetPoly(), FOOTPRINT::GetPosition(), PCB_SHAPE::GetShape(), PCB_SHAPE::GetStart(), PCB_SHAPE::GetWidth(), S_ARC, S_CIRCLE, S_CURVE, S_POLYGON, S_RECT, and S_SEGMENT.

Referenced by export_vrml_footprint().

export_vrml_fp_text()

static void export_vrml_fp_text ( FP_TEXT *  item )

static

Definition at line 1074 of file export_vrml.cpp.

{
    if( item->IsVisible() )
    {
        wxSize size = item->GetTextSize();

        if( item->IsMirrored() )
            size.x = -size.x;  // Text is mirrored

        bool forceBold = true;
        int  penWidth = item->GetEffectiveTextPenWidth();

        model_vrml->m_text_layer = item->GetLayer();
        model_vrml->m_text_width = penWidth;

        GRText( NULL, item->GetTextPos(), BLACK, item->GetShownText(), item->GetDrawRotation(),
                size, item->GetHorizJustify(), item->GetVertJustify(), penWidth, item->IsItalic(),
                forceBold, vrml_text_callback );
    }
}

References BLACK, FP_TEXT::GetDrawRotation(), EDA_TEXT::GetEffectiveTextPenWidth(), EDA_TEXT::GetHorizJustify(), BOARD_ITEM::GetLayer(), FP_TEXT::GetShownText(), EDA_TEXT::GetTextPos(), EDA_TEXT::GetTextSize(), EDA_TEXT::GetVertJustify(), GRText(), EDA_TEXT::IsItalic(), EDA_TEXT::IsMirrored(), EDA_TEXT::IsVisible(), MODEL_VRML::m_text_layer, MODEL_VRML::m_text_width, model_vrml, NULL, and vrml_text_callback().

Referenced by export_vrml_footprint().

export_vrml_line()

static void export_vrml_line ( MODEL_VRML &  aModel, LAYER_NUM  layer, double  startx, double  starty, double  endx, double  endy, double  width  )

static

Definition at line 588 of file export_vrml.cpp.

{
    VRML_LAYER* vlayer;

    if( !GetLayer( aModel, layer, &vlayer ) )
        return;

    if( width < aModel.m_minLineWidth)
        width = aModel.m_minLineWidth;

    starty = -starty;
    endy = -endy;

    double  angle   = atan2( endy - starty, endx - startx ) * 180.0 / M_PI;
    double  length  = Distance( startx, starty, endx, endy ) + width;
    double  cx  = ( startx + endx ) / 2.0;
    double  cy  = ( starty + endy ) / 2.0;

    if( !vlayer->AddSlot( cx, cy, length, width, angle, false ) )
        throw( std::runtime_error( vlayer->GetError() ) );
}

References PNS::angle(), GetLayer(), and MODEL_VRML::m_minLineWidth.

Referenced by export_vrml_drawsegment(), export_vrml_fp_shape(), export_vrml_tracks(), and vrml_text_callback().

export_vrml_pad()

static void export_vrml_pad ( MODEL_VRML &  aModel, BOARD *  aPcb, PAD *  aPad  )

static

Definition at line 1294 of file export_vrml.cpp.

{
    double  hole_drill_w    = (double) aPad->GetDrillSize().x * BOARD_SCALE / 2.0;
    double  hole_drill_h    = (double) aPad->GetDrillSize().y * BOARD_SCALE / 2.0;
    double  hole_drill      = std::min( hole_drill_w, hole_drill_h );
    double  hole_x          = aPad->GetPosition().x * BOARD_SCALE;
    double  hole_y          = aPad->GetPosition().y * BOARD_SCALE;

    // Export the hole on the edge layer
    if( hole_drill > 0 )
    {
        bool pth = false;

        if( ( aPad->GetAttribute() != PAD_ATTRIB_NPTH )
            && !aModel.m_plainPCB )
            pth = true;

        if( aPad->GetDrillShape() == PAD_DRILL_SHAPE_OBLONG )
        {
            // Oblong hole (slot)

            if( pth )
            {
                aModel.m_holes.AddSlot( hole_x, -hole_y, hole_drill_w * 2.0 + PLATE_OFFSET,
                    hole_drill_h * 2.0 + PLATE_OFFSET,
                    aPad->GetOrientation()/10.0, true, true );

                aModel.m_plated_holes.AddSlot( hole_x, -hole_y,
                    hole_drill_w * 2.0, hole_drill_h * 2.0,
                    aPad->GetOrientation()/10.0, true, false );
            }
            else
            {
                aModel.m_holes.AddSlot( hole_x, -hole_y, hole_drill_w * 2.0, hole_drill_h * 2.0,
                    aPad->GetOrientation()/10.0, true, false );

            }
        }
        else
        {
            // Drill a round hole

            if( pth )
            {
                aModel.m_holes.AddCircle( hole_x, -hole_y, hole_drill + PLATE_OFFSET, true, true );
                aModel.m_plated_holes.AddCircle( hole_x, -hole_y, hole_drill, true, false );
            }
            else
            {
                aModel.m_holes.AddCircle( hole_x, -hole_y, hole_drill, true, false );
            }

        }
    }

    if( aModel.m_plainPCB )
        return;

    // The pad proper, on the selected layers
    LSET layer_mask = aPad->GetLayerSet();

    if( layer_mask[B_Cu] )
    {
        if( layer_mask[B_Mask] )
            export_vrml_padshape( aModel, &aModel.m_bot_tin, aPad );
        else
            export_vrml_padshape( aModel, &aModel.m_bot_copper, aPad );
    }
    if( layer_mask[F_Cu] )
    {
        if( layer_mask[F_Mask] )
            export_vrml_padshape( aModel, &aModel.m_top_tin, aPad );
        else
            export_vrml_padshape( aModel, &aModel.m_top_copper, aPad );
    }

}

References B_Cu, B_Mask, BOARD_SCALE, export_vrml_padshape(), F_Cu, F_Mask, PAD::GetAttribute(), PAD::GetDrillShape(), PAD::GetDrillSize(), PAD::GetLayerSet(), PAD::GetOrientation(), PAD::GetPosition(), MODEL_VRML::m_bot_copper, MODEL_VRML::m_bot_tin, MODEL_VRML::m_holes, MODEL_VRML::m_plainPCB, MODEL_VRML::m_plated_holes, MODEL_VRML::m_top_copper, MODEL_VRML::m_top_tin, PAD_ATTRIB_NPTH, PAD_DRILL_SHAPE_OBLONG, and PLATE_OFFSET.

Referenced by export_vrml_footprint().

export_vrml_padshape()

static void export_vrml_padshape ( MODEL_VRML &  aModel, VRML_LAYER *  aTinLayer, PAD *  aPad  )

static

Definition at line 1161 of file export_vrml.cpp.

{
    // The (maybe offset) pad position
    wxPoint pad_pos = aPad->ShapePos();
    double  pad_x   = pad_pos.x * BOARD_SCALE;
    double  pad_y   = pad_pos.y * BOARD_SCALE;
    wxSize  pad_delta = aPad->GetDelta();

    double  pad_dx  = pad_delta.x * BOARD_SCALE / 2.0;
    double  pad_dy  = pad_delta.y * BOARD_SCALE / 2.0;

    double  pad_w   = aPad->GetSize().x * BOARD_SCALE / 2.0;
    double  pad_h   = aPad->GetSize().y * BOARD_SCALE / 2.0;

    switch( aPad->GetShape() )
    {
    case PAD_SHAPE_CIRCLE:

        if( !aTinLayer->AddCircle( pad_x, -pad_y, pad_w, false ) )
            throw( std::runtime_error( aTinLayer->GetError() ) );

        break;

    case PAD_SHAPE_OVAL:

        if( !aTinLayer->AddSlot( pad_x, -pad_y, pad_w * 2.0, pad_h * 2.0,
                                 aPad->GetOrientation()/10.0, false ) )
            throw( std::runtime_error( aTinLayer->GetError() ) );

        break;

    case PAD_SHAPE_ROUNDRECT:
    case PAD_SHAPE_CHAMFERED_RECT:
    {
        SHAPE_POLY_SET polySet;
        const int corner_radius = aPad->GetRoundRectCornerRadius();
        TransformRoundChamferedRectToPolygon( polySet, wxPoint( 0, 0 ), aPad->GetSize(), 0.0,
                                              corner_radius, 0.0, 0, ARC_HIGH_DEF, ERROR_INSIDE );
        std::vector< wxRealPoint > cornerList;
        // TransformRoundChamferedRectToPolygon creates only one convex polygon
        SHAPE_LINE_CHAIN poly( polySet.Outline( 0 ) );

        cornerList.reserve( poly.PointCount() );
        for( int ii = 0; ii < poly.PointCount(); ++ii )
            cornerList.emplace_back(
                    poly.CPoint( ii ).x * BOARD_SCALE, -poly.CPoint( ii ).y * BOARD_SCALE );

        // Close polygon
        cornerList.push_back( cornerList[0] );
        if( !aTinLayer->AddPolygon( cornerList, pad_x, -pad_y, aPad->GetOrientation() ) )
            throw( std::runtime_error( aTinLayer->GetError() ) );

        break;
    }

    case PAD_SHAPE_CUSTOM:
    {
        SHAPE_POLY_SET polySet;
        std::vector< wxRealPoint > cornerList;
        aPad->MergePrimitivesAsPolygon( &polySet, UNDEFINED_LAYER );

        for( int cnt = 0; cnt < polySet.OutlineCount(); ++cnt )
        {
            SHAPE_LINE_CHAIN& poly = polySet.Outline( cnt );
            cornerList.clear();

            for( int ii = 0; ii < poly.PointCount(); ++ii )
                cornerList.emplace_back(
                        poly.CPoint( ii ).x * BOARD_SCALE, -poly.CPoint( ii ).y * BOARD_SCALE );

            // Close polygon
            cornerList.push_back( cornerList[0] );

            if( !aTinLayer->AddPolygon( cornerList, pad_x, -pad_y, aPad->GetOrientation() ) )
                throw( std::runtime_error( aTinLayer->GetError() ) );
        }

        break;
    }

    case PAD_SHAPE_RECT:
        // Just to be sure :D
        pad_dx  = 0;
        pad_dy  = 0;

        // Intentionally fall through and treat a rectangle as a trapezoid with no sloped sides
        KI_FALLTHROUGH;

    case PAD_SHAPE_TRAPEZOID:
        {
        double coord[8] =
        {
            -pad_w + pad_dy, -pad_h - pad_dx,
            -pad_w - pad_dy, pad_h + pad_dx,
            +pad_w - pad_dy, -pad_h + pad_dx,
            +pad_w + pad_dy, pad_h - pad_dx
        };

        for( int i = 0; i < 4; i++ )
        {
            RotatePoint( &coord[i * 2], &coord[i * 2 + 1], aPad->GetOrientation() );
            coord[i * 2] += pad_x;
            coord[i * 2 + 1] += pad_y;
        }

        int lines;

        lines = aTinLayer->NewContour();

        if( lines < 0 )
            throw( std::runtime_error( aTinLayer->GetError() ) );

        if( !aTinLayer->AddVertex( lines, coord[0], -coord[1] ) )
            throw( std::runtime_error( aTinLayer->GetError() ) );

        if( !aTinLayer->AddVertex( lines, coord[4], -coord[5] ) )
            throw( std::runtime_error( aTinLayer->GetError() ) );

        if( !aTinLayer->AddVertex( lines, coord[6], -coord[7] ) )
            throw( std::runtime_error( aTinLayer->GetError() ) );

        if( !aTinLayer->AddVertex( lines, coord[2], -coord[3] ) )
            throw( std::runtime_error( aTinLayer->GetError() ) );

        if( !aTinLayer->EnsureWinding( lines, false ) )
            throw( std::runtime_error( aTinLayer->GetError() ) );

        break;
        }
    }
}

References BOARD_SCALE, SHAPE_LINE_CHAIN::CPoint(), ERROR_INSIDE, PAD::GetDelta(), PAD::GetOrientation(), PAD::GetRoundRectCornerRadius(), PAD::GetShape(), PAD::GetSize(), KI_FALLTHROUGH, PAD::MergePrimitivesAsPolygon(), SHAPE_POLY_SET::Outline(), SHAPE_POLY_SET::OutlineCount(), PAD_SHAPE_CHAMFERED_RECT, PAD_SHAPE_CIRCLE, PAD_SHAPE_CUSTOM, PAD_SHAPE_OVAL, PAD_SHAPE_RECT, PAD_SHAPE_ROUNDRECT, PAD_SHAPE_TRAPEZOID, SHAPE_LINE_CHAIN::PointCount(), RotatePoint(), PAD::ShapePos(), TransformRoundChamferedRectToPolygon(), UNDEFINED_LAYER, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by export_vrml_pad().

export_vrml_pcbtext()

static void export_vrml_pcbtext ( MODEL_VRML &  aModel, PCB_TEXT *  text  )

static

Definition at line 793 of file export_vrml.cpp.

{
    wxSize size = text->GetTextSize();

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

    bool    forceBold = true;
    int     penWidth = text->GetEffectiveTextPenWidth();
    COLOR4D color = COLOR4D::BLACK;  // not actually used, but needed by GRText

    model_vrml->m_text_layer    = text->GetLayer();
    model_vrml->m_text_width    = penWidth;

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

        for( unsigned ii = 0; ii < strings_list.Count(); ii++ )
        {
            GRText( nullptr, positions[ii], color, strings_list[ii], text->GetTextAngle(), size,
                    text->GetHorizJustify(), text->GetVertJustify(), penWidth, text->IsItalic(),
                    forceBold, vrml_text_callback );
        }
    }
    else
    {
        GRText( nullptr, text->GetTextPos(), color, text->GetShownText(), text->GetTextAngle(),
                size, text->GetHorizJustify(), text->GetVertJustify(), penWidth, text->IsItalic(),
                forceBold, vrml_text_callback );
    }
}

References BLACK, color, EDA_TEXT::GetEffectiveTextPenWidth(), EDA_TEXT::GetHorizJustify(), BOARD_ITEM::GetLayer(), 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(), MODEL_VRML::m_text_layer, MODEL_VRML::m_text_width, model_vrml, vrml_text_callback(), and wxStringSplit().

Referenced by export_vrml_drawings().

export_vrml_polygon()

static void export_vrml_polygon ( MODEL_VRML &  aModel, LAYER_NUM  layer, PCB_SHAPE *  aOutline, double  aOrientation, wxPoint  aPos  )

static

Definition at line 666 of file export_vrml.cpp.

{
    if( aOutline->IsPolyShapeValid() )
    {
        SHAPE_POLY_SET shape = aOutline->GetPolyShape();
        VRML_LAYER* vlayer;

        if( !GetLayer( aModel, layer, &vlayer ) )
                return;

        if( aOutline->GetWidth() )
        {
            int numSegs = GetArcToSegmentCount( aOutline->GetWidth() / 2, ARC_HIGH_DEF, 360.0 );
            shape.Inflate( aOutline->GetWidth() / 2, numSegs );
            shape.Fracture( SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
        }

        shape.Rotate( -aOrientation, VECTOR2I( 0, 0 ) );
        shape.Move( aPos );
        const SHAPE_LINE_CHAIN& outline = shape.COutline( 0 );

        int seg = vlayer->NewContour();

        for( int j = 0; j < outline.PointCount(); j++ )
        {
            if( !vlayer->AddVertex( seg, outline.CPoint( j ).x * BOARD_SCALE,
                                     -outline.CPoint( j ).y * BOARD_SCALE ) )
                throw( std::runtime_error( vlayer->GetError() ) );
        }

        vlayer->EnsureWinding( seg, false );
    }
}

References BOARD_SCALE, SHAPE_POLY_SET::COutline(), SHAPE_LINE_CHAIN::CPoint(), SHAPE_POLY_SET::Fracture(), GetArcToSegmentCount(), GetLayer(), PCB_SHAPE::GetPolyShape(), PCB_SHAPE::GetWidth(), SHAPE_POLY_SET::Inflate(), PCB_SHAPE::IsPolyShapeValid(), SHAPE_POLY_SET::Move(), SHAPE_POLY_SET::PM_STRICTLY_SIMPLE, SHAPE_LINE_CHAIN::PointCount(), SHAPE_POLY_SET::Rotate(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by export_vrml_drawsegment(), and export_vrml_fp_shape().

export_vrml_tracks()

static void export_vrml_tracks ( MODEL_VRML &  aModel, BOARD *  pcb  )

static

Definition at line 975 of file export_vrml.cpp.

{
    for( TRACK* track : pcb->Tracks() )
    {
        if( track->Type() == PCB_VIA_T )
        {
            export_vrml_via( aModel, pcb, (const VIA*) track );
        }
        else if( ( track->GetLayer() == B_Cu || track->GetLayer() == F_Cu )
                 && !aModel.m_plainPCB )
        {
            if( track->Type() == PCB_ARC_T )
            {
                ARC* arc = static_cast<ARC*>( track );
                VECTOR2D center( arc->GetCenter() );
                double arc_angle_degree = arc->GetAngle()/10;

                // Vrml exporter does not export arcs with angle < 1.0 degree
                // ( to avoid issues with vrml viewers).
                // The best way is to convert them to a small straight line
                if( arc_angle_degree < -1.0 || arc_angle_degree > 1.0 )
                {
                    export_vrml_arc( aModel, track->GetLayer(),
                                     center.x * BOARD_SCALE, center.y * BOARD_SCALE,
                                     arc->GetStart().x * BOARD_SCALE,
                                     arc->GetStart().y * BOARD_SCALE,
                                     arc->GetWidth() * BOARD_SCALE, arc_angle_degree );
                }
                else
                {
                    export_vrml_line( aModel, arc->GetLayer(),
                                      arc->GetStart().x * BOARD_SCALE,
                                      arc->GetStart().y * BOARD_SCALE,
                                      arc->GetEnd().x * BOARD_SCALE,
                                      arc->GetEnd().y * BOARD_SCALE,
                                      arc->GetWidth() * BOARD_SCALE );
                }
            }
            else
            {
                export_vrml_line( aModel, track->GetLayer(),
                                  track->GetStart().x * BOARD_SCALE,
                                  track->GetStart().y * BOARD_SCALE,
                                  track->GetEnd().x * BOARD_SCALE,
                                  track->GetEnd().y * BOARD_SCALE,
                                  track->GetWidth() * BOARD_SCALE );
            }
        }
    }
}

References B_Cu, BOARD_SCALE, export_vrml_arc(), export_vrml_line(), export_vrml_via(), F_Cu, ARC::GetAngle(), ARC::GetCenter(), TRACK::GetEnd(), BOARD_ITEM::GetLayer(), TRACK::GetStart(), TRACK::GetWidth(), MODEL_VRML::m_plainPCB, PCB_ARC_T, PCB_VIA_T, and BOARD::Tracks().

Referenced by PCB_EDIT_FRAME::ExportVRML_File().

export_vrml_via()

static void export_vrml_via ( MODEL_VRML &  aModel, BOARD *  aPcb, const VIA *  aVia  )

static

Definition at line 955 of file export_vrml.cpp.

{
    double       x, y, r, hole;
    PCB_LAYER_ID top_layer, bottom_layer;

    hole = aVia->GetDrillValue() * BOARD_SCALE / 2.0;
    r    = aVia->GetWidth() * BOARD_SCALE / 2.0;
    x    = aVia->GetStart().x * BOARD_SCALE;
    y    = aVia->GetStart().y * BOARD_SCALE;
    aVia->LayerPair( &top_layer, &bottom_layer );

    // do not render a buried via
    if( top_layer != F_Cu && bottom_layer != B_Cu )
        return;

    // Export the via padstack
    export_round_padstack( aModel, aPcb, x, y, r, bottom_layer, top_layer, hole );
}

References B_Cu, BOARD_SCALE, export_round_padstack(), F_Cu, VIA::GetDrillValue(), TRACK::GetStart(), TRACK::GetWidth(), and VIA::LayerPair().

Referenced by export_vrml_tracks().

export_vrml_zones()

static void export_vrml_zones ( MODEL_VRML &  aModel, BOARD *  aPcb, COMMIT *  aCommit  )

static

Definition at line 1027 of file export_vrml.cpp.

{
    for( ZONE* zone : aPcb->Zones() )
    {
        for( PCB_LAYER_ID layer : zone->GetLayerSet().Seq() )
        {
            VRML_LAYER* vl;

            if( !GetLayer( aModel, layer, &vl ) )
                continue;

            if( !zone->IsFilled() )
            {
                ZONE_FILLER filler( aPcb, aCommit );
                zone->SetFillMode( ZONE_FILL_MODE::POLYGONS ); // use filled polygons

                // If the zone fill failed, don't try adding it to the export
                std::vector<ZONE*> toFill = { zone };

                if( !filler.Fill( toFill ) )
                    continue;
            }

            const SHAPE_POLY_SET& poly = zone->GetFilledPolysList( layer );

            for( int i = 0; i < poly.OutlineCount(); i++ )
            {
                const SHAPE_LINE_CHAIN& outline = poly.COutline( i );

                int seg = vl->NewContour();

                for( int j = 0; j < outline.PointCount(); j++ )
                {
                    if( !vl->AddVertex( seg, (double) outline.CPoint( j ).x * BOARD_SCALE,
                                -( (double) outline.CPoint( j ).y * BOARD_SCALE ) ) )
                    {
                        throw( std::runtime_error( vl->GetError() ) );
                    }
                }

                vl->EnsureWinding( seg, false );
            }
        }
    }
}

References BOARD_SCALE, SHAPE_POLY_SET::COutline(), SHAPE_LINE_CHAIN::CPoint(), ZONE_FILLER::Fill(), GetLayer(), SHAPE_POLY_SET::OutlineCount(), SHAPE_LINE_CHAIN::PointCount(), POLYGONS, VECTOR2< T >::x, VECTOR2< T >::y, and BOARD::Zones().

Referenced by PCB_EDIT_FRAME::ExportVRML_File().

from_quat()

static void from_quat ( double  q[4], double  rot[4]  )

static

Definition at line 1386 of file export_vrml.cpp.

{
    rot[3] = acos( q[3] ) * 2;

    for( int i = 0; i < 3; i++ )
        rot[i] = q[i] / sin( rot[3] / 2 );
}

Referenced by export_vrml_footprint().

GetLayer()

static bool GetLayer ( MODEL_VRML &  aModel, LAYER_NUM  layer, VRML_LAYER **  vlayer  )

static

Definition at line 287 of file export_vrml.cpp.

{
    switch( layer )
    {
    case B_Cu:    *vlayer = &aModel.m_bot_copper; return true;
    case F_Cu:    *vlayer = &aModel.m_top_copper; return true;
    case B_SilkS: *vlayer = &aModel.m_bot_silk;   return true;
    case F_SilkS: *vlayer = &aModel.m_top_silk;   return true;
    default:                                      return false;
    }
}

References B_Cu, B_SilkS, F_Cu, F_SilkS, MODEL_VRML::m_bot_copper, MODEL_VRML::m_bot_silk, MODEL_VRML::m_top_copper, and MODEL_VRML::m_top_silk.

Referenced by SCH_EAGLE_PLUGIN::addBusEntries(), BuildBoardPolygonOutlines(), BuildFootprintPolygonOutlines(), export_vrml_arc(), export_vrml_circle(), export_vrml_line(), export_vrml_polygon(), export_vrml_zones(), EE_COLLECTOR::IsCorner(), FOOTPRINT::IsFlipped(), CONVERT_TOOL::LinesToPoly(), DIALOG_FOOTPRINT_FP_EDITOR::OnAddField(), and DIALOG_FOOTPRINT_PROPERTIES::OnAddField().

getSGColor()

static SGNODE* getSGColor ( VRML_COLOR_INDEX  colorIdx )

static

Definition at line 1741 of file export_vrml.cpp.

{
    if( colorIdx == -1 )
        colorIdx = VRML_COLOR_PCB;
    else if( colorIdx == VRML_COLOR_LAST )
        return NULL;

    if( sgmaterial[colorIdx] )
        return sgmaterial[colorIdx];

    IFSG_APPEARANCE vcolor( (SGNODE*) NULL );
    VRML_COLOR* cp = &colors[colorIdx];

    vcolor.SetSpecular( cp->spec_red, cp->spec_grn, cp->spec_blu );
    vcolor.SetDiffuse( cp->diffuse_red, cp->diffuse_grn, cp->diffuse_blu );
    vcolor.SetShininess( cp->shiny );
    // NOTE: XXX - replace with a better equation; using this definition
    // of ambient will not yield the best results
    vcolor.SetAmbient( cp->ambient, cp->ambient, cp->ambient );
    vcolor.SetTransparency( cp->transp );

    sgmaterial[colorIdx] = vcolor.GetRawPtr();

    return sgmaterial[colorIdx];
}

References VRML_COLOR::ambient, colors, VRML_COLOR::diffuse_blu, VRML_COLOR::diffuse_grn, VRML_COLOR::diffuse_red, IFSG_NODE::GetRawPtr(), NULL, IFSG_APPEARANCE::SetAmbient(), IFSG_APPEARANCE::SetDiffuse(), IFSG_APPEARANCE::SetShininess(), IFSG_APPEARANCE::SetSpecular(), IFSG_APPEARANCE::SetTransparency(), sgmaterial, VRML_COLOR::shiny, VRML_COLOR::spec_blu, VRML_COLOR::spec_grn, VRML_COLOR::spec_red, VRML_COLOR::transp, VRML_COLOR_LAST, and VRML_COLOR_PCB.

Referenced by create_vrml_plane(), and create_vrml_shell().

vrml_text_callback()

static void vrml_text_callback ( int  x0, int  y0, int  xf, int  yf, void *  aData  )

static

Definition at line 781 of file export_vrml.cpp.

{
    LAYER_NUM m_text_layer = model_vrml->m_text_layer;
    int m_text_width = model_vrml->m_text_width;

    export_vrml_line( *model_vrml, m_text_layer,
                      x0 * BOARD_SCALE, y0 * BOARD_SCALE,
                      xf * BOARD_SCALE, yf * BOARD_SCALE,
                      m_text_width * BOARD_SCALE );
}

References BOARD_SCALE, export_vrml_line(), MODEL_VRML::m_text_layer, MODEL_VRML::m_text_width, and model_vrml.

Referenced by export_vrml_fp_text(), and export_vrml_pcbtext().

write_layers()

static void write_layers ( MODEL_VRML &  aModel, BOARD *  aPcb, const char *  aFileName, OSTREAM *  aOutputFile  )

static

Definition at line 409 of file export_vrml.cpp.

{
    // VRML_LAYER board;
    aModel.m_board.Tesselate( &aModel.m_holes );
    double brdz = aModel.m_brd_thickness / 2.0
                  - ( Millimeter2iu( ART_OFFSET / 2.0 ) ) * BOARD_SCALE;

    if( USE_INLINES )
    {
        write_triangle_bag( *aOutputFile, aModel.GetColor( VRML_COLOR_PCB ),
                            &aModel.m_board, false, false, brdz, -brdz );
    }
    else
    {
        create_vrml_shell( aModel.m_OutputPCB, VRML_COLOR_PCB, &aModel.m_board, brdz, -brdz );
    }

    if( aModel.m_plainPCB )
    {
        if( !USE_INLINES )
            S3D::WriteVRML( aFileName, true, aModel.m_OutputPCB.GetRawPtr(), USE_DEFS, true );

        return;
    }

    // VRML_LAYER m_top_copper;
    aModel.m_top_copper.Tesselate( &aModel.m_holes );

    if( USE_INLINES )
    {
        write_triangle_bag( *aOutputFile, aModel.GetColor( VRML_COLOR_TRACK ),
                            &aModel.m_top_copper, true, true,
                            aModel.GetLayerZ( F_Cu ), 0 );
    }
    else
    {
        create_vrml_plane( aModel.m_OutputPCB, VRML_COLOR_TRACK, &aModel.m_top_copper,
                           aModel.GetLayerZ( F_Cu ), true );
    }

    // VRML_LAYER m_top_tin;
    aModel.m_top_tin.Tesselate( &aModel.m_holes );

    if( USE_INLINES )
    {
        write_triangle_bag( *aOutputFile, aModel.GetColor( VRML_COLOR_TIN ),
                            &aModel.m_top_tin, true, true,
                            aModel.GetLayerZ( F_Cu ) + Millimeter2iu( ART_OFFSET / 2.0 ) * BOARD_SCALE,
                            0 );
    }
    else
    {
        create_vrml_plane( aModel.m_OutputPCB, VRML_COLOR_TIN, &aModel.m_top_tin,
                           aModel.GetLayerZ( F_Cu ) + Millimeter2iu( ART_OFFSET / 2.0 ) * BOARD_SCALE,
                           true );
    }

    // VRML_LAYER m_bot_copper;
    aModel.m_bot_copper.Tesselate( &aModel.m_holes );

    if( USE_INLINES )
    {
        write_triangle_bag( *aOutputFile, aModel.GetColor( VRML_COLOR_TRACK ),
                            &aModel.m_bot_copper, true, false,
                            aModel.GetLayerZ( B_Cu ), 0 );
    }
    else
    {
        create_vrml_plane( aModel.m_OutputPCB, VRML_COLOR_TRACK, &aModel.m_bot_copper,
                           aModel.GetLayerZ( B_Cu ), false );
    }

    // VRML_LAYER m_bot_tin;
    aModel.m_bot_tin.Tesselate( &aModel.m_holes );

    if( USE_INLINES )
    {
        write_triangle_bag( *aOutputFile, aModel.GetColor( VRML_COLOR_TIN ),
                            &aModel.m_bot_tin, true, false,
                            aModel.GetLayerZ( B_Cu )
                            - Millimeter2iu( ART_OFFSET / 2.0 ) * BOARD_SCALE,
                            0 );
    }
    else
    {
        create_vrml_plane( aModel.m_OutputPCB, VRML_COLOR_TIN, &aModel.m_bot_tin,
                           aModel.GetLayerZ( B_Cu ) - Millimeter2iu( ART_OFFSET / 2.0 ) * BOARD_SCALE,
                           false );
    }

    // VRML_LAYER PTH;
    aModel.m_plated_holes.Tesselate( NULL, true );

    if( USE_INLINES )
    {
        write_triangle_bag( *aOutputFile, aModel.GetColor( VRML_COLOR_TIN ),
                            &aModel.m_plated_holes, false, false,
                            aModel.GetLayerZ( F_Cu ) + Millimeter2iu( ART_OFFSET / 2.0 ) * BOARD_SCALE,
                            aModel.GetLayerZ( B_Cu ) - Millimeter2iu( ART_OFFSET / 2.0 ) * BOARD_SCALE );
    }
    else
    {
        create_vrml_shell( aModel.m_OutputPCB, VRML_COLOR_TIN, &aModel.m_plated_holes,
                           aModel.GetLayerZ( F_Cu ) + Millimeter2iu( ART_OFFSET / 2.0 ) * BOARD_SCALE,
                           aModel.GetLayerZ( B_Cu ) - Millimeter2iu( ART_OFFSET / 2.0 ) * BOARD_SCALE );
    }

    // VRML_LAYER m_top_silk;
    aModel.m_top_silk.Tesselate( &aModel.m_holes );

    if( USE_INLINES )
    {
        write_triangle_bag( *aOutputFile, aModel.GetColor( VRML_COLOR_SILK ), &aModel.m_top_silk,
                            true, true, aModel.GetLayerZ( F_SilkS ), 0 );
    }
    else
    {
        create_vrml_plane( aModel.m_OutputPCB, VRML_COLOR_SILK, &aModel.m_top_silk,
                           aModel.GetLayerZ( F_SilkS ), true );
    }

    // VRML_LAYER m_bot_silk;
    aModel.m_bot_silk.Tesselate( &aModel.m_holes );

    if( USE_INLINES )
    {
        write_triangle_bag( *aOutputFile, aModel.GetColor( VRML_COLOR_SILK ), &aModel.m_bot_silk,
                            true, false, aModel.GetLayerZ( B_SilkS ), 0 );
    }
    else
    {
        create_vrml_plane( aModel.m_OutputPCB, VRML_COLOR_SILK, &aModel.m_bot_silk,
                           aModel.GetLayerZ( B_SilkS ), false );
    }

    if( !USE_INLINES )
        S3D::WriteVRML( aFileName, true, aModel.m_OutputPCB.GetRawPtr(), true, true );
}

References ART_OFFSET, B_Cu, B_SilkS, BOARD_SCALE, create_vrml_plane(), create_vrml_shell(), F_Cu, F_SilkS, MODEL_VRML::GetColor(), MODEL_VRML::GetLayerZ(), IFSG_NODE::GetRawPtr(), MODEL_VRML::m_board, MODEL_VRML::m_bot_copper, MODEL_VRML::m_bot_silk, MODEL_VRML::m_bot_tin, MODEL_VRML::m_brd_thickness, MODEL_VRML::m_holes, MODEL_VRML::m_OutputPCB, MODEL_VRML::m_plainPCB, MODEL_VRML::m_plated_holes, MODEL_VRML::m_top_copper, MODEL_VRML::m_top_silk, MODEL_VRML::m_top_tin, Millimeter2iu(), NULL, USE_DEFS, USE_INLINES, VRML_COLOR_PCB, VRML_COLOR_SILK, VRML_COLOR_TIN, VRML_COLOR_TRACK, write_triangle_bag(), and S3D::WriteVRML().

Referenced by PCB_EDIT_FRAME::ExportVRML_File().

write_triangle_bag()

static void write_triangle_bag ( std::ostream &  aOut_file, const VRML_COLOR &  aColor, VRML_LAYER *  aLayer, bool  aPlane, bool  aTop, double  aTop_z, double  aBottom_z  )

static

Definition at line 305 of file export_vrml.cpp.

{
    /* A lot of nodes are not required, but blender sometimes chokes
     * without them */
    static const char* shape_boiler[] =
    {
        "Transform {\n",
        "  children [\n",
        "    Group {\n",
        "      children [\n",
        "        Shape {\n",
        "          appearance Appearance {\n",
        "            material Material {\n",
        0,                                      // Material marker
        "            }\n",
        "          }\n",
        "          geometry IndexedFaceSet {\n",
        "            solid TRUE\n",
        "            coord Coordinate {\n",
        "              point [\n",
        0,                                      // Coordinates marker
        "              ]\n",
        "            }\n",
        "            coordIndex [\n",
        0,                                      // Index marker
        "            ]\n",
        "          }\n",
        "        }\n",
        "      ]\n",
        "    }\n",
        "  ]\n",
        "}\n",
        0    // End marker
    };

    int marker_found = 0, lineno = 0;

    while( marker_found < 4 )
    {
        if( shape_boiler[lineno] )
            aOut_file << shape_boiler[lineno];
        else
        {
            marker_found++;

            switch( marker_found )
            {
            case 1:    // Material marker
            {
                std::streamsize lastPrecision = aOut_file.precision();
                aOut_file << "              diffuseColor " << std::setprecision(3);
                aOut_file << aColor.diffuse_red << " ";
                aOut_file << aColor.diffuse_grn << " ";
                aOut_file << aColor.diffuse_blu << "\n";

                aOut_file << "              specularColor ";
                aOut_file << aColor.spec_red << " ";
                aOut_file << aColor.spec_grn << " ";
                aOut_file << aColor.spec_blu << "\n";

                aOut_file << "              emissiveColor ";
                aOut_file << aColor.emit_red << " ";
                aOut_file << aColor.emit_grn << " ";
                aOut_file << aColor.emit_blu << "\n";

                aOut_file << "              ambientIntensity " << aColor.ambient << "\n";
                aOut_file << "              transparency " << aColor.transp << "\n";
                aOut_file << "              shininess " << aColor.shiny << "\n";
                aOut_file.precision( lastPrecision );
            }
                break;

            case 2:

                if( aPlane )
                    aLayer->WriteVertices( aTop_z, aOut_file, PRECISION );
                else
                    aLayer->Write3DVertices( aTop_z, aBottom_z, aOut_file, PRECISION );

                aOut_file << "\n";
                break;

            case 3:

                if( aPlane )
                    aLayer->WriteIndices( aTop, aOut_file );
                else
                    aLayer->Write3DIndices( aOut_file );

                aOut_file << "\n";
                break;

            default:
                break;
            }
        }

        lineno++;
    }
}

References VRML_COLOR::ambient, VRML_COLOR::diffuse_blu, VRML_COLOR::diffuse_grn, VRML_COLOR::diffuse_red, VRML_COLOR::emit_blu, VRML_COLOR::emit_grn, VRML_COLOR::emit_red, PRECISION, VRML_COLOR::shiny, VRML_COLOR::spec_blu, VRML_COLOR::spec_grn, VRML_COLOR::spec_red, and VRML_COLOR::transp.

Referenced by write_layers().

Variable Documentation

BOARD_SCALE

double BOARD_SCALE

static

Definition at line 67 of file export_vrml.cpp.

Referenced by compute_layer_Zs(), export_vrml_board(), export_vrml_drawsegment(), export_vrml_footprint(), export_vrml_fp_shape(), export_vrml_pad(), export_vrml_padshape(), export_vrml_polygon(), export_vrml_tracks(), export_vrml_via(), export_vrml_zones(), PCB_EDIT_FRAME::ExportVRML_File(), vrml_text_callback(), and write_layers().

cache

S3D_CACHE* cache

static

Definition at line 62 of file export_vrml.cpp.

Referenced by export_vrml_footprint(), PCB_EDIT_FRAME::ExportVRML_File(), and SCH_BASE_FRAME::GetLibPart().

colors

VRML_COLOR colors[VRML_COLOR_LAST]

static

Definition at line 139 of file export_vrml.cpp.

Referenced by SHAPE::CalcShape(), PL_EDITOR_FRAME::CommonSettingsChanged(), KIGFX::GPU_NONCACHED_MANAGER::EndDrawing(), PCB_MARKER::getColor(), SCH_MARKER::getColor(), MODEL_VRML::GetColor(), DIALOG_PLOT_SCHEMATIC::getPlotOptions(), getSGColor(), EDA_3D_VIEWER::LoadSettings(), MODEL_VRML::MODEL_VRML(), EDA_3D_VIEWER::SaveSettings(), EDA_3D_VIEWER::Set3DBoardBodyColorFromUser(), EDA_3D_VIEWER::Set3DCopperColorFromUser(), EDA_3D_VIEWER::Set3DSilkScreenColorFromUser(), EDA_3D_VIEWER::Set3DSolderMaskColorFromUser(), and EDA_3D_VIEWER::Set3DSolderPasteColorFromUser().

model_vrml

MODEL_VRML* model_vrml

static

Definition at line 282 of file export_vrml.cpp.

Referenced by export_vrml_fp_text(), export_vrml_pcbtext(), PCB_EDIT_FRAME::ExportVRML_File(), and vrml_text_callback().

PRECISION

const int PRECISION = 6

static

Definition at line 68 of file export_vrml.cpp.

Referenced by export_vrml_footprint(), PCB_EDIT_FRAME::ExportVRML_File(), and write_triangle_bag().

PROJ_DIR

wxString PROJ_DIR

static

Definition at line 70 of file export_vrml.cpp.

Referenced by PCB_EDIT_FRAME::ExportVRML_File().

sgmaterial

SGNODE* sgmaterial[VRML_COLOR_LAST] = { NULL }

static

Definition at line 140 of file export_vrml.cpp.

Referenced by getSGColor(), and MODEL_VRML::~MODEL_VRML().

SUBDIR_3D

wxString SUBDIR_3D

static

Definition at line 69 of file export_vrml.cpp.

Referenced by export_vrml_footprint(), and PCB_EDIT_FRAME::ExportVRML_File().

USE_DEFS

bool USE_DEFS

static

Definition at line 64 of file export_vrml.cpp.

Referenced by export_vrml_footprint(), PCB_EDIT_FRAME::ExportVRML_File(), and write_layers().

USE_INLINES

bool USE_INLINES

static

Definition at line 63 of file export_vrml.cpp.

Referenced by export_vrml_footprint(), PCB_EDIT_FRAME::ExportVRML_File(), and write_layers().

USE_RELPATH

bool USE_RELPATH

static

Definition at line 65 of file export_vrml.cpp.

Referenced by export_vrml_footprint(), and PCB_EDIT_FRAME::ExportVRML_File().

WORLD_SCALE

double WORLD_SCALE = 1.0

static

Definition at line 66 of file export_vrml.cpp.

Referenced by PCB_EDIT_FRAME::ExportVRML_File(), and MODEL_VRML::SetScale().