458 lines
17 KiB
C++
458 lines
17 KiB
C++
/*
|
|
* file: vrml_layer.h
|
|
*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2013-2017 Cirilo Bernardo
|
|
* Copyright (C) 2021 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, you may find one here:
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
* or you may search the http://www.gnu.org website for the version 2 license,
|
|
* or you may write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
/**
|
|
* @file vrml_layer.h
|
|
*/
|
|
|
|
/*
|
|
* Classes and structures to support the tesselation of a PCB for VRML output.
|
|
*/
|
|
|
|
#ifndef VRML_LAYER_H
|
|
#define VRML_LAYER_H
|
|
|
|
// Apple, in their infinite wisdom, has decided to mark OpenGL as deprecated.
|
|
// Luckily we can silence warnings about its deprecation.
|
|
#ifdef __APPLE__
|
|
#define GL_SILENCE_DEPRECATION 1
|
|
#endif
|
|
|
|
#include <wx/glcanvas.h> // CALLBACK definition, needed on Windows
|
|
// also needed on OSX to define __DARWIN__
|
|
|
|
#ifdef __WXMAC__
|
|
# ifdef __DARWIN__
|
|
# include <OpenGL/glu.h>
|
|
# else
|
|
# include <glu.h>
|
|
# endif
|
|
#else
|
|
# include <GL/glu.h>
|
|
#endif
|
|
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <list>
|
|
#include <utility>
|
|
|
|
#ifndef M_PI2
|
|
#define M_PI2 ( M_PI / 2.0 )
|
|
#endif
|
|
|
|
#ifndef M_PI4
|
|
#define M_PI4 ( M_PI / 4.0 )
|
|
#endif
|
|
|
|
|
|
struct VERTEX_3D
|
|
{
|
|
double x;
|
|
double y;
|
|
int i; // vertex index
|
|
int o; // vertex order
|
|
bool pth; // true for plate-through hole
|
|
};
|
|
|
|
struct TRIPLET_3D
|
|
{
|
|
int i1, i2, i3;
|
|
|
|
TRIPLET_3D( int p1, int p2, int p3 )
|
|
{
|
|
i1 = p1;
|
|
i2 = p2;
|
|
i3 = p3;
|
|
}
|
|
};
|
|
|
|
|
|
class VRML_LAYER
|
|
{
|
|
public:
|
|
VRML_LAYER();
|
|
virtual ~VRML_LAYER();
|
|
|
|
/**
|
|
* Retrieve the parameters used in calculating the number of vertices in an arc.
|
|
*
|
|
* @param aMaxSeg is the maximum number of segments for an arc with cords of length aMinLength.
|
|
* @param aMinLength is the minimum length of cords in an arc.
|
|
* @param aMaxLength is the maximum length of cords in an arc.
|
|
*/
|
|
void GetArcParams( int& aMaxSeg, double& aMinLength, double& aMaxLength );
|
|
|
|
/**
|
|
* Set the parameters used in calculating the number of vertices in an arc.
|
|
*
|
|
* The default settings are reasonable for rendering for unit lengths of 1mm.
|
|
*
|
|
* @param aMaxSeg is the maximum number of segments for an arc with cords of length aMinLength.
|
|
* @param aMinLength is the minimum length of cords in an arc.
|
|
* @param aMaxLength is the maximum length of cords in an arc.
|
|
* @return true if the parameters were accepted.
|
|
*/
|
|
bool SetArcParams( int aMaxSeg, double aMinLength, double aMaxLength );
|
|
|
|
/**
|
|
* Reset the parameters used in calculating the number of vertices in an arc to default values.
|
|
*/
|
|
void ResetArcParams();
|
|
|
|
/**
|
|
* Erase all data except for arc parameters.
|
|
*/
|
|
void Clear( void );
|
|
|
|
/**
|
|
* @return the total number of vertices indexed.
|
|
*/
|
|
int GetSize( void );
|
|
|
|
/**
|
|
* @return the number of stored contours.
|
|
*/
|
|
int GetNContours( void )
|
|
{
|
|
return contours.size();
|
|
}
|
|
|
|
/**
|
|
* Create a new list of vertices and returns an index to the list.
|
|
*
|
|
* @param aPlatedHole is true if the new contour will represent a plated hole.
|
|
* @return index to the list or -1 if the operation failed.
|
|
*/
|
|
int NewContour( bool aPlatedHole = false );
|
|
|
|
/**
|
|
* Add a point to the requested contour.
|
|
*
|
|
* @param aContour is an index previously returned by a call to NewContour().
|
|
* @param aXpos is the X coordinate of the vertex.
|
|
* @param aYpos is the Y coordinate of the vertex.
|
|
* @return true if the vertex was added.
|
|
*/
|
|
bool AddVertex( int aContourID, double aXpos, double aYpos );
|
|
|
|
/**
|
|
* Check the winding of a contour and ensures that it is a hole or a solid depending on the
|
|
* value of @param hole.
|
|
*
|
|
* @param aContour is an index to a contour as returned by NewContour().
|
|
* @param aHoleFlag determines if the contour must be a hole.
|
|
* @return true if the operation succeeded.
|
|
*/
|
|
bool EnsureWinding( int aContourID, bool aHoleFlag );
|
|
|
|
/**
|
|
* Add a circular contour to the specified (empty) contour.
|
|
*
|
|
* @param aXpos is the X coordinate of the hole center.
|
|
* @param aYpos is the Y coordinate of the hole center.
|
|
* @param aRadius is the radius of the hole.
|
|
* @param aContourID is the contour index.
|
|
* @param aHoleFlag determines if the contour to be created is a cutout.
|
|
* @return true if the new contour was successfully created.
|
|
*/
|
|
bool AppendCircle( double aXpos, double aYpos, double aRadius, int aContourID,
|
|
bool aHoleFlag = false );
|
|
|
|
/**
|
|
* Create a circular contour and adds it to the internal list.
|
|
*
|
|
* @param aXpos is the X coordinate of the hole center.
|
|
* @param aYpos is the Y coordinate of the hole center.
|
|
* @param aRadius is the radius of the hole.
|
|
* @param aHoleFlag determines if the contour to be created is a cutout.
|
|
* @param aPlatedHole is true if this is a plated hole.
|
|
* @return true if the new contour was successfully created.
|
|
*/
|
|
bool AddCircle( double aXpos, double aYpos, double aRadius, bool aHoleFlag = false,
|
|
bool aPlatedHole = false );
|
|
|
|
/**
|
|
* Create and add a slot feature to the list of contours.
|
|
*
|
|
* @param aCenterX is the X coordinate of the slot's center.
|
|
* @param aCenterY is the Y coordinate of the slot's center.
|
|
* @param aSlotLength is the length of the slot along the major axis.
|
|
* @param aSlotWidth is the width of the slot along the minor axis.
|
|
* @param aAngle (degrees) is the orientation of the slot.
|
|
* @param aHoleFlag determines whether the slot is a hole or a solid.
|
|
* @param aPlatedHole is true if this is a plated slot.
|
|
* @return true if the slot was successfully created.
|
|
*/
|
|
bool AddSlot( double aCenterX, double aCenterY, double aSlotLength, double aSlotWidth,
|
|
double aAngle, bool aHoleFlag = false, bool aPlatedHole = false );
|
|
|
|
/**
|
|
* Add an arc to the specified contour.
|
|
*
|
|
* @param aCenterX is the X coordinate of the arc's center.
|
|
* @param aCenterY is the Y coordinate of the arc's center.
|
|
* @param aRadius is the radius of the arc.
|
|
* @param aStartAngle (degrees) is the starting angle of the arc.
|
|
* @param aAngle (degrees) is the measure of the arc.
|
|
* @param aContourID is the contour's index.
|
|
* @return true if the slot was successfully created.
|
|
*/
|
|
bool AppendArc( double aCenterX, double aCenterY, double aRadius, double aStartAngle,
|
|
double aAngle, int aContourID );
|
|
|
|
/**
|
|
* Create a slotted arc and adds it to the internal list of contours.
|
|
*
|
|
* @param aCenterX is the X coordinate of the arc's center.
|
|
* @param aCenterY is the Y coordinate of the arc's center.
|
|
* @param aStartX is the X coordinate of the starting point.
|
|
* @param aStartY is the Y coordinate of the starting point.
|
|
* @param aArcWidth is the width of the arc.
|
|
* @param aAngle is the included angle (degrees).
|
|
* @param aHoleFlag determines whether the arc is to be a hole or a solid.
|
|
* @param aPlatedHole is true if this is a plated slotted arc.
|
|
* @return true if the feature was successfully created.
|
|
*/
|
|
bool AddArc( double aCenterX, double aCenterY, double aStartX, double aStartY,
|
|
double aArcWidth, double aAngle, bool aHoleFlag = false,
|
|
bool aPlatedHole = false );
|
|
|
|
/**
|
|
* Create an arbitrary polygon and adds it to the list of contours.
|
|
*
|
|
* @param aPolySet is the set of polygon points.
|
|
* @param aCenterX is the X coordinate of the polygon's center.
|
|
* @param aCenterY is the Y coordinate of the polygon's center.
|
|
* @param aAngle is the rotation angle (degrees) of the pad.
|
|
*/
|
|
bool AddPolygon( const std::vector< wxRealPoint >& aPolySet, double aCenterX, double aCenterY,
|
|
double aAngle );
|
|
|
|
/**
|
|
* Create a list of outline vertices as well as the vertex sets required to render the surface.
|
|
*
|
|
* @param holes is an optional pointer to cutouts to be imposed on the surface.
|
|
* @param aHolesOnly is true if the outline contains only holes.
|
|
* @return true if the operation succeeded.
|
|
*/
|
|
bool Tesselate( VRML_LAYER* holes = NULL, bool aHolesOnly = false );
|
|
|
|
/**
|
|
* Write out the list of vertices required to render a planar surface.
|
|
*
|
|
* @param aZcoord is the Z coordinate of the plane.
|
|
* @param aOutFile is the file to write to.
|
|
* @param aPrecision is the precision of the output coordinates.
|
|
* @return true if the operation succeeded.
|
|
*/
|
|
bool WriteVertices( double aZcoord, std::ostream& aOutFile, int aPrecision );
|
|
|
|
/**
|
|
* Write out the list of vertices required to render an extruded solid.
|
|
*
|
|
* @param aTopZ is the Z coordinate of the top plane.
|
|
* @param aBottomZ is the Z coordinate of the bottom plane.
|
|
* @param aOutFile is the file to write to.
|
|
* @param aPrecision is the precision of the output coordinates.
|
|
* @return true if the operation succeeded.
|
|
*/
|
|
bool Write3DVertices( double aTopZ, double aBottomZ, std::ostream& aOutFile, int aPrecision );
|
|
|
|
/**
|
|
* Write out the vertex sets required to render a planar surface.
|
|
*
|
|
* @param aTopFlag is true if the surface is to be visible from above; if false the surface
|
|
* will be visible from below.
|
|
* @param aOutFile is the file to write to.
|
|
* @return true if the operation succeeded.
|
|
*/
|
|
bool WriteIndices( bool aTopFlag, std::ostream& aOutFile );
|
|
|
|
/**
|
|
* Write out the vertex sets required to render an extruded solid.
|
|
*
|
|
* @param aOutFile is the file to write to.
|
|
* @param aIncludePlatedHoles is true if holes marked as plated should be rendered. Default
|
|
* is false since the user will usually render these holes in a
|
|
* different color.
|
|
* @return true if the operation succeeded.
|
|
*/
|
|
bool Write3DIndices( std::ostream& aOutFile, bool aIncludePlatedHoles = false );
|
|
|
|
/**
|
|
* Add an extra vertex as required by the GLU tesselator.
|
|
*
|
|
* @param aXpos is the X coordinate of the newly created point.
|
|
* @param aYpos is the Y coordinate of the newly created point.
|
|
* @param aPlatedHole is true if this point is part of a plated hole.
|
|
* @return is the new vertex or NULL if a vertex could not be created.
|
|
*/
|
|
VERTEX_3D* AddExtraVertex( double aXpos, double aYpos, bool aPlatedHole );
|
|
|
|
/**
|
|
* Invoked by the GLU tesselator callback to notify this object of the type of GL command
|
|
* which is applicable to the upcoming vertex list.
|
|
*
|
|
* @param cmd is the GL command.
|
|
*/
|
|
void glStart( GLenum cmd );
|
|
|
|
/**
|
|
* Invoked by the GLU tesselator callback; the supplied vertex is added to the internal list
|
|
* of vertices awaiting processing upon execution of glEnd()
|
|
*
|
|
* @param vertex is a vertex forming part of the GL command as previously set by glStart.
|
|
*/
|
|
void glPushVertex( VERTEX_3D* vertex );
|
|
|
|
/**
|
|
* Invoked by the GLU tesselator callback to notify this object that the vertex list is
|
|
* complete and ready for processing.
|
|
*/
|
|
void glEnd( void );
|
|
|
|
/**
|
|
* Set the error message according to the specified OpenGL error.
|
|
*/
|
|
void SetGLError( GLenum error_id );
|
|
|
|
/**
|
|
* Inserts all contours into the given tesselator.
|
|
*
|
|
* This results in the renumbering of all vertices from \a start. Take care when using
|
|
* this call since tesselators cannot work on the internal data concurrently.
|
|
*
|
|
* @param start is the starting number for vertex indices.
|
|
* @param tess is a pointer to a GLU Tesselator object.
|
|
* @return the number of vertices exported.
|
|
*/
|
|
int Import( int start, GLUtesselator* aTesselator );
|
|
|
|
/**
|
|
* Return a pointer to the requested vertex or NULL if no such vertex exists.
|
|
*
|
|
* @param aPointIndex is a vertex index.
|
|
* @return the requested vertex or NULL
|
|
*/
|
|
VERTEX_3D* GetVertexByIndex( int aPointIndex );
|
|
|
|
/**
|
|
* @return the error message related to the last failed operation.
|
|
*/
|
|
const std::string& GetError( void );
|
|
|
|
void SetVertexOffsets( double aXoffset, double aYoffset );
|
|
|
|
/**
|
|
* Allocate and populate the 3D vertex and index lists with triangular vertices which may
|
|
* be used for rendering a volume.
|
|
*
|
|
* @param aVertexList will store the vertices.
|
|
* @param aIndexPlane will store the indices for the top + bottom planes.
|
|
* @param aIndexSide will store the indices for the vertical wall.
|
|
* @param aTopZ is the top plane of the model.
|
|
* @param aBotZ is the bottom plane of the model.
|
|
*/
|
|
bool Get3DTriangles( std::vector< double >& aVertexList, std::vector< int >& aIndexPlane,
|
|
std::vector< int >& aIndexSide, double aTopZ, double aBotZ );
|
|
|
|
/**
|
|
* Allocate and populate the 3D vertex and index lists with triangular vertices which may
|
|
* be used for rendering a plane.
|
|
*
|
|
* @param aVertexList will store the vertices.
|
|
* @param aIndexPlane will store the indices for the plane.
|
|
* @param aHeight is the plane of the model.
|
|
* @param aTopPlane is true if the plane is a top plane (false = reverse indices).
|
|
*/
|
|
bool Get2DTriangles( std::vector< double >& aVertexList, std::vector< int > &aIndexPlane,
|
|
double aHeight, bool aTopPlane );
|
|
|
|
|
|
private:
|
|
void clearTmp( void ); // clear ephemeral data used by the tesselation routine
|
|
|
|
// add a triangular facet (triplet) to the output index list
|
|
bool addTriplet( VERTEX_3D* p0, VERTEX_3D* p1, VERTEX_3D* p2 );
|
|
|
|
// retrieve a vertex given its index; the vertex may be contained in the
|
|
// vertices vector, extra_verts vector, or foreign VRML_LAYER object
|
|
VERTEX_3D* getVertexByIndex( int aPointIndex, VRML_LAYER* holes );
|
|
|
|
void processFan( void ); // process a GL_TRIANGLE_FAN list
|
|
void processStrip( void ); // process a GL_TRIANGLE_STRIP list
|
|
void processTri( void ); // process a GL_TRIANGLES list
|
|
|
|
void pushVertices( bool holes ); // push the internal vertices
|
|
bool pushOutline( VRML_LAYER* holes ); // push the outline vertices
|
|
|
|
// calculate number of sides on an arc (angle is in radians)
|
|
int calcNSides( double aRadius, double aAngle );
|
|
|
|
// returns the number of solid or hole contours
|
|
int checkNContours( bool holes );
|
|
|
|
public:
|
|
/// set to true when a fault is encountered during tesselation
|
|
bool Fault;
|
|
|
|
private:
|
|
// Arc parameters
|
|
int maxArcSeg; // maximum number of arc segments in a small circle
|
|
double minSegLength; // min. segment length
|
|
double maxSegLength; // max. segment length
|
|
|
|
// Vertex offsets to work around a suspected GLU tesselator bug
|
|
double offsetX;
|
|
double offsetY;
|
|
|
|
bool fix; // when true, no more vertices may be added by the user
|
|
int idx; // vertex index (number of contained vertices)
|
|
int ord; // vertex order (number of ordered vertices)
|
|
std::vector<VERTEX_3D*> vertices; // vertices of all contours
|
|
std::vector<std::list<int>*> contours; // lists of vertices for each contour
|
|
std::vector<bool>pth; // indicates whether a 'contour' is a PTH or not
|
|
std::vector<bool>solid; // indicates whether a 'contour' is a solid or a hole
|
|
std::vector< double > areas; // area of the contours (positive if winding is CCW)
|
|
std::list<TRIPLET_3D> triplets; // output facet triplet list (triplet of ORDER values)
|
|
std::list<std::list<int>*> outline; // indices for outline outputs (index by ORDER values)
|
|
std::vector<int> ordmap; // mapping of ORDER to INDEX
|
|
|
|
std::string error; // error message
|
|
|
|
int hidx; // number of vertices in the holes
|
|
int eidx; // index for extra vertices
|
|
std::vector<VERTEX_3D*> extra_verts; // extra vertices added for outlines and facets
|
|
std::vector<VERTEX_3D*> vlist; // vertex list for the GL command in progress
|
|
VRML_LAYER* pholes; // pointer to another layer object used for tesselation;
|
|
// this object is normally expected to hold only holes
|
|
|
|
GLUtesselator* tess; // local instance of the GLU tesselator
|
|
GLenum glcmd; // current GL command type ( fan, triangle, tri-strip, loop )
|
|
};
|
|
|
|
#endif // VRML_LAYER_H
|