KiCad PCB EDA Suite
RENDER_3D_OPENGL Class Reference

Object to render the board using openGL. More...

#include <render_3d_opengl.h>

Inheritance diagram for RENDER_3D_OPENGL:
RENDER_3D_BASE

Public Member Functions

 RENDER_3D_OPENGL (EDA_3D_CANVAS *aCanvas, BOARD_ADAPTER &aAdapter, CAMERA &aCamera)
 
 ~RENDER_3D_OPENGL ()
 
void SetCurWindowSize (const wxSize &aSize) override
 Before each render, the canvas will tell the render what is the size of its windows, so render can take actions if it changed. More...
 
bool Redraw (bool aIsMoving, REPORTER *aStatusReporter, REPORTER *aWarningReporter) override
 Redraw the view. More...
 
int GetWaitForEditingTimeOut () override
 Give the interface the time (in ms) that it should wait for editing or movements before (this works for display preview mode). More...
 
void SetCurrentRollOverItem (BOARD_ITEM *aRollOverItem)
 
void Load3dModelsIfNeeded ()
 Load footprint models if they are not already loaded, i.e. More...
 
void ReloadRequest ()
 
bool IsReloadRequestPending () const
 Query if there is a pending reload request. More...
 
void SetBusyIndicatorFactory (BUSY_INDICATOR::FACTORY aNewFactory)
 Set a new busy indicator factory. More...
 

Protected Member Functions

std::unique_ptr< BUSY_INDICATORCreateBusyIndicator () const
 Return a created busy indicator, if a factory has been set, else a null pointer. More...
 

Protected Attributes

EDA_3D_CANVASm_canvas
 Settings reference in use for this render. More...
 
BOARD_ADAPTERm_boardAdapter
 
CAMERAm_camera
 Flag if the opengl specific for this render was already initialized. More...
 
bool m_is_opengl_initialized
 
bool m_reloadRequested
 The window size that this camera is working. More...
 
wxSize m_windowSize
 

Static Protected Attributes

static const wxChar * m_logTrace = wxT( "KI_TRACE_3D_RENDER" )
 Trace mask used to enable or disable the trace output of this class. More...
 

Private Member Functions

OPENGL_RENDER_LISTgenerateHoles (const LIST_OBJECT2D &aListHolesObject2d, const SHAPE_POLY_SET &aPoly, float aZtop, float aZbot, bool aInvertFaces, const BVH_CONTAINER_2D *aThroughHoles=nullptr)
 
OPENGL_RENDER_LISTgenerateLayerList (const BVH_CONTAINER_2D *aContainer, const SHAPE_POLY_SET *aPolyList, PCB_LAYER_ID aLayerId, const BVH_CONTAINER_2D *aThroughHoles=nullptr)
 
void addTopAndBottomTriangles (TRIANGLE_DISPLAY_LIST *aDst, const SFVEC2F &v0, const SFVEC2F &v1, const SFVEC2F &v2, float top, float bot)
 
void addObjectTriangles (const RING_2D *aRing, TRIANGLE_DISPLAY_LIST *aDstLayer, float aZtop, float aZbot)
 
void addObjectTriangles (const POLYGON_4PT_2D *aPoly, TRIANGLE_DISPLAY_LIST *aDstLayer, float aZtop, float aZbot)
 
void addObjectTriangles (const FILLED_CIRCLE_2D *aFilledCircle, TRIANGLE_DISPLAY_LIST *aDstLayer, float aZtop, float aZbot)
 
void addObjectTriangles (const TRIANGLE_2D *aTri, TRIANGLE_DISPLAY_LIST *aDstLayer, float aZtop, float aZbot)
 
void addObjectTriangles (const ROUND_SEGMENT_2D *aSeg, TRIANGLE_DISPLAY_LIST *aDstLayer, float aZtop, float aZbot)
 
void renderSolderMaskLayer (PCB_LAYER_ID aLayerID, float aZPosition, bool aDrawMiddleSegments, bool aSkipRenderHoles)
 
void renderBoardBody (bool aSkipRenderHoles)
 
void getLayerZPos (PCB_LAYER_ID aLayerID, float &aOutZtop, float &aOutZbot) const
 
void generateRing (const SFVEC2F &aCenter, float aInnerRadius, float aOuterRadius, unsigned int aNr_sides_per_circle, std::vector< SFVEC2F > &aInnerContourResult, std::vector< SFVEC2F > &aOuterContourResult, bool aInvertOrder)
 
void generateCylinder (const SFVEC2F &aCenter, float aInnerRadius, float aOuterRadius, float aZtop, float aZbot, unsigned int aNr_sides_per_circle, TRIANGLE_DISPLAY_LIST *aDstLayer)
 
void generateViasAndPads ()
 
void load3dModels (REPORTER *aStatusReporter)
 Load footprint models from the cache and load it to openGL lists in the form of MODEL_3D objects. More...
 
void render3dModels (bool aRenderTopOrBot, bool aRenderTransparentOnly)
 
void render3dModelsSelected (bool aRenderTopOrBot, bool aRenderTransparentOnly, bool aRenderSelectedOnly)
 
void renderFootprint (const FOOTPRINT *aFootprint, bool aRenderTransparentOnly, bool aIsSelected)
 
void setLightFront (bool enabled)
 
void setLightTop (bool enabled)
 
void setLightBottom (bool enabled)
 
void render3dArrows ()
 
void generate3dGrid (GRID3D_TYPE aGridType)
 Create a 3D grid to an OpenGL display list. More...
 
void setupMaterials ()
 
void setCopperMaterial ()
 
void setPlatedCopperAndDepthOffset (PCB_LAYER_ID aLayer_id)
 
void unsetDepthOffset ()
 
void setLayerMaterial (PCB_LAYER_ID aLayerID)
 
SFVEC4F getLayerColor (PCB_LAYER_ID aLayerID)
 
bool initializeOpenGL ()
 
OPENGL_RENDER_LISTcreateBoard (const SHAPE_POLY_SET &aBoardPoly, const BVH_CONTAINER_2D *aThroughHoles=nullptr)
 
void reload (REPORTER *aStatusReporter, REPORTER *aWarningReporter)
 
void setArrowMaterial ()
 
void freeAllLists ()
 

Private Attributes

struct {
   SMATERIAL   m_Paste
 
   SMATERIAL   m_SilkSBot
 
   SMATERIAL   m_SilkSTop
 
   SMATERIAL   m_SolderMask
 
   SMATERIAL   m_EpoxyBoard
 
   SMATERIAL   m_NonPlatedCopper
 
   SMATERIAL   m_Copper
 
   SMATERIAL   m_Plastic
 
   SMATERIAL   m_GrayMaterial
 
m_materials
 
MAP_OGL_DISP_LISTS m_layers
 
OPENGL_RENDER_LISTm_platedPadsFront
 
OPENGL_RENDER_LISTm_platedPadsBack
 
MAP_OGL_DISP_LISTS m_outerLayerHoles
 
MAP_OGL_DISP_LISTS m_innerLayerHoles
 
OPENGL_RENDER_LISTm_board
 
OPENGL_RENDER_LISTm_boardWithHoles
 
OPENGL_RENDER_LISTm_antiBoard
 
OPENGL_RENDER_LISTm_outerThroughHoles
 
OPENGL_RENDER_LISTm_outerViaThroughHoles
 
OPENGL_RENDER_LISTm_outerThroughHoleRings
 
LIST_TRIANGLES m_triangles
 store pointers so can be deleted latter More...
 
GLuint m_circleTexture
 
GLuint m_grid
 oGL list that stores current grid More...
 
GRID3D_TYPE m_lastGridType
 Stores the last grid type. More...
 
OPENGL_RENDER_LISTm_vias
 
OPENGL_RENDER_LISTm_padHoles
 
MAP_3DMODEL m_3dModelMap
 
BOARD_ITEMm_currentRollOverItem
 
SHAPE_POLY_SET m_antiBoardPolys
 The negative polygon representation of the board outline. More...
 

Detailed Description

Object to render the board using openGL.

Definition at line 54 of file render_3d_opengl.h.

Constructor & Destructor Documentation

◆ RENDER_3D_OPENGL()

RENDER_3D_OPENGL::RENDER_3D_OPENGL ( EDA_3D_CANVAS aCanvas,
BOARD_ADAPTER aAdapter,
CAMERA aCamera 
)
explicit

Definition at line 42 of file render_3d_opengl.cpp.

43  :
44  RENDER_3D_BASE( aCanvas, aAdapter, aCamera )
45 {
46  wxLogTrace( m_logTrace, wxT( "RENDER_3D_OPENGL::RENDER_3D_OPENGL" ) );
47 
48  m_layers.clear();
49  m_outerLayerHoles.clear();
50  m_innerLayerHoles.clear();
51  m_triangles.clear();
52  m_board = nullptr;
53  m_antiBoard = nullptr;
54 
55  m_platedPadsFront = nullptr;
56  m_platedPadsBack = nullptr;
57 
58  m_outerThroughHoles = nullptr;
59  m_outerThroughHoleRings = nullptr;
60  m_outerViaThroughHoles = nullptr;
61  m_vias = nullptr;
62  m_padHoles = nullptr;
63 
64  m_circleTexture = 0;
65  m_grid = 0;
67  m_currentRollOverItem = nullptr;
68  m_boardWithHoles = nullptr;
69 
70  m_3dModelMap.clear();
71 }
OPENGL_RENDER_LIST * m_platedPadsBack
OPENGL_RENDER_LIST * m_antiBoard
OPENGL_RENDER_LIST * m_board
OPENGL_RENDER_LIST * m_outerViaThroughHoles
OPENGL_RENDER_LIST * m_boardWithHoles
LIST_TRIANGLES m_triangles
store pointers so can be deleted latter
MAP_OGL_DISP_LISTS m_innerLayerHoles
MAP_OGL_DISP_LISTS m_layers
BOARD_ITEM * m_currentRollOverItem
OPENGL_RENDER_LIST * m_outerThroughHoles
OPENGL_RENDER_LIST * m_vias
RENDER_3D_BASE(EDA_3D_CANVAS *aCanvas, BOARD_ADAPTER &aBoardAdapter, CAMERA &aCamera)
MAP_OGL_DISP_LISTS m_outerLayerHoles
GLuint m_grid
oGL list that stores current grid
static const wxChar * m_logTrace
Trace mask used to enable or disable the trace output of this class.
OPENGL_RENDER_LIST * m_outerThroughHoleRings
OPENGL_RENDER_LIST * m_padHoles
OPENGL_RENDER_LIST * m_platedPadsFront
GRID3D_TYPE m_lastGridType
Stores the last grid type.
MAP_3DMODEL m_3dModelMap

References m_3dModelMap, m_antiBoard, m_board, m_boardWithHoles, m_circleTexture, m_currentRollOverItem, m_grid, m_innerLayerHoles, m_lastGridType, m_layers, RENDER_3D_BASE::m_logTrace, m_outerLayerHoles, m_outerThroughHoleRings, m_outerThroughHoles, m_outerViaThroughHoles, m_padHoles, m_platedPadsBack, m_platedPadsFront, m_triangles, m_vias, and NONE.

◆ ~RENDER_3D_OPENGL()

RENDER_3D_OPENGL::~RENDER_3D_OPENGL ( )

Definition at line 74 of file render_3d_opengl.cpp.

75 {
76  wxLogTrace( m_logTrace, wxT( "RENDER_3D_OPENGL::RENDER_3D_OPENGL" ) );
77 
78  freeAllLists();
79 
80  glDeleteTextures( 1, &m_circleTexture );
81 }
static const wxChar * m_logTrace
Trace mask used to enable or disable the trace output of this class.

References freeAllLists(), m_circleTexture, and RENDER_3D_BASE::m_logTrace.

Member Function Documentation

◆ addObjectTriangles() [1/5]

void RENDER_3D_OPENGL::addObjectTriangles ( const RING_2D aRing,
TRIANGLE_DISPLAY_LIST aDstLayer,
float  aZtop,
float  aZbot 
)
private

Definition at line 115 of file opengl/create_scene.cpp.

117 {
118  const SFVEC2F& center = aRing->GetCenter();
119  const float inner = aRing->GetInnerRadius();
120  const float outer = aRing->GetOuterRadius();
121 
122  std::vector< SFVEC2F > innerContour;
123  std::vector< SFVEC2F > outerContour;
124 
125  generateRing( center, inner, outer, m_boardAdapter.GetCircleSegmentCount( outer * 2.0f ),
126  innerContour, outerContour, false );
127 
128  // This will add the top and bot quads that will form the approximated ring
129  for( unsigned int i = 0; i < ( innerContour.size() - 1 ); ++i )
130  {
131  const SFVEC2F& vi0 = innerContour[i + 0];
132  const SFVEC2F& vi1 = innerContour[i + 1];
133  const SFVEC2F& vo0 = outerContour[i + 0];
134  const SFVEC2F& vo1 = outerContour[i + 1];
135 
136  aDstLayer->m_layer_top_triangles->AddQuad( SFVEC3F( vi1.x, vi1.y, aZtop ),
137  SFVEC3F( vi0.x, vi0.y, aZtop ),
138  SFVEC3F( vo0.x, vo0.y, aZtop ),
139  SFVEC3F( vo1.x, vo1.y, aZtop ) );
140 
141  aDstLayer->m_layer_bot_triangles->AddQuad( SFVEC3F( vi1.x, vi1.y, aZbot ),
142  SFVEC3F( vo1.x, vo1.y, aZbot ),
143  SFVEC3F( vo0.x, vo0.y, aZbot ),
144  SFVEC3F( vi0.x, vi0.y, aZbot ) );
145  }
146 }
BOARD_ADAPTER & m_boardAdapter
float GetInnerRadius() const
Definition: ring_2d.h:47
TRIANGLE_LIST * m_layer_top_triangles
float GetOuterRadius() const
Definition: ring_2d.h:48
glm::vec2 SFVEC2F
Definition: xv3d_types.h:42
void generateRing(const SFVEC2F &aCenter, float aInnerRadius, float aOuterRadius, unsigned int aNr_sides_per_circle, std::vector< SFVEC2F > &aInnerContourResult, std::vector< SFVEC2F > &aOuterContourResult, bool aInvertOrder)
void AddQuad(const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3, const SFVEC3F &aV4)
TRIANGLE_LIST * m_layer_bot_triangles
glm::vec3 SFVEC3F
Definition: xv3d_types.h:44
const SFVEC2F & GetCenter() const
Definition: ring_2d.h:46
unsigned int GetCircleSegmentCount(float aDiameter3DU) const

References TRIANGLE_LIST::AddQuad(), generateRing(), RING_2D::GetCenter(), BOARD_ADAPTER::GetCircleSegmentCount(), RING_2D::GetInnerRadius(), RING_2D::GetOuterRadius(), RENDER_3D_BASE::m_boardAdapter, TRIANGLE_DISPLAY_LIST::m_layer_bot_triangles, and TRIANGLE_DISPLAY_LIST::m_layer_top_triangles.

Referenced by generateHoles(), and generateLayerList().

◆ addObjectTriangles() [2/5]

void RENDER_3D_OPENGL::addObjectTriangles ( const POLYGON_4PT_2D aPoly,
TRIANGLE_DISPLAY_LIST aDstLayer,
float  aZtop,
float  aZbot 
)
private

Definition at line 67 of file opengl/create_scene.cpp.

70 {
71  const SFVEC2F& v0 = aPoly->GetV0();
72  const SFVEC2F& v1 = aPoly->GetV1();
73  const SFVEC2F& v2 = aPoly->GetV2();
74  const SFVEC2F& v3 = aPoly->GetV3();
75 
76  addTopAndBottomTriangles( aDstLayer, v0, v2, v1, aZtop, aZbot );
77  addTopAndBottomTriangles( aDstLayer, v2, v0, v3, aZtop, aZbot );
78 }
const SFVEC2F & GetV1() const
VECTOR2I v2(1, 0)
Test suite for KiCad math code.
void addTopAndBottomTriangles(TRIANGLE_DISPLAY_LIST *aDst, const SFVEC2F &v0, const SFVEC2F &v1, const SFVEC2F &v2, float top, float bot)
const SFVEC2F & GetV2() const
glm::vec2 SFVEC2F
Definition: xv3d_types.h:42
const SFVEC2F & GetV3() const
const SFVEC2F & GetV0() const

References addTopAndBottomTriangles(), POLYGON_4PT_2D::GetV0(), POLYGON_4PT_2D::GetV1(), POLYGON_4PT_2D::GetV2(), POLYGON_4PT_2D::GetV3(), and v2.

◆ addObjectTriangles() [3/5]

void RENDER_3D_OPENGL::addObjectTriangles ( const FILLED_CIRCLE_2D aFilledCircle,
TRIANGLE_DISPLAY_LIST aDstLayer,
float  aZtop,
float  aZbot 
)
private

Definition at line 37 of file opengl/create_scene.cpp.

40 {
41  const SFVEC2F& center = aFilledCircle->GetCenter();
42  const float radius = aFilledCircle->GetRadius() * 2.0f; // Double because the render triangle
43 
44  // This is a small adjustment to the circle texture
45  const float texture_factor = ( 8.0f / (float) SIZE_OF_CIRCLE_TEXTURE ) + 1.0f;
46  const float f = ( sqrtf( 2.0f ) / 2.0f ) * radius * texture_factor;
47 
48  // Top and Bot segments ends are just triangle semi-circles, so need to add it in duplicated.
49  aDstLayer->m_layer_top_segment_ends->AddTriangle( SFVEC3F( center.x + f, center.y, aZtop ),
50  SFVEC3F( center.x - f, center.y, aZtop ),
51  SFVEC3F( center.x, center.y - f, aZtop ) );
52 
53  aDstLayer->m_layer_top_segment_ends->AddTriangle( SFVEC3F( center.x - f, center.y, aZtop ),
54  SFVEC3F( center.x + f, center.y, aZtop ),
55  SFVEC3F( center.x, center.y + f, aZtop ) );
56 
57  aDstLayer->m_layer_bot_segment_ends->AddTriangle( SFVEC3F( center.x - f, center.y, aZbot ),
58  SFVEC3F( center.x + f, center.y, aZbot ),
59  SFVEC3F( center.x, center.y - f, aZbot ) );
60 
61  aDstLayer->m_layer_bot_segment_ends->AddTriangle( SFVEC3F( center.x + f, center.y, aZbot ),
62  SFVEC3F( center.x - f, center.y, aZbot ),
63  SFVEC3F( center.x, center.y + f, aZbot ) );
64 }
float GetRadius() const
const SFVEC2F & GetCenter() const
#define SIZE_OF_CIRCLE_TEXTURE
glm::vec2 SFVEC2F
Definition: xv3d_types.h:42
void AddTriangle(const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3)
glm::vec3 SFVEC3F
Definition: xv3d_types.h:44
TRIANGLE_LIST * m_layer_bot_segment_ends
TRIANGLE_LIST * m_layer_top_segment_ends

References TRIANGLE_LIST::AddTriangle(), FILLED_CIRCLE_2D::GetCenter(), FILLED_CIRCLE_2D::GetRadius(), TRIANGLE_DISPLAY_LIST::m_layer_bot_segment_ends, TRIANGLE_DISPLAY_LIST::m_layer_top_segment_ends, and SIZE_OF_CIRCLE_TEXTURE.

◆ addObjectTriangles() [4/5]

void RENDER_3D_OPENGL::addObjectTriangles ( const TRIANGLE_2D aTri,
TRIANGLE_DISPLAY_LIST aDstLayer,
float  aZtop,
float  aZbot 
)
private

Definition at line 149 of file opengl/create_scene.cpp.

152 {
153  const SFVEC2F& v1 = aTri->GetP1();
154  const SFVEC2F& v2 = aTri->GetP2();
155  const SFVEC2F& v3 = aTri->GetP3();
156 
157  addTopAndBottomTriangles( aDstLayer, v1, v2, v3, aZtop, aZbot );
158 }
VECTOR2I v2(1, 0)
Test suite for KiCad math code.
void addTopAndBottomTriangles(TRIANGLE_DISPLAY_LIST *aDst, const SFVEC2F &v0, const SFVEC2F &v1, const SFVEC2F &v2, float top, float bot)
const SFVEC2F & GetP1() const
Definition: triangle_2d.h:44
const SFVEC2F & GetP2() const
Definition: triangle_2d.h:45
glm::vec2 SFVEC2F
Definition: xv3d_types.h:42
const SFVEC2F & GetP3() const
Definition: triangle_2d.h:46

References addTopAndBottomTriangles(), TRIANGLE_2D::GetP1(), TRIANGLE_2D::GetP2(), TRIANGLE_2D::GetP3(), and v2.

◆ addObjectTriangles() [5/5]

void RENDER_3D_OPENGL::addObjectTriangles ( const ROUND_SEGMENT_2D aSeg,
TRIANGLE_DISPLAY_LIST aDstLayer,
float  aZtop,
float  aZbot 
)
private

Definition at line 161 of file opengl/create_scene.cpp.

164 {
165  const SFVEC2F& leftStart = aSeg->GetLeftStar();
166  const SFVEC2F& leftEnd = aSeg->GetLeftEnd();
167  const SFVEC2F& leftDir = aSeg->GetLeftDir();
168 
169  const SFVEC2F& rightStart = aSeg->GetRightStar();
170  const SFVEC2F& rightEnd = aSeg->GetRightEnd();
171  const SFVEC2F& rightDir = aSeg->GetRightDir();
172  const float radius = aSeg->GetRadius();
173 
174  const SFVEC2F& start = aSeg->GetStart();
175  const SFVEC2F& end = aSeg->GetEnd();
176 
177  const float texture_factor = ( 12.0f / (float) SIZE_OF_CIRCLE_TEXTURE ) + 1.0f;
178  const float texture_factorF = ( 6.0f / (float) SIZE_OF_CIRCLE_TEXTURE ) + 1.0f;
179 
180  const float radius_of_the_square = sqrtf( aSeg->GetRadiusSquared() * 2.0f );
181  const float radius_triangle_factor = ( radius_of_the_square - radius ) / radius;
182 
183  const SFVEC2F factorS = SFVEC2F( -rightDir.y * radius * radius_triangle_factor,
184  rightDir.x * radius * radius_triangle_factor );
185 
186  const SFVEC2F factorE = SFVEC2F( -leftDir.y * radius * radius_triangle_factor,
187  leftDir.x * radius * radius_triangle_factor );
188 
189  // Top end segment triangles (semi-circles)
191  SFVEC3F( rightEnd.x + texture_factor * factorS.x,
192  rightEnd.y + texture_factor * factorS.y,
193  aZtop ),
194  SFVEC3F( leftStart.x + texture_factor * factorE.x,
195  leftStart.y + texture_factor * factorE.y,
196  aZtop ),
197  SFVEC3F( start.x - texture_factorF * leftDir.x * radius * sqrtf( 2.0f ),
198  start.y - texture_factorF * leftDir.y * radius * sqrtf( 2.0f ),
199  aZtop ) );
200 
202  SFVEC3F( leftEnd.x + texture_factor * factorE.x,
203  leftEnd.y + texture_factor * factorE.y, aZtop ),
204  SFVEC3F( rightStart.x + texture_factor * factorS.x,
205  rightStart.y + texture_factor * factorS.y, aZtop ),
206  SFVEC3F( end.x - texture_factorF * rightDir.x * radius * sqrtf( 2.0f ),
207  end.y - texture_factorF * rightDir.y * radius * sqrtf( 2.0f ),
208  aZtop ) );
209 
210  // Bot end segment triangles (semi-circles)
212  SFVEC3F( leftStart.x + texture_factor * factorE.x,
213  leftStart.y + texture_factor * factorE.y,
214  aZbot ),
215  SFVEC3F( rightEnd.x + texture_factor * factorS.x,
216  rightEnd.y + texture_factor * factorS.y,
217  aZbot ),
218  SFVEC3F( start.x - texture_factorF * leftDir.x * radius * sqrtf( 2.0f ),
219  start.y - texture_factorF * leftDir.y * radius * sqrtf( 2.0f ),
220  aZbot ) );
221 
223  SFVEC3F( rightStart.x + texture_factor * factorS.x,
224  rightStart.y + texture_factor * factorS.y, aZbot ),
225  SFVEC3F( leftEnd.x + texture_factor * factorE.x,
226  leftEnd.y + texture_factor * factorE.y, aZbot ),
227  SFVEC3F( end.x - texture_factorF * rightDir.x * radius * sqrtf( 2.0f ),
228  end.y - texture_factorF * rightDir.y * radius * sqrtf( 2.0f ),
229  aZbot ) );
230 
231  // Segment top and bot planes
232  aDstLayer->m_layer_top_triangles->AddQuad(
233  SFVEC3F( rightEnd.x, rightEnd.y, aZtop ),
234  SFVEC3F( rightStart.x, rightStart.y, aZtop ),
235  SFVEC3F( leftEnd.x, leftEnd.y, aZtop ),
236  SFVEC3F( leftStart.x, leftStart.y, aZtop ) );
237 
238  aDstLayer->m_layer_bot_triangles->AddQuad(
239  SFVEC3F( rightEnd.x, rightEnd.y, aZbot ),
240  SFVEC3F( leftStart.x, leftStart.y, aZbot ),
241  SFVEC3F( leftEnd.x, leftEnd.y, aZbot ),
242  SFVEC3F( rightStart.x, rightStart.y, aZbot ) );
243 }
float GetRadiusSquared() const
float GetRadius() const
TRIANGLE_LIST * m_layer_top_triangles
#define SIZE_OF_CIRCLE_TEXTURE
glm::vec2 SFVEC2F
Definition: xv3d_types.h:42
const SFVEC2F & GetLeftEnd() const
const SFVEC2F & GetEnd() const
const SFVEC2F & GetLeftStar() const
void AddQuad(const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3, const SFVEC3F &aV4)
void AddTriangle(const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3)
const SFVEC2F & GetRightDir() const
TRIANGLE_LIST * m_layer_bot_triangles
const SFVEC2F & GetLeftDir() const
glm::vec3 SFVEC3F
Definition: xv3d_types.h:44
const SFVEC2F & GetRightEnd() const
TRIANGLE_LIST * m_layer_bot_segment_ends
const SFVEC2F & GetStart() const
TRIANGLE_LIST * m_layer_top_segment_ends
const SFVEC2F & GetRightStar() const

References TRIANGLE_LIST::AddQuad(), TRIANGLE_LIST::AddTriangle(), ROUND_SEGMENT_2D::GetEnd(), ROUND_SEGMENT_2D::GetLeftDir(), ROUND_SEGMENT_2D::GetLeftEnd(), ROUND_SEGMENT_2D::GetLeftStar(), ROUND_SEGMENT_2D::GetRadius(), ROUND_SEGMENT_2D::GetRadiusSquared(), ROUND_SEGMENT_2D::GetRightDir(), ROUND_SEGMENT_2D::GetRightEnd(), ROUND_SEGMENT_2D::GetRightStar(), ROUND_SEGMENT_2D::GetStart(), TRIANGLE_DISPLAY_LIST::m_layer_bot_segment_ends, TRIANGLE_DISPLAY_LIST::m_layer_bot_triangles, TRIANGLE_DISPLAY_LIST::m_layer_top_segment_ends, TRIANGLE_DISPLAY_LIST::m_layer_top_triangles, and SIZE_OF_CIRCLE_TEXTURE.

◆ addTopAndBottomTriangles()

void RENDER_3D_OPENGL::addTopAndBottomTriangles ( TRIANGLE_DISPLAY_LIST aDst,
const SFVEC2F v0,
const SFVEC2F v1,
const SFVEC2F v2,
float  top,
float  bot 
)
private

Definition at line 663 of file opengl/create_scene.cpp.

666 {
667  aDst->m_layer_bot_triangles->AddTriangle( SFVEC3F( v0.x, v0.y, bot ),
668  SFVEC3F( v1.x, v1.y, bot ),
669  SFVEC3F( v2.x, v2.y, bot ) );
670 
671  aDst->m_layer_top_triangles->AddTriangle( SFVEC3F( v2.x, v2.y, top ),
672  SFVEC3F( v1.x, v1.y, top ),
673  SFVEC3F( v0.x, v0.y, top ) );
674 }
VECTOR2I v2(1, 0)
Test suite for KiCad math code.
TRIANGLE_LIST * m_layer_top_triangles
void AddTriangle(const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3)
TRIANGLE_LIST * m_layer_bot_triangles
glm::vec3 SFVEC3F
Definition: xv3d_types.h:44

References TRIANGLE_LIST::AddTriangle(), TRIANGLE_DISPLAY_LIST::m_layer_bot_triangles, TRIANGLE_DISPLAY_LIST::m_layer_top_triangles, v2, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by addObjectTriangles(), createBoard(), and generateViasAndPads().

◆ createBoard()

OPENGL_RENDER_LIST * RENDER_3D_OPENGL::createBoard ( const SHAPE_POLY_SET aBoardPoly,
const BVH_CONTAINER_2D aThroughHoles = nullptr 
)
private

Definition at line 377 of file opengl/create_scene.cpp.

379 {
380  OPENGL_RENDER_LIST* dispLists = nullptr;
381  CONTAINER_2D boardContainer;
382  SHAPE_POLY_SET brd_outlines = aBoardPoly;
383 
384  ConvertPolygonToTriangles( brd_outlines, boardContainer, m_boardAdapter.BiuTo3dUnits(),
385  (const BOARD_ITEM &)*m_boardAdapter.GetBoard() );
386 
387  const LIST_OBJECT2D& listBoardObject2d = boardContainer.GetList();
388 
389  if( listBoardObject2d.size() > 0 )
390  {
391  // We will set a unitary Z so it will in future used with transformations
392  // since the board poly will be used not only to draw itself but also the
393  // solder mask layers.
394  const float layer_z_top = 1.0f;
395  const float layer_z_bot = 0.0f;
396 
397  TRIANGLE_DISPLAY_LIST* layerTriangles =
398  new TRIANGLE_DISPLAY_LIST( listBoardObject2d.size() );
399 
400  // Convert the list of objects(triangles) to triangle layer structure
401  for( const OBJECT_2D* itemOnLayer : listBoardObject2d )
402  {
403  const OBJECT_2D* object2d_A = itemOnLayer;
404 
405  wxASSERT( object2d_A->GetObjectType() == OBJECT_2D_TYPE::TRIANGLE );
406 
407  const TRIANGLE_2D* tri = static_cast<const TRIANGLE_2D*>( object2d_A );
408 
409  const SFVEC2F& v1 = tri->GetP1();
410  const SFVEC2F& v2 = tri->GetP2();
411  const SFVEC2F& v3 = tri->GetP3();
412 
413  addTopAndBottomTriangles( layerTriangles, v1, v2, v3, layer_z_top, layer_z_bot );
414  }
415 
416  if( aBoardPoly.OutlineCount() > 0 )
417  {
418  layerTriangles->AddToMiddleContourns( aBoardPoly, layer_z_bot, layer_z_top,
419  m_boardAdapter.BiuTo3dUnits(), false,
420  aThroughHoles );
421 
422  dispLists = new OPENGL_RENDER_LIST( *layerTriangles, m_circleTexture,
423  layer_z_top, layer_z_top );
424  }
425 
426  delete layerTriangles;
427  }
428 
429  return dispLists;
430 }
BOARD_ADAPTER & m_boardAdapter
void ConvertPolygonToTriangles(SHAPE_POLY_SET &aPolyList, CONTAINER_2D_BASE &aDstContainer, float aBiuTo3dUnitsScale, const BOARD_ITEM &aBoardItem)
VECTOR2I v2(1, 0)
Test suite for KiCad math code.
int OutlineCount() const
Return the number of vertices in a given outline/hole.
void addTopAndBottomTriangles(TRIANGLE_DISPLAY_LIST *aDst, const SFVEC2F &v0, const SFVEC2F &v1, const SFVEC2F &v2, float top, float bot)
Store arrays of triangles to be used to create display lists.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:49
const LIST_OBJECT2D & GetList() const
Definition: container_2d.h:66
glm::vec2 SFVEC2F
Definition: xv3d_types.h:42
Represent a set of closed polygons.
double BiuTo3dUnits() const noexcept
Board integer units To 3D units.
const BOARD * GetBoard() const noexcept
Get current board to be rendered.
void AddToMiddleContourns(const SHAPE_LINE_CHAIN &outlinePath, float zBot, float zTop, double aBiuTo3Du, bool aInvertFaceDirection, const BVH_CONTAINER_2D *aThroughHoles=nullptr)
OBJECT_2D_TYPE GetObjectType() const
Definition: object_2d.h:107
Store the OpenGL display lists to related with a layer.
std::list< OBJECT_2D * > LIST_OBJECT2D
Definition: container_2d.h:36

References TRIANGLE_DISPLAY_LIST::AddToMiddleContourns(), addTopAndBottomTriangles(), BOARD_ADAPTER::BiuTo3dUnits(), ConvertPolygonToTriangles(), BOARD_ADAPTER::GetBoard(), CONTAINER_2D_BASE::GetList(), OBJECT_2D::GetObjectType(), RENDER_3D_BASE::m_boardAdapter, m_circleTexture, SHAPE_POLY_SET::OutlineCount(), TRIANGLE, and v2.

Referenced by reload().

◆ CreateBusyIndicator()

std::unique_ptr< BUSY_INDICATOR > RENDER_3D_BASE::CreateBusyIndicator ( ) const
protectedinherited

Return a created busy indicator, if a factory has been set, else a null pointer.

the canvas to disply the scene

Definition at line 70 of file render_3d_base.cpp.

71 {
72  std::unique_ptr<BUSY_INDICATOR> busy;
73 
75  busy = m_busyIndicatorFactory();
76 
77  return busy;
78 }
BUSY_INDICATOR::FACTORY m_busyIndicatorFactory
< Factory that returns a suitable busy indicator for the context.

References RENDER_3D_BASE::m_busyIndicatorFactory.

Referenced by Redraw(), and RENDER_3D_RAYTRACE::Redraw().

◆ freeAllLists()

void RENDER_3D_OPENGL::freeAllLists ( )
private

Definition at line 1036 of file render_3d_opengl.cpp.

1037 {
1038  if( glIsList( m_grid ) )
1039  glDeleteLists( m_grid, 1 );
1040 
1041  m_grid = 0;
1042 
1043  for( MAP_OGL_DISP_LISTS::const_iterator ii = m_layers.begin(); ii != m_layers.end(); ++ii )
1044  {
1045  OPENGL_RENDER_LIST* pLayerDispList = static_cast<OPENGL_RENDER_LIST*>( ii->second );
1046  delete pLayerDispList;
1047  }
1048 
1049  m_layers.clear();
1050 
1051  delete m_platedPadsFront;
1052  m_platedPadsFront = nullptr;
1053 
1054  delete m_platedPadsBack;
1055  m_platedPadsBack = nullptr;
1056 
1057  for( MAP_OGL_DISP_LISTS::const_iterator ii = m_outerLayerHoles.begin();
1058  ii != m_outerLayerHoles.end();
1059  ++ii )
1060  {
1061  OPENGL_RENDER_LIST* pLayerDispList = static_cast<OPENGL_RENDER_LIST*>( ii->second );
1062  delete pLayerDispList;
1063  }
1064 
1065  m_outerLayerHoles.clear();
1066 
1067  for( MAP_OGL_DISP_LISTS::const_iterator ii = m_innerLayerHoles.begin();
1068  ii != m_innerLayerHoles.end();
1069  ++ii )
1070  {
1071  OPENGL_RENDER_LIST* pLayerDispList = static_cast<OPENGL_RENDER_LIST*>( ii->second );
1072  delete pLayerDispList;
1073  }
1074 
1075  m_innerLayerHoles.clear();
1076 
1077  for( LIST_TRIANGLES::const_iterator ii = m_triangles.begin(); ii != m_triangles.end(); ++ii )
1078  {
1079  delete *ii;
1080  }
1081 
1082  m_triangles.clear();
1083 
1084  for( MAP_3DMODEL::const_iterator ii = m_3dModelMap.begin(); ii != m_3dModelMap.end(); ++ii )
1085  {
1086  MODEL_3D* pointer = static_cast<MODEL_3D*>(ii->second);
1087  delete pointer;
1088  }
1089 
1090  m_3dModelMap.clear();
1091 
1092  delete m_board;
1093  m_board = nullptr;
1094 
1095  delete m_boardWithHoles;
1096  m_boardWithHoles = nullptr;
1097 
1098  delete m_antiBoard;
1099  m_antiBoard = nullptr;
1100 
1101  delete m_outerThroughHoles;
1102  m_outerThroughHoles = nullptr;
1103 
1104  delete m_outerViaThroughHoles;
1105  m_outerViaThroughHoles = nullptr;
1106 
1107  delete m_outerThroughHoleRings;
1108  m_outerThroughHoleRings = nullptr;
1109 
1110  delete m_vias;
1111  m_vias = nullptr;
1112 
1113  delete m_padHoles;
1114  m_padHoles = nullptr;
1115 }
OPENGL_RENDER_LIST * m_platedPadsBack
OPENGL_RENDER_LIST * m_antiBoard
OPENGL_RENDER_LIST * m_board
OPENGL_RENDER_LIST * m_outerViaThroughHoles
OPENGL_RENDER_LIST * m_boardWithHoles
LIST_TRIANGLES m_triangles
store pointers so can be deleted latter
MAP_OGL_DISP_LISTS m_innerLayerHoles
MAP_OGL_DISP_LISTS m_layers
OPENGL_RENDER_LIST * m_outerThroughHoles
OPENGL_RENDER_LIST * m_vias
MAP_OGL_DISP_LISTS m_outerLayerHoles
GLuint m_grid
oGL list that stores current grid
OPENGL_RENDER_LIST * m_outerThroughHoleRings
OPENGL_RENDER_LIST * m_padHoles
OPENGL_RENDER_LIST * m_platedPadsFront
Store the OpenGL display lists to related with a layer.
MAP_3DMODEL m_3dModelMap

References m_3dModelMap, m_antiBoard, m_board, m_boardWithHoles, m_grid, m_innerLayerHoles, m_layers, m_outerLayerHoles, m_outerThroughHoleRings, m_outerThroughHoles, m_outerViaThroughHoles, m_padHoles, m_platedPadsBack, m_platedPadsFront, m_triangles, and m_vias.

Referenced by reload(), and ~RENDER_3D_OPENGL().

◆ generate3dGrid()

void RENDER_3D_OPENGL::generate3dGrid ( GRID3D_TYPE  aGridType)
private

Create a 3D grid to an OpenGL display list.

A horizontal grid (XY plane and Z = 0, and a vertical grid (XZ plane and Y = 0).

Definition at line 1325 of file render_3d_opengl.cpp.

1326 {
1327  if( glIsList( m_grid ) )
1328  glDeleteLists( m_grid, 1 );
1329 
1330  m_grid = 0;
1331 
1332  if( aGridType == GRID3D_TYPE::NONE )
1333  return;
1334 
1335  m_grid = glGenLists( 1 );
1336 
1337  if( !glIsList( m_grid ) )
1338  return;
1339 
1340  glNewList( m_grid, GL_COMPILE );
1341 
1342  glEnable( GL_BLEND );
1343  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
1344 
1345  const double zpos = 0.0;
1346 
1347  // Color of grid lines
1348  const SFVEC3F gridColor = m_boardAdapter.GetColor( DARKGRAY );
1349 
1350  // Color of grid lines every 5 lines
1351  const SFVEC3F gridColor_marker = m_boardAdapter.GetColor( LIGHTBLUE );
1352  const double scale = m_boardAdapter.BiuTo3dUnits();
1353  const GLfloat transparency = 0.35f;
1354 
1355  double griSizeMM = 0.0;
1356 
1357  switch( aGridType )
1358  {
1359  default:
1360  case GRID3D_TYPE::NONE:
1361  return;
1362  case GRID3D_TYPE::GRID_1MM:
1363  griSizeMM = 1.0;
1364  break;
1366  griSizeMM = 2.5;
1367  break;
1368  case GRID3D_TYPE::GRID_5MM:
1369  griSizeMM = 5.0;
1370  break;
1372  griSizeMM = 10.0;
1373  break;
1374  }
1375 
1376  glNormal3f( 0.0, 0.0, 1.0 );
1377 
1378  const wxSize brd_size = m_boardAdapter.GetBoardSize();
1379  wxPoint brd_center_pos = m_boardAdapter.GetBoardPos();
1380 
1381  brd_center_pos.y = -brd_center_pos.y;
1382 
1383  const int xsize = std::max( brd_size.x, Millimeter2iu( 100 ) ) * 1.2;
1384  const int ysize = std::max( brd_size.y, Millimeter2iu( 100 ) ) * 1.2;
1385 
1386  // Grid limits, in 3D units
1387  double xmin = ( brd_center_pos.x - xsize / 2 ) * scale;
1388  double xmax = ( brd_center_pos.x + xsize / 2 ) * scale;
1389  double ymin = ( brd_center_pos.y - ysize / 2 ) * scale;
1390  double ymax = ( brd_center_pos.y + ysize / 2 ) * scale;
1391  double zmin = Millimeter2iu( -50 ) * scale;
1392  double zmax = Millimeter2iu( 100 ) * scale;
1393 
1394  // Set rasterised line width (min value = 1)
1395  glLineWidth( 1 );
1396 
1397  // Draw horizontal grid centered on 3D origin (center of the board)
1398  for( int ii = 0; ; ii++ )
1399  {
1400  if( (ii % 5) )
1401  glColor4f( gridColor.r, gridColor.g, gridColor.b, transparency );
1402  else
1403  glColor4f( gridColor_marker.r, gridColor_marker.g, gridColor_marker.b,
1404  transparency );
1405 
1406  const int delta = KiROUND( ii * griSizeMM * IU_PER_MM );
1407 
1408  if( delta <= xsize / 2 ) // Draw grid lines parallel to X axis
1409  {
1410  glBegin( GL_LINES );
1411  glVertex3f( (brd_center_pos.x + delta) * scale, -ymin, zpos );
1412  glVertex3f( (brd_center_pos.x + delta) * scale, -ymax, zpos );
1413  glEnd();
1414 
1415  if( ii != 0 )
1416  {
1417  glBegin( GL_LINES );
1418  glVertex3f( (brd_center_pos.x - delta) * scale, -ymin, zpos );
1419  glVertex3f( (brd_center_pos.x - delta) * scale, -ymax, zpos );
1420  glEnd();
1421  }
1422  }
1423 
1424  if( delta <= ysize / 2 ) // Draw grid lines parallel to Y axis
1425  {
1426  glBegin( GL_LINES );
1427  glVertex3f( xmin, -( brd_center_pos.y + delta ) * scale, zpos );
1428  glVertex3f( xmax, -( brd_center_pos.y + delta ) * scale, zpos );
1429  glEnd();
1430 
1431  if( ii != 0 )
1432  {
1433  glBegin( GL_LINES );
1434  glVertex3f( xmin, -( brd_center_pos.y - delta ) * scale, zpos );
1435  glVertex3f( xmax, -( brd_center_pos.y - delta ) * scale, zpos );
1436  glEnd();
1437  }
1438  }
1439 
1440  if( ( delta > ysize / 2 ) && ( delta > xsize / 2 ) )
1441  break;
1442  }
1443 
1444  // Draw vertical grid on Z axis
1445  glNormal3f( 0.0, -1.0, 0.0 );
1446 
1447  // Draw vertical grid lines (parallel to Z axis)
1448  double posy = -brd_center_pos.y * scale;
1449 
1450  for( int ii = 0; ; ii++ )
1451  {
1452  if( (ii % 5) )
1453  glColor4f( gridColor.r, gridColor.g, gridColor.b, transparency );
1454  else
1455  glColor4f( gridColor_marker.r, gridColor_marker.g, gridColor_marker.b,
1456  transparency );
1457 
1458  const double delta = ii * griSizeMM * IU_PER_MM;
1459 
1460  glBegin( GL_LINES );
1461  xmax = ( brd_center_pos.x + delta ) * scale;
1462 
1463  glVertex3f( xmax, posy, zmin );
1464  glVertex3f( xmax, posy, zmax );
1465  glEnd();
1466 
1467  if( ii != 0 )
1468  {
1469  glBegin( GL_LINES );
1470  xmin = ( brd_center_pos.x - delta ) * scale;
1471  glVertex3f( xmin, posy, zmin );
1472  glVertex3f( xmin, posy, zmax );
1473  glEnd();
1474  }
1475 
1476  if( delta > xsize / 2.0f )
1477  break;
1478  }
1479 
1480  // Draw horizontal grid lines on Z axis (parallel to X axis)
1481  for( int ii = 0; ; ii++ )
1482  {
1483  if( ii % 5 )
1484  glColor4f( gridColor.r, gridColor.g, gridColor.b, transparency );
1485  else
1486  glColor4f( gridColor_marker.r, gridColor_marker.g, gridColor_marker.b, transparency );
1487 
1488  const double delta = ii * griSizeMM * IU_PER_MM * scale;
1489 
1490  if( delta <= zmax )
1491  {
1492  // Draw grid lines on Z axis (positive Z axis coordinates)
1493  glBegin( GL_LINES );
1494  glVertex3f( xmin, posy, delta );
1495  glVertex3f( xmax, posy, delta );
1496  glEnd();
1497  }
1498 
1499  if( delta <= -zmin && ( ii != 0 ) )
1500  {
1501  // Draw grid lines on Z axis (negative Z axis coordinates)
1502  glBegin( GL_LINES );
1503  glVertex3f( xmin, posy, -delta );
1504  glVertex3f( xmax, posy, -delta );
1505  glEnd();
1506  }
1507 
1508  if( ( delta > zmax ) && ( delta > -zmin ) )
1509  break;
1510  }
1511 
1512  glDisable( GL_BLEND );
1513 
1514  glEndList();
1515 }
BOARD_ADAPTER & m_boardAdapter
static constexpr double IU_PER_MM
Mock up a conversion function.
SFVEC4F GetColor(const COLOR4D &aColor) const
wxPoint GetBoardPos() const noexcept
Get the board center.
GLuint m_grid
oGL list that stores current grid
double BiuTo3dUnits() const noexcept
Board integer units To 3D units.
const int scale
glm::vec3 SFVEC3F
Definition: xv3d_types.h:44
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:73
constexpr int delta
static constexpr int Millimeter2iu(double mm)
wxSize GetBoardSize() const noexcept
Get the board size.

References BOARD_ADAPTER::BiuTo3dUnits(), DARKGRAY, delta, BOARD_ADAPTER::GetBoardPos(), BOARD_ADAPTER::GetBoardSize(), BOARD_ADAPTER::GetColor(), GRID_10MM, GRID_1MM, GRID_2P5MM, GRID_5MM, IU_PER_MM, KiROUND(), LIGHTBLUE, RENDER_3D_BASE::m_boardAdapter, m_grid, Millimeter2iu(), NONE, and scale.

Referenced by Redraw().

◆ generateCylinder()

void RENDER_3D_OPENGL::generateCylinder ( const SFVEC2F aCenter,
float  aInnerRadius,
float  aOuterRadius,
float  aZtop,
float  aZbot,
unsigned int  aNr_sides_per_circle,
TRIANGLE_DISPLAY_LIST aDstLayer 
)
private

Definition at line 691 of file opengl/create_scene.cpp.

695 {
696  std::vector< SFVEC2F > innerContour;
697  std::vector< SFVEC2F > outerContour;
698 
699  generateRing( aCenter, aInnerRadius, aOuterRadius, aNr_sides_per_circle, innerContour,
700  outerContour, false );
701 
702  for( unsigned int i = 0; i < ( innerContour.size() - 1 ); ++i )
703  {
704  const SFVEC2F& vi0 = innerContour[i + 0];
705  const SFVEC2F& vi1 = innerContour[i + 1];
706  const SFVEC2F& vo0 = outerContour[i + 0];
707  const SFVEC2F& vo1 = outerContour[i + 1];
708 
709  aDstLayer->m_layer_top_triangles->AddQuad( SFVEC3F( vi1.x, vi1.y, aZtop ),
710  SFVEC3F( vi0.x, vi0.y, aZtop ),
711  SFVEC3F( vo0.x, vo0.y, aZtop ),
712  SFVEC3F( vo1.x, vo1.y, aZtop ) );
713 
714  aDstLayer->m_layer_bot_triangles->AddQuad( SFVEC3F( vi1.x, vi1.y, aZbot ),
715  SFVEC3F( vo1.x, vo1.y, aZbot ),
716  SFVEC3F( vo0.x, vo0.y, aZbot ),
717  SFVEC3F( vi0.x, vi0.y, aZbot ) );
718  }
719 
720  aDstLayer->AddToMiddleContourns( outerContour, aZbot, aZtop, true );
721  aDstLayer->AddToMiddleContourns( innerContour, aZbot, aZtop, false );
722 }
TRIANGLE_LIST * m_layer_top_triangles
glm::vec2 SFVEC2F
Definition: xv3d_types.h:42
void generateRing(const SFVEC2F &aCenter, float aInnerRadius, float aOuterRadius, unsigned int aNr_sides_per_circle, std::vector< SFVEC2F > &aInnerContourResult, std::vector< SFVEC2F > &aOuterContourResult, bool aInvertOrder)
void AddQuad(const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3, const SFVEC3F &aV4)
void AddToMiddleContourns(const SHAPE_LINE_CHAIN &outlinePath, float zBot, float zTop, double aBiuTo3Du, bool aInvertFaceDirection, const BVH_CONTAINER_2D *aThroughHoles=nullptr)
TRIANGLE_LIST * m_layer_bot_triangles
glm::vec3 SFVEC3F
Definition: xv3d_types.h:44

References TRIANGLE_LIST::AddQuad(), TRIANGLE_DISPLAY_LIST::AddToMiddleContourns(), generateRing(), TRIANGLE_DISPLAY_LIST::m_layer_bot_triangles, and TRIANGLE_DISPLAY_LIST::m_layer_top_triangles.

Referenced by generateViasAndPads().

◆ generateHoles()

OPENGL_RENDER_LIST * RENDER_3D_OPENGL::generateHoles ( const LIST_OBJECT2D aListHolesObject2d,
const SHAPE_POLY_SET aPoly,
float  aZtop,
float  aZbot,
bool  aInvertFaces,
const BVH_CONTAINER_2D aThroughHoles = nullptr 
)
private

Definition at line 246 of file opengl/create_scene.cpp.

250 {
251  OPENGL_RENDER_LIST* ret = nullptr;
252 
253  if( aListHolesObject2d.size() > 0 )
254  {
255  TRIANGLE_DISPLAY_LIST* layerTriangles =
256  new TRIANGLE_DISPLAY_LIST( aListHolesObject2d.size() * 2 );
257 
258  // Convert the list of objects(filled circles) to triangle layer structure
259  for( const OBJECT_2D* itemOnLayer : aListHolesObject2d )
260  {
261  const OBJECT_2D* object2d_A = itemOnLayer;
262 
263  wxASSERT( ( object2d_A->GetObjectType() == OBJECT_2D_TYPE::FILLED_CIRCLE )
264  || ( object2d_A->GetObjectType() == OBJECT_2D_TYPE::ROUNDSEG ) );
265 
266  switch( object2d_A->GetObjectType() )
267  {
269  addObjectTriangles( static_cast<const FILLED_CIRCLE_2D*>( object2d_A ),
270  layerTriangles, aZtop, aZbot );
271  break;
272 
274  addObjectTriangles( static_cast<const ROUND_SEGMENT_2D*>( object2d_A ),
275  layerTriangles, aZtop, aZbot );
276  break;
277 
278  default:
279  wxFAIL_MSG( "RENDER_3D_OPENGL::generateHoles: Object type is not implemented" );
280  break;
281  }
282  }
283 
284  // Note: he can have a aListHolesObject2d with holes but without contours
285  // eg: when there are only NPTH on the list and the contours were not added
286  if( aPoly.OutlineCount() > 0 )
287  {
288  layerTriangles->AddToMiddleContourns( aPoly, aZbot, aZtop,
290  aInvertFaces, aThroughHoles );
291  }
292 
293  ret = new OPENGL_RENDER_LIST( *layerTriangles, m_circleTexture, aZbot, aZtop );
294 
295  delete layerTriangles;
296  }
297 
298  return ret;
299 }
BOARD_ADAPTER & m_boardAdapter
int OutlineCount() const
Return the number of vertices in a given outline/hole.
Store arrays of triangles to be used to create display lists.
double BiuTo3dUnits() const noexcept
Board integer units To 3D units.
void AddToMiddleContourns(const SHAPE_LINE_CHAIN &outlinePath, float zBot, float zTop, double aBiuTo3Du, bool aInvertFaceDirection, const BVH_CONTAINER_2D *aThroughHoles=nullptr)
OBJECT_2D_TYPE GetObjectType() const
Definition: object_2d.h:107
Store the OpenGL display lists to related with a layer.
void addObjectTriangles(const RING_2D *aRing, TRIANGLE_DISPLAY_LIST *aDstLayer, float aZtop, float aZbot)

References addObjectTriangles(), TRIANGLE_DISPLAY_LIST::AddToMiddleContourns(), BOARD_ADAPTER::BiuTo3dUnits(), FILLED_CIRCLE, OBJECT_2D::GetObjectType(), RENDER_3D_BASE::m_boardAdapter, m_circleTexture, SHAPE_POLY_SET::OutlineCount(), and ROUNDSEG.

Referenced by reload().

◆ generateLayerList()

OPENGL_RENDER_LIST * RENDER_3D_OPENGL::generateLayerList ( const BVH_CONTAINER_2D aContainer,
const SHAPE_POLY_SET aPolyList,
PCB_LAYER_ID  aLayerId,
const BVH_CONTAINER_2D aThroughHoles = nullptr 
)
private

Definition at line 302 of file opengl/create_scene.cpp.

306 {
307  if( aContainer == nullptr )
308  return nullptr;
309 
310  const LIST_OBJECT2D& listObject2d = aContainer->GetList();
311 
312  if( listObject2d.size() == 0 )
313  return nullptr;
314 
315  float layer_z_bot = 0.0f;
316  float layer_z_top = 0.0f;
317 
318  getLayerZPos( aLayerId, layer_z_top, layer_z_bot );
319 
320  // Calculate an estimation for the nr of triangles based on the nr of objects
321  unsigned int nrTrianglesEstimation = listObject2d.size() * 8;
322 
323  TRIANGLE_DISPLAY_LIST* layerTriangles = new TRIANGLE_DISPLAY_LIST( nrTrianglesEstimation );
324 
325  // store in a list so it will be latter deleted
326  m_triangles.push_back( layerTriangles );
327 
328  // Load the 2D (X,Y axis) component of shapes
329  for( const OBJECT_2D* itemOnLayer : listObject2d )
330  {
331  const OBJECT_2D* object2d_A = itemOnLayer;
332 
333  switch( object2d_A->GetObjectType() )
334  {
336  addObjectTriangles( static_cast<const FILLED_CIRCLE_2D*>( object2d_A ),
337  layerTriangles, layer_z_top, layer_z_bot );
338  break;
339 
341  addObjectTriangles( static_cast<const POLYGON_4PT_2D*>( object2d_A ),
342  layerTriangles, layer_z_top, layer_z_bot );
343  break;
344 
346  addObjectTriangles( static_cast<const RING_2D*>( object2d_A ),
347  layerTriangles, layer_z_top, layer_z_bot );
348  break;
349 
351  addObjectTriangles( static_cast<const TRIANGLE_2D*>( object2d_A ),
352  layerTriangles, layer_z_top, layer_z_bot );
353  break;
354 
356  addObjectTriangles( static_cast<const ROUND_SEGMENT_2D*>( object2d_A ),
357  layerTriangles, layer_z_top, layer_z_bot );
358  break;
359 
360  default:
361  wxFAIL_MSG( "RENDER_3D_OPENGL: Object type is not implemented" );
362  break;
363  }
364  }
365 
366  if( aPolyList && aPolyList->OutlineCount() > 0 )
367  {
368  layerTriangles->AddToMiddleContourns( *aPolyList, layer_z_bot, layer_z_top,
369  m_boardAdapter.BiuTo3dUnits(), false, aThroughHoles );
370  }
371 
372  // Create display list
373  return new OPENGL_RENDER_LIST( *layerTriangles, m_circleTexture, layer_z_bot, layer_z_top );
374 }
BOARD_ADAPTER & m_boardAdapter
int OutlineCount() const
Return the number of vertices in a given outline/hole.
Store arrays of triangles to be used to create display lists.
LIST_TRIANGLES m_triangles
store pointers so can be deleted latter
void getLayerZPos(PCB_LAYER_ID aLayerID, float &aOutZtop, float &aOutZbot) const
const LIST_OBJECT2D & GetList() const
Definition: container_2d.h:66
double BiuTo3dUnits() const noexcept
Board integer units To 3D units.
void AddToMiddleContourns(const SHAPE_LINE_CHAIN &outlinePath, float zBot, float zTop, double aBiuTo3Du, bool aInvertFaceDirection, const BVH_CONTAINER_2D *aThroughHoles=nullptr)
OBJECT_2D_TYPE GetObjectType() const
Definition: object_2d.h:107
Store the OpenGL display lists to related with a layer.
void addObjectTriangles(const RING_2D *aRing, TRIANGLE_DISPLAY_LIST *aDstLayer, float aZtop, float aZbot)
std::list< OBJECT_2D * > LIST_OBJECT2D
Definition: container_2d.h:36

References addObjectTriangles(), TRIANGLE_DISPLAY_LIST::AddToMiddleContourns(), BOARD_ADAPTER::BiuTo3dUnits(), FILLED_CIRCLE, getLayerZPos(), CONTAINER_2D_BASE::GetList(), OBJECT_2D::GetObjectType(), RENDER_3D_BASE::m_boardAdapter, m_circleTexture, m_triangles, SHAPE_POLY_SET::OutlineCount(), POLYGON4PT, RING, ROUNDSEG, and TRIANGLE.

Referenced by reload().

◆ generateRing()

void RENDER_3D_OPENGL::generateRing ( const SFVEC2F aCenter,
float  aInnerRadius,
float  aOuterRadius,
unsigned int  aNr_sides_per_circle,
std::vector< SFVEC2F > &  aInnerContourResult,
std::vector< SFVEC2F > &  aOuterContourResult,
bool  aInvertOrder 
)
private

Definition at line 81 of file opengl/create_scene.cpp.

86 {
87  aInnerContourResult.clear();
88  aInnerContourResult.reserve( aNr_sides_per_circle + 2 );
89 
90  aOuterContourResult.clear();
91  aOuterContourResult.reserve( aNr_sides_per_circle + 2 );
92 
93  const int delta = 3600 / aNr_sides_per_circle;
94 
95  for( int ii = 0; ii < 3600; ii += delta )
96  {
97  float angle = (float)( aInvertOrder ? ( 3600 - ii ) : ii )
98  * 2.0f * glm::pi<float>() / 3600.0f;
99  const SFVEC2F rotatedDir = SFVEC2F( cos( angle ), sin( angle ) );
100 
101  aInnerContourResult.emplace_back( aCenter.x + rotatedDir.x * aInnerRadius,
102  aCenter.y + rotatedDir.y * aInnerRadius );
103 
104  aOuterContourResult.emplace_back( aCenter.x + rotatedDir.x * aOuterRadius,
105  aCenter.y + rotatedDir.y * aOuterRadius );
106  }
107 
108  aInnerContourResult.push_back( aInnerContourResult[0] );
109  aOuterContourResult.push_back( aOuterContourResult[0] );
110 
111  wxASSERT( aInnerContourResult.size() == aOuterContourResult.size() );
112 }
glm::vec2 SFVEC2F
Definition: xv3d_types.h:42
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
constexpr int delta

References PNS::angle(), and delta.

Referenced by addObjectTriangles(), and generateCylinder().

◆ generateViasAndPads()

void RENDER_3D_OPENGL::generateViasAndPads ( )
private

Definition at line 725 of file opengl/create_scene.cpp.

726 {
727  if( !m_boardAdapter.GetBoard() )
728  return;
729 
730  const int platingThickness = m_boardAdapter.GetHolePlatingThickness();
731  const float platingThickness3d = platingThickness * m_boardAdapter.BiuTo3dUnits();
732 
733  if( m_boardAdapter.GetViaCount() > 0 )
734  {
735  const unsigned int reserve_nr_triangles_estimation =
739 
740  TRIANGLE_DISPLAY_LIST* layerTriangleVIA =
741  new TRIANGLE_DISPLAY_LIST( reserve_nr_triangles_estimation );
742 
743  // Insert plated vertical holes inside the board
744 
745  // Insert vias holes (vertical cylinders)
746  for( const PCB_TRACK* track : m_boardAdapter.GetBoard()->Tracks() )
747  {
748  if( track->Type() == PCB_VIA_T )
749  {
750  const PCB_VIA* via = static_cast<const PCB_VIA*>( track );
751 
752  const float holediameter = via->GetDrillValue() * m_boardAdapter.BiuTo3dUnits();
753  const int nrSegments = m_boardAdapter.GetCircleSegmentCount( via->GetDrillValue() );
754  const float hole_inner_radius = holediameter / 2.0f;
755 
756  const SFVEC2F via_center( via->GetStart().x * m_boardAdapter.BiuTo3dUnits(),
757  -via->GetStart().y * m_boardAdapter.BiuTo3dUnits() );
758 
759  PCB_LAYER_ID top_layer, bottom_layer;
760  via->LayerPair( &top_layer, &bottom_layer );
761 
762  float ztop, zbot, dummy;
763 
764  getLayerZPos( top_layer, ztop, dummy );
765  getLayerZPos( bottom_layer, dummy, zbot );
766 
767  wxASSERT( zbot < ztop );
768 
769  generateCylinder( via_center, hole_inner_radius,
770  hole_inner_radius + platingThickness3d,
771  ztop, zbot, nrSegments, layerTriangleVIA );
772  }
773  }
774 
775  m_vias = new OPENGL_RENDER_LIST( *layerTriangleVIA, 0, 0.0f, 0.0f );
776 
777  delete layerTriangleVIA;
778  }
779 
780 
781  if( m_boardAdapter.GetHoleCount() > 0 )
782  {
783  SHAPE_POLY_SET tht_outer_holes_poly; // Stores the outer poly of the copper holes (the pad)
784  SHAPE_POLY_SET tht_inner_holes_poly; // Stores the inner poly of the copper holes (the hole)
785 
786  tht_outer_holes_poly.RemoveAllContours();
787  tht_inner_holes_poly.RemoveAllContours();
788 
789  // Insert pads holes (vertical cylinders)
790  for( const FOOTPRINT* footprint : m_boardAdapter.GetBoard()->Footprints() )
791  {
792  for( const PAD* pad : footprint->Pads() )
793  {
794  if( pad->GetAttribute() != PAD_ATTRIB::NPTH )
795  {
796  const wxSize drillsize = pad->GetDrillSize();
797  const bool hasHole = drillsize.x && drillsize.y;
798 
799  if( !hasHole )
800  continue;
801 
802  pad->TransformHoleWithClearanceToPolygon( tht_outer_holes_poly,
803  platingThickness,
804  ARC_HIGH_DEF, ERROR_INSIDE );
805  pad->TransformHoleWithClearanceToPolygon( tht_inner_holes_poly, 0,
806  ARC_HIGH_DEF, ERROR_INSIDE );
807  }
808  }
809  }
810 
811  // Subtract the holes
812  tht_outer_holes_poly.BooleanSubtract( tht_inner_holes_poly, SHAPE_POLY_SET::PM_FAST );
813 
816 
817  CONTAINER_2D holesContainer;
818 
819  ConvertPolygonToTriangles( tht_outer_holes_poly, holesContainer,
821  (const BOARD_ITEM &)*m_boardAdapter.GetBoard() );
822 
823  const LIST_OBJECT2D& listHolesObject2d = holesContainer.GetList();
824 
825  if( listHolesObject2d.size() > 0 )
826  {
827  float layer_z_top, layer_z_bot, dummy;
828 
829  getLayerZPos( F_Cu, layer_z_top, dummy );
830  getLayerZPos( B_Cu, dummy, layer_z_bot );
831 
832  TRIANGLE_DISPLAY_LIST* layerTriangles =
833  new TRIANGLE_DISPLAY_LIST( listHolesObject2d.size() );
834 
835  // Convert the list of objects(triangles) to triangle layer structure
836  for( const OBJECT_2D* itemOnLayer : listHolesObject2d )
837  {
838  const OBJECT_2D* object2d_A = itemOnLayer;
839 
840  wxASSERT( object2d_A->GetObjectType() == OBJECT_2D_TYPE::TRIANGLE );
841 
842  const TRIANGLE_2D* tri = static_cast<const TRIANGLE_2D*>( object2d_A );
843 
844  const SFVEC2F& v1 = tri->GetP1();
845  const SFVEC2F& v2 = tri->GetP2();
846  const SFVEC2F& v3 = tri->GetP3();
847 
848  addTopAndBottomTriangles( layerTriangles, v1, v2, v3, layer_z_top, layer_z_bot );
849  }
850 
851  wxASSERT( tht_outer_holes_poly.OutlineCount() > 0 );
852 
853  if( tht_outer_holes_poly.OutlineCount() > 0 )
854  {
855  layerTriangles->AddToMiddleContourns( tht_outer_holes_poly,
856  layer_z_bot, layer_z_top,
857  m_boardAdapter.BiuTo3dUnits(), false );
858 
859  m_padHoles = new OPENGL_RENDER_LIST( *layerTriangles, m_circleTexture,
860  layer_z_top, layer_z_top );
861  }
862 
863  delete layerTriangles;
864  }
865  }
866 }
bool GetFlag(DISPLAY3D_FLG aFlag) const
Get a configuration status of a flag.
BOARD_ADAPTER & m_boardAdapter
void ConvertPolygonToTriangles(SHAPE_POLY_SET &aPolyList, CONTAINER_2D_BASE &aDstContainer, float aBiuTo3dUnitsScale, const BOARD_ITEM &aBoardItem)
VECTOR2I v2(1, 0)
Test suite for KiCad math code.
int OutlineCount() const
Return the number of vertices in a given outline/hole.
void addTopAndBottomTriangles(TRIANGLE_DISPLAY_LIST *aDst, const SFVEC2F &v0, const SFVEC2F &v1, const SFVEC2F &v2, float top, float bot)
Store arrays of triangles to be used to create display lists.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:49
void getLayerZPos(PCB_LAYER_ID aLayerID, float &aOutZtop, float &aOutZbot) const
SHAPE_POLY_SET m_antiBoardPolys
The negative polygon representation of the board outline.
const LIST_OBJECT2D & GetList() const
Definition: container_2d.h:66
static LIB_SYMBOL * dummy()
Used to draw a dummy shape when a LIB_SYMBOL is not found in library.
Definition: sch_symbol.cpp:72
OPENGL_RENDER_LIST * m_vias
like PAD_PTH, but not plated
glm::vec2 SFVEC2F
Definition: xv3d_types.h:42
Represent a set of closed polygons.
FOOTPRINTS & Footprints()
Definition: board.h:234
double BiuTo3dUnits() const noexcept
Board integer units To 3D units.
const BOARD * GetBoard() const noexcept
Get current board to be rendered.
void AddToMiddleContourns(const SHAPE_LINE_CHAIN &outlinePath, float zBot, float zTop, double aBiuTo3Du, bool aInvertFaceDirection, const BVH_CONTAINER_2D *aThroughHoles=nullptr)
OPENGL_RENDER_LIST * m_padHoles
OBJECT_2D_TYPE GetObjectType() const
Definition: object_2d.h:107
Store the OpenGL display lists to related with a layer.
unsigned int GetViaCount() const noexcept
Get number of vias in this board.
void generateCylinder(const SFVEC2F &aCenter, float aInnerRadius, float aOuterRadius, float aZtop, float aZbot, unsigned int aNr_sides_per_circle, TRIANGLE_DISPLAY_LIST *aDstLayer)
unsigned int GetHoleCount() const noexcept
Get number of holes in this board.
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:65
Definition: layer_ids.h:71
float GetAverageViaHoleDiameter() const noexcept
Thee average diameter of the via holes.
std::list< OBJECT_2D * > LIST_OBJECT2D
Definition: container_2d.h:36
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
void BooleanSubtract(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Perform boolean polyset intersection For aFastMode meaning, see function booleanOp.
Definition: pad.h:57
unsigned int GetCircleSegmentCount(float aDiameter3DU) const
TRACKS & Tracks()
Definition: board.h:231
int GetHolePlatingThickness() const noexcept
Get the current copper layer thickness.

References TRIANGLE_DISPLAY_LIST::AddToMiddleContourns(), addTopAndBottomTriangles(), B_Cu, BOARD_ADAPTER::BiuTo3dUnits(), SHAPE_POLY_SET::BooleanSubtract(), ConvertPolygonToTriangles(), dummy(), ERROR_INSIDE, F_Cu, FL_USE_REALISTIC_MODE, BOARD::Footprints(), generateCylinder(), BOARD_ADAPTER::GetAverageViaHoleDiameter(), BOARD_ADAPTER::GetBoard(), BOARD_ADAPTER::GetCircleSegmentCount(), BOARD_ADAPTER::GetFlag(), BOARD_ADAPTER::GetHoleCount(), BOARD_ADAPTER::GetHolePlatingThickness(), getLayerZPos(), CONTAINER_2D_BASE::GetList(), OBJECT_2D::GetObjectType(), BOARD_ADAPTER::GetViaCount(), m_antiBoardPolys, RENDER_3D_BASE::m_boardAdapter, m_circleTexture, m_padHoles, m_vias, NPTH, SHAPE_POLY_SET::OutlineCount(), pad, PCB_VIA_T, SHAPE_POLY_SET::PM_FAST, SHAPE_POLY_SET::RemoveAllContours(), BOARD::Tracks(), TRIANGLE, v2, and via.

Referenced by reload().

◆ getLayerColor()

SFVEC4F RENDER_3D_OPENGL::getLayerColor ( PCB_LAYER_ID  aLayerID)
private

Definition at line 394 of file render_3d_opengl.cpp.

395 {
396  SFVEC4F layerColor = m_boardAdapter.GetLayerColor( aLayerID );
397 
399  {
400  switch( aLayerID )
401  {
402  case B_Adhes:
403  case F_Adhes:
404  break;
405 
406  case B_Mask:
408  break;
409  case F_Mask:
411  break;
412 
413  case B_Paste:
414  case F_Paste:
415  layerColor = m_boardAdapter.m_SolderPasteColor;
416  break;
417 
418  case B_SilkS:
420  break;
421  case F_SilkS:
423  break;
424 
425  case Dwgs_User:
426  case Cmts_User:
427  case Eco1_User:
428  case Eco2_User:
429  case Edge_Cuts:
430  case Margin:
431  break;
432 
433  case B_CrtYd:
434  case F_CrtYd:
435  break;
436 
437  case B_Fab:
438  case F_Fab:
439  break;
440 
441  default:
442  layerColor = m_boardAdapter.m_CopperColor;
443  break;
444  }
445  }
446 
447  return layerColor;
448 }
bool GetFlag(DISPLAY3D_FLG aFlag) const
Get a configuration status of a flag.
BOARD_ADAPTER & m_boardAdapter
SFVEC4F m_SilkScreenColorBot
in realistic mode: SilkScreen color ( bot )
glm::vec4 SFVEC4F
Definition: xv3d_types.h:46
SFVEC4F m_SolderMaskColorTop
in realistic mode: solder mask color ( top )
SFVEC4F m_SolderPasteColor
in realistic mode: solder paste color
SFVEC4F m_SolderMaskColorBot
in realistic mode: solder mask color ( bot )
SFVEC4F GetLayerColor(PCB_LAYER_ID aLayerId) const
Get the technical color of a layer.
SFVEC4F m_CopperColor
in realistic mode: copper color
SFVEC4F m_SilkScreenColorTop
in realistic mode: SilkScreen color ( top )

References B_Adhes, B_CrtYd, B_Fab, B_Mask, B_Paste, B_SilkS, Cmts_User, Dwgs_User, Eco1_User, Eco2_User, Edge_Cuts, F_Adhes, F_CrtYd, F_Fab, F_Mask, F_Paste, F_SilkS, FL_USE_REALISTIC_MODE, BOARD_ADAPTER::GetFlag(), BOARD_ADAPTER::GetLayerColor(), RENDER_3D_BASE::m_boardAdapter, BOARD_ADAPTER::m_CopperColor, BOARD_ADAPTER::m_SilkScreenColorBot, BOARD_ADAPTER::m_SilkScreenColorTop, BOARD_ADAPTER::m_SolderMaskColorBot, BOARD_ADAPTER::m_SolderMaskColorTop, BOARD_ADAPTER::m_SolderPasteColor, and Margin.

Referenced by setLayerMaterial().

◆ getLayerZPos()

void RENDER_3D_OPENGL::getLayerZPos ( PCB_LAYER_ID  aLayerID,
float &  aOutZtop,
float &  aOutZbot 
) const
private

Definition at line 677 of file opengl/create_scene.cpp.

678 {
679  aOutZbot = m_boardAdapter.GetLayerBottomZPos( aLayerID );
680  aOutZtop = m_boardAdapter.GetLayerTopZPos( aLayerID );
681 
682  if( aOutZtop < aOutZbot )
683  {
684  float tmpFloat = aOutZbot;
685  aOutZbot = aOutZtop;
686  aOutZtop = tmpFloat;
687  }
688 }
BOARD_ADAPTER & m_boardAdapter
float GetLayerTopZPos(PCB_LAYER_ID aLayerId) const noexcept
Get the top z position.
float GetLayerBottomZPos(PCB_LAYER_ID aLayerId) const noexcept
Get the bottom z position.

References BOARD_ADAPTER::GetLayerBottomZPos(), BOARD_ADAPTER::GetLayerTopZPos(), and RENDER_3D_BASE::m_boardAdapter.

Referenced by generateLayerList(), generateViasAndPads(), and reload().

◆ GetWaitForEditingTimeOut()

int RENDER_3D_OPENGL::GetWaitForEditingTimeOut ( )
overridevirtual

Give the interface the time (in ms) that it should wait for editing or movements before (this works for display preview mode).

Returns
a value in milliseconds

Implements RENDER_3D_BASE.

Definition at line 84 of file render_3d_opengl.cpp.

85 {
86  return 50; // ms
87 }

◆ initializeOpenGL()

bool RENDER_3D_OPENGL::initializeOpenGL ( )
private

Definition at line 974 of file render_3d_opengl.cpp.

975 {
976  glEnable( GL_LINE_SMOOTH );
977  glShadeModel( GL_SMOOTH );
978 
979  // 4-byte pixel alignment
980  glPixelStorei( GL_UNPACK_ALIGNMENT, 4 );
981 
982  // Initialize the open GL texture to draw the filled semi-circle of the segments
984 
985  if( !circleImage )
986  return false;
987 
988  unsigned int circleRadius = ( SIZE_OF_CIRCLE_TEXTURE / 2 ) - 4;
989 
990  circleImage->CircleFilled( ( SIZE_OF_CIRCLE_TEXTURE / 2 ) - 0,
991  ( SIZE_OF_CIRCLE_TEXTURE / 2 ) - 0,
992  circleRadius,
993  0xFF );
994 
995  IMAGE* circleImageBlured = new IMAGE( circleImage->GetWidth(), circleImage->GetHeight() );
996 
997  circleImageBlured->EfxFilter_SkipCenter( circleImage, IMAGE_FILTER::GAUSSIAN_BLUR, circleRadius - 8 );
998 
999  m_circleTexture = OglLoadTexture( *circleImageBlured );
1000 
1001  delete circleImageBlured;
1002  circleImageBlured = nullptr;
1003 
1004  delete circleImage;
1005  circleImage = nullptr;
1006 
1007  init_lights();
1008 
1009  // Use this mode if you want see the triangle lines (debug proposes)
1010  //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
1011  m_is_opengl_initialized = true;
1012 
1013  return true;
1014 }
void EfxFilter_SkipCenter(IMAGE *aInImg, IMAGE_FILTER aFilterType, unsigned int aRadius)
Apply a filter to the input image and store it in the image class.
Definition: image.cpp:527
#define SIZE_OF_CIRCLE_TEXTURE
void CircleFilled(int aCx, int aCy, int aRadius, unsigned char aValue)
Definition: image.cpp:173
bool m_is_opengl_initialized
unsigned int GetHeight() const
Definition: image.h:214
Manage an 8-bit channel image.
Definition: image.h:89
unsigned int GetWidth() const
Definition: image.h:213
GLuint OglLoadTexture(const IMAGE &aImage)
Generate a new OpenGL texture.
Definition: ogl_utils.cpp:71
void init_lights(void)

References IMAGE::CircleFilled(), IMAGE::EfxFilter_SkipCenter(), GAUSSIAN_BLUR, IMAGE::GetHeight(), IMAGE::GetWidth(), IMAGE, init_lights(), m_circleTexture, RENDER_3D_BASE::m_is_opengl_initialized, OglLoadTexture(), and SIZE_OF_CIRCLE_TEXTURE.

Referenced by Redraw().

◆ IsReloadRequestPending()

bool RENDER_3D_BASE::IsReloadRequestPending ( ) const
inlineinherited

Query if there is a pending reload request.

Returns
true if it wants to reload, false if there is no reload pending

Definition at line 77 of file render_3d_base.h.

77 { return m_reloadRequested; }
bool m_reloadRequested
The window size that this camera is working.

References RENDER_3D_BASE::m_reloadRequested.

Referenced by EDA_3D_CANVAS::DoRePaint(), and EDA_3D_CANVAS::IsReloadRequestPending().

◆ load3dModels()

void RENDER_3D_OPENGL::load3dModels ( REPORTER aStatusReporter)
private

Load footprint models from the cache and load it to openGL lists in the form of MODEL_3D objects.

This map of models will work as a local cache for this render. (cache based on MODEL_3D with associated openGL lists in GPU memory)

Definition at line 887 of file opengl/create_scene.cpp.

888 {
889  if( !m_boardAdapter.GetBoard() )
890  return;
891 
895  {
896  return;
897  }
898 
899  // Go for all footprints
900  for( const FOOTPRINT* footprint : m_boardAdapter.GetBoard()->Footprints() )
901  {
902  for( const FP_3DMODEL& model : footprint->Models() )
903  {
904  if( model.m_Show && !model.m_Filename.empty() )
905  {
906  if( aStatusReporter )
907  {
908  // Display the short filename of the 3D model loaded:
909  // (the full name is usually too long to be displayed)
910  wxFileName fn( model.m_Filename );
911  aStatusReporter->Report( wxString::Format( _( "Loading %s..." ),
912  fn.GetFullName() ) );
913  }
914 
915  // Check if the model is not present in our cache map
916  // (Not already loaded in memory)
917  if( m_3dModelMap.find( model.m_Filename ) == m_3dModelMap.end() )
918  {
919  // It is not present, try get it from cache
920  const S3DMODEL* modelPtr =
921  m_boardAdapter.Get3dCacheManager()->GetModel( model.m_Filename );
922 
923  // only add it if the return is not NULL
924  if( modelPtr )
925  {
927  MODEL_3D* ogl_model = new MODEL_3D( *modelPtr, materialMode );
928 
929  if( ogl_model )
930  m_3dModelMap[ model.m_Filename ] = ogl_model;
931  }
932  }
933  }
934  }
935  }
936 }
bool GetFlag(DISPLAY3D_FLG aFlag) const
Get a configuration status of a flag.
BOARD_ADAPTER & m_boardAdapter
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)=0
Report a string with a given severity.
S3DMODEL * GetModel(const wxString &aModelFileName)
Attempt to load the scene data for a model and to translate it into an S3D_MODEL structure for displa...
Definition: 3d_cache.cpp:643
S3D_CACHE * Get3dCacheManager() const noexcept
Return the 3D cache manager pointer.
Definition: board_adapter.h:88
FOOTPRINTS & Footprints()
Definition: board.h:234
MATERIAL_MODE GetMaterialMode() const noexcept
const BOARD * GetBoard() const noexcept
Get current board to be rendered.
#define _(s)
MATERIAL_MODE
Render 3d model shape materials mode.
Definition: 3d_enums.h:118
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
Store the a model based on meshes and materials.
Definition: c3dmodel.h:90
MAP_3DMODEL m_3dModelMap

References _, FL_FP_ATTRIBUTES_NORMAL, FL_FP_ATTRIBUTES_NORMAL_INSERT, FL_FP_ATTRIBUTES_VIRTUAL, BOARD::Footprints(), Format(), BOARD_ADAPTER::Get3dCacheManager(), BOARD_ADAPTER::GetBoard(), BOARD_ADAPTER::GetFlag(), BOARD_ADAPTER::GetMaterialMode(), S3D_CACHE::GetModel(), m_3dModelMap, RENDER_3D_BASE::m_boardAdapter, and REPORTER::Report().

Referenced by Load3dModelsIfNeeded(), and reload().

◆ Load3dModelsIfNeeded()

void RENDER_3D_OPENGL::Load3dModelsIfNeeded ( )

Load footprint models if they are not already loaded, i.e.

if m_3dModelMap is empty

Definition at line 869 of file opengl/create_scene.cpp.

870 {
871  if( m_3dModelMap.size() > 0 )
872  return;
873 
874  wxFrame* frame = dynamic_cast<EDA_3D_VIEWER_FRAME*>( m_canvas->GetParent() );
875 
876  if( frame )
877  {
878  STATUSBAR_REPORTER activityReporter( frame->GetStatusBar(),
880  load3dModels( &activityReporter );
881  }
882  else
883  load3dModels( nullptr );
884 }
A wrapper for reporting to a specific text location in a statusbar.
Definition: reporter.h:286
void load3dModels(REPORTER *aStatusReporter)
Load footprint models from the cache and load it to openGL lists in the form of MODEL_3D objects.
EDA_3D_CANVAS * m_canvas
Settings reference in use for this render.
MAP_3DMODEL m_3dModelMap

References ACTIVITY, load3dModels(), m_3dModelMap, and RENDER_3D_BASE::m_canvas.

Referenced by EDA_3D_CONTROLLER::ToggleVisibility().

◆ Redraw()

bool RENDER_3D_OPENGL::Redraw ( bool  aIsMoving,
REPORTER aStatusReporter,
REPORTER aWarningReporter 
)
overridevirtual

Redraw the view.

Parameters
aIsMovingif the user is moving the scene, it should be render in preview mode.
aStatusReportera pointer to the status progress reporter.
Returns
true if the render would like to redraw again.

Implements RENDER_3D_BASE.

Definition at line 546 of file render_3d_opengl.cpp.

548 {
549  // Initialize OpenGL
551  {
552  if( !initializeOpenGL() )
553  return false;
554  }
555 
556  if( m_reloadRequested )
557  {
558  std::unique_ptr<BUSY_INDICATOR> busy = CreateBusyIndicator();
559 
560  if( aStatusReporter )
561  aStatusReporter->Report( _( "Loading..." ) );
562 
563  reload( aStatusReporter, aWarningReporter );
564 
565  // generate a new 3D grid as the size of the board may had changed
568  }
569  else
570  {
571  // Check if grid was changed
573  {
574  // and generate a new one
577  }
578  }
579 
580  setupMaterials();
581 
582  // Initial setup
583  glDepthFunc( GL_LESS );
584  glEnable( GL_CULL_FACE );
585  glFrontFace( GL_CCW ); // This is the OpenGL default
586  glEnable( GL_NORMALIZE ); // This allow OpenGL to normalize the normals after transformations
587  glViewport( 0, 0, m_windowSize.x, m_windowSize.y );
588 
590  glDisable( GL_MULTISAMPLE );
591  else
592  glEnable( GL_MULTISAMPLE );
593 
594  // clear color and depth buffers
595  glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
596  glClearDepth( 1.0f );
597  glClearStencil( 0x00 );
598  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
599 
601 
602  // Draw the background ( rectangle with color gradient)
605 
606  glEnable( GL_DEPTH_TEST );
607 
608  // Set projection and modelview matrixes
609  glMatrixMode( GL_PROJECTION );
610  glLoadMatrixf( glm::value_ptr( m_camera.GetProjectionMatrix() ) );
611  glMatrixMode( GL_MODELVIEW );
612  glLoadIdentity();
613  glLoadMatrixf( glm::value_ptr( m_camera.GetViewMatrix() ) );
614 
615  // Position the headlight
616  setLightFront( true );
617  setLightTop( true );
618  setLightBottom( true );
619 
620  glEnable( GL_LIGHTING );
621 
622  {
623  const SFVEC3F& cameraPos = m_camera.GetPos();
624 
625  // Place the light at a minimum Z so the diffuse factor will not drop
626  // and the board will still look with good light.
627  float zpos;
628 
629  if( cameraPos.z > 0.0f )
630  {
631  zpos = glm::max( cameraPos.z, 0.5f ) + cameraPos.z * cameraPos.z;
632  }
633  else
634  {
635  zpos = glm::min( cameraPos.z,-0.5f ) - cameraPos.z * cameraPos.z;
636  }
637 
638  // This is a point light.
639  const GLfloat headlight_pos[] = { cameraPos.x, cameraPos.y, zpos, 1.0f };
640 
641  glLightfv( GL_LIGHT0, GL_POSITION, headlight_pos );
642  }
643 
644  const bool drawMiddleSegments = !( aIsMoving &&
646 
647  const bool skipRenderHoles = aIsMoving &&
649 
650  const bool skipRenderVias = aIsMoving &&
652 
654  {
655  // Draw vias and pad holes with copper material
657  }
658  else
659  {
660  OglSetMaterial( m_materials.m_GrayMaterial, 1.0f );
661  }
662 
663  if( !( skipRenderVias || skipRenderHoles ) && m_vias )
664  m_vias->DrawAll();
665 
666  if( !skipRenderHoles && m_padHoles )
667  m_padHoles->DrawAll();
668 
669  // Display copper and tech layers
670  for( MAP_OGL_DISP_LISTS::const_iterator ii = m_layers.begin(); ii != m_layers.end(); ++ii )
671  {
672  const PCB_LAYER_ID layer_id = ( PCB_LAYER_ID )( ii->first );
673 
674  // Mask layers are not processed here because they are a special case
675  if( ( layer_id == B_Mask ) || ( layer_id == F_Mask ) )
676  continue;
677 
678  // Do not show inner layers when it is displaying the board and board body is opaque
679  // enough: the time to create inner layers can be *really significant*.
680  // So avoid creating them is they are not very visible
681  const double opacity_min = 0.8;
682 
684  ( m_boardAdapter.m_BoardBodyColor.a > opacity_min ) )
685  {
686  if( ( layer_id > F_Cu ) && ( layer_id < B_Cu ) )
687  continue;
688  }
689 
690  glPushMatrix();
691 
692  OPENGL_RENDER_LIST* pLayerDispList = static_cast<OPENGL_RENDER_LIST*>( ii->second );
693 
694  if( ( layer_id >= F_Cu ) && ( layer_id <= B_Cu ) )
695  {
699  setLayerMaterial( layer_id );
700  else
702 
703  if( skipRenderHoles )
704  {
705  pLayerDispList->DrawAllCameraCulled( m_camera.GetPos().z, drawMiddleSegments );
706 
707  // Draw copper plated pads
708  if( ( ( layer_id == F_Cu ) || ( layer_id == B_Cu ) ) &&
710  setPlatedCopperAndDepthOffset( layer_id );
711 
712  if( layer_id == F_Cu && m_platedPadsFront )
713  {
715  drawMiddleSegments );
716  }
717  else if( layer_id == B_Cu && m_platedPadsBack )
718  {
720  drawMiddleSegments );
721  }
722 
724  }
725  else
726  {
727  if( m_outerThroughHoles )
728  {
729  m_outerThroughHoles->ApplyScalePosition( pLayerDispList->GetZBot(),
730  pLayerDispList->GetZTop()
731  - pLayerDispList->GetZBot() );
732  }
733 
734  if( m_antiBoard )
735  {
736  m_antiBoard->ApplyScalePosition( pLayerDispList->GetZBot(),
737  pLayerDispList->GetZTop()
738  - pLayerDispList->GetZBot() );
739  }
740 
741  if( m_outerLayerHoles.find( layer_id ) != m_outerLayerHoles.end() )
742  {
743  const OPENGL_RENDER_LIST* viasHolesLayer = m_outerLayerHoles.at( layer_id );
744 
745  wxASSERT( viasHolesLayer != nullptr );
746 
747  if( viasHolesLayer != nullptr )
748  {
749  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
751  viasHolesLayer,
752  m_antiBoard );
753 
754  // Draw copper plated pads
755 
756  if( ( ( layer_id == F_Cu ) || ( layer_id == B_Cu ) ) &&
758  {
759  setPlatedCopperAndDepthOffset( layer_id );
760  }
761 
762  if( layer_id == F_Cu && m_platedPadsFront )
763  {
765  drawMiddleSegments,
767  viasHolesLayer,
768  m_antiBoard );
769  }
770  else if( layer_id == B_Cu && m_platedPadsBack )
771  {
773  drawMiddleSegments,
775  viasHolesLayer,
776  m_antiBoard );
777  }
778 
780  }
781  }
782  else
783  {
784  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
786  m_antiBoard );
787 
788  // Draw copper plated pads
789  if( ( ( layer_id == F_Cu ) || ( layer_id == B_Cu ) ) &&
791  {
792  setPlatedCopperAndDepthOffset( layer_id );
793  }
794 
795  if( layer_id == F_Cu && m_platedPadsFront )
796  {
799  m_antiBoard );
800  }
801  else if( layer_id == B_Cu && m_platedPadsBack )
802  {
805  m_antiBoard );
806  }
807 
809  }
810  }
811  }
812  else
813  {
814  setLayerMaterial( layer_id );
815 
816  OPENGL_RENDER_LIST* throughHolesOuter =
819  && ( layer_id == B_SilkS || layer_id == F_SilkS )
822 
823  if( throughHolesOuter )
824  {
825  throughHolesOuter->ApplyScalePosition(
826  pLayerDispList->GetZBot(),
827  pLayerDispList->GetZTop() - pLayerDispList->GetZBot() );
828  }
829 
830  OPENGL_RENDER_LIST* anti_board = m_antiBoard;
831 
832  if( anti_board )
833  {
834  anti_board->ApplyScalePosition(
835  pLayerDispList->GetZBot(),
836  pLayerDispList->GetZTop() - pLayerDispList->GetZBot() );
837  }
838 
839  if( !skipRenderHoles
842  && ( ( layer_id == B_SilkS && m_layers.find( B_Mask ) != m_layers.end() )
843  || ( layer_id == F_SilkS && m_layers.find( F_Mask ) != m_layers.end() ) ) )
844  {
845  const PCB_LAYER_ID layerMask_id = (layer_id == B_SilkS) ? B_Mask : F_Mask;
846 
847  const OPENGL_RENDER_LIST* pLayerDispListMask = m_layers.at( layerMask_id );
848 
849  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
850  pLayerDispListMask,
851  throughHolesOuter, anti_board );
852  }
853  else
854  {
855  if( !skipRenderHoles && throughHolesOuter
856  && ( layer_id == B_SilkS || layer_id == F_SilkS ) )
857  {
858  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments, nullptr,
859  throughHolesOuter,
860  anti_board );
861  }
862  else
863  {
864  // Do not render Paste layers when skipRenderHoles is enabled
865  // otherwise it will cause z-fight issues
866  if( !( skipRenderHoles && ( layer_id == B_Paste || layer_id == F_Paste ) ) )
867  {
868  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
869  anti_board );
870  }
871  }
872  }
873  }
874 
875  glPopMatrix();
876  }
877 
878  // Render 3D Models (Non-transparent)
879  render3dModels( false, false );
880  render3dModels( true, false );
881 
882  // Display board body
884  {
885  renderBoardBody( skipRenderHoles );
886  }
887 
888  // Display transparent mask layers
890  {
891  // add a depth buffer offset, it will help to hide some artifacts
892  // on silkscreen where the SolderMask is removed
893  glEnable( GL_POLYGON_OFFSET_FILL );
894  glPolygonOffset( 0.0f, -2.0f );
895 
896  if( m_camera.GetPos().z > 0 )
897  {
899  drawMiddleSegments, skipRenderHoles );
900 
902  drawMiddleSegments, skipRenderHoles );
903  }
904  else
905  {
907  drawMiddleSegments, skipRenderHoles );
908 
910  drawMiddleSegments, skipRenderHoles );
911  }
912 
913  glDisable( GL_POLYGON_OFFSET_FILL );
914  glPolygonOffset( 0.0f, 0.0f );
915  }
916 
917  // Render 3D Models (Transparent)
918  // !TODO: this can be optimized. If there are no transparent models (or no opacity),
919  // then there is no need to make this function call.
920  glDepthMask( GL_FALSE );
921  glEnable( GL_BLEND );
922  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
923 
924  // Enables Texture Env so it can combine model transparency with each footprint opacity
925  glEnable( GL_TEXTURE_2D );
926  glActiveTexture( GL_TEXTURE0 );
927 
928  glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE );
929  glTexEnvf( GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE );
930  glTexEnvf( GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE );
931 
932  glTexEnvi( GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PRIMARY_COLOR );
933  glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR );
934 
935  glTexEnvi( GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PREVIOUS );
936  glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR );
937 
938  glTexEnvi( GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PRIMARY_COLOR );
939  glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA );
940  glTexEnvi( GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_CONSTANT );
941  glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_CONSTANT );
942 
943  render3dModels( false, true );
944  render3dModels( true, true );
945 
946  glDisable( GL_BLEND );
948 
949  glDepthMask( GL_TRUE );
950 
951  // Render Grid
953  {
954  glDisable( GL_LIGHTING );
955 
956  if( glIsList( m_grid ) )
957  glCallList( m_grid );
958 
959  glEnable( GL_LIGHTING );
960  }
961 
962  // Render 3D arrows
964  render3dArrows();
965 
966  // Return back to the original viewport (this is important if we want
967  // to take a screenshot after the render)
968  glViewport( 0, 0, m_windowSize.x, m_windowSize.y );
969 
970  return false;
971 }
OPENGL_RENDER_LIST * m_platedPadsBack
GRID3D_TYPE GetGridType() const noexcept
Get the current grid.
OPENGL_RENDER_LIST * m_antiBoard
bool GetFlag(DISPLAY3D_FLG aFlag) const
Get a configuration status of a flag.
BOARD_ADAPTER & m_boardAdapter
void setLightFront(bool enabled)
void OglSetMaterial(const SMATERIAL &aMaterial, float aOpacity, bool aUseSelectedMaterial, SFVEC3F aSelectionColor)
Set OpenGL materials.
Definition: ogl_utils.cpp:119
void DrawAllCameraCulledSubtractLayer(bool aDrawMiddle, const OPENGL_RENDER_LIST *aLayerToSubtractA=nullptr, const OPENGL_RENDER_LIST *aLayerToSubtractB=nullptr, const OPENGL_RENDER_LIST *aLayerToSubtractC=nullptr, const OPENGL_RENDER_LIST *aLayerToSubtractD=nullptr) const
float GetZBot() const
void DrawAllCameraCulled(float zCameraPos, bool aDrawMiddle=true) const
Draw all layers if they are visible by the camera if camera position is above the layer.
const glm::mat4 & GetProjectionMatrix() const
Definition: camera.cpp:391
const SFVEC3F & GetPos() const
Definition: camera.h:107
MAP_OGL_DISP_LISTS m_layers
SFVEC4F m_BoardBodyColor
in realistic mode: FR4 board color
OPENGL_RENDER_LIST * m_outerThroughHoles
void OglResetTextureState()
Reset to default state the texture settings.
Definition: ogl_utils.cpp:189
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)=0
Report a string with a given severity.
struct RENDER_3D_OPENGL::@2 m_materials
OPENGL_RENDER_LIST * m_vias
void reload(REPORTER *aStatusReporter, REPORTER *aWarningReporter)
SFVEC4F m_BgColorTop
background top color
void setLightBottom(bool enabled)
float GetLayerTopZPos(PCB_LAYER_ID aLayerId) const noexcept
Get the top z position.
MAP_OGL_DISP_LISTS m_outerLayerHoles
GLuint m_grid
oGL list that stores current grid
float GetLayerBottomZPos(PCB_LAYER_ID aLayerId) const noexcept
Get the bottom z position.
const glm::mat4 & GetViewMatrix() const
Definition: camera.cpp:427
OPENGL_RENDER_LIST * m_outerThroughHoleRings
void setPlatedCopperAndDepthOffset(PCB_LAYER_ID aLayer_id)
#define _(s)
SFVEC4F m_BgColorBot
background bottom color
void ApplyScalePosition(float aZposition, float aZscale)
void setLightTop(bool enabled)
OPENGL_RENDER_LIST * m_padHoles
void DrawAll(bool aDrawMiddle=true) const
Call to draw all the display lists.
OPENGL_RENDER_LIST * m_platedPadsFront
bool m_is_opengl_initialized
std::unique_ptr< BUSY_INDICATOR > CreateBusyIndicator() const
Return a created busy indicator, if a factory has been set, else a null pointer.
Store the OpenGL display lists to related with a layer.
bool m_reloadRequested
The window size that this camera is working.
void generate3dGrid(GRID3D_TYPE aGridType)
Create a 3D grid to an OpenGL display list.
void renderBoardBody(bool aSkipRenderHoles)
void setLayerMaterial(PCB_LAYER_ID aLayerID)
GRID3D_TYPE m_lastGridType
Stores the last grid type.
void OglDrawBackground(const SFVEC3F &aTopColor, const SFVEC3F &aBotColor)
Definition: ogl_utils.cpp:160
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:65
glm::vec3 SFVEC3F
Definition: xv3d_types.h:44
Definition: layer_ids.h:71
CAMERA & m_camera
Flag if the opengl specific for this render was already initialized.
float GetZTop() const
void render3dModels(bool aRenderTopOrBot, bool aRenderTransparentOnly)
void renderSolderMaskLayer(PCB_LAYER_ID aLayerID, float aZPosition, bool aDrawMiddleSegments, bool aSkipRenderHoles)

References _, OPENGL_RENDER_LIST::ApplyScalePosition(), B_Cu, B_Mask, B_Paste, B_SilkS, RENDER_3D_BASE::CreateBusyIndicator(), OPENGL_RENDER_LIST::DrawAll(), OPENGL_RENDER_LIST::DrawAllCameraCulled(), OPENGL_RENDER_LIST::DrawAllCameraCulledSubtractLayer(), F_Cu, F_Mask, F_Paste, F_SilkS, FL_AXIS, FL_CLIP_SILK_ON_VIA_ANNULUS, FL_RENDER_OPENGL_AA_DISABLE_ON_MOVE, FL_RENDER_OPENGL_HOLES_DISABLE_ON_MOVE, FL_RENDER_OPENGL_THICKNESS_DISABLE_ON_MOVE, FL_RENDER_OPENGL_VIAS_DISABLE_ON_MOVE, FL_RENDER_PLATED_PADS_AS_PLATED, FL_SHOW_BOARD_BODY, FL_SOLDERMASK, FL_SUBTRACT_MASK_FROM_SILK, FL_USE_REALISTIC_MODE, generate3dGrid(), BOARD_ADAPTER::GetFlag(), BOARD_ADAPTER::GetGridType(), BOARD_ADAPTER::GetLayerBottomZPos(), BOARD_ADAPTER::GetLayerTopZPos(), CAMERA::GetPos(), CAMERA::GetProjectionMatrix(), CAMERA::GetViewMatrix(), OPENGL_RENDER_LIST::GetZBot(), OPENGL_RENDER_LIST::GetZTop(), initializeOpenGL(), m_antiBoard, BOARD_ADAPTER::m_BgColorBot, BOARD_ADAPTER::m_BgColorTop, RENDER_3D_BASE::m_boardAdapter, BOARD_ADAPTER::m_BoardBodyColor, RENDER_3D_BASE::m_camera, m_grid, RENDER_3D_BASE::m_is_opengl_initialized, m_lastGridType, m_layers, m_materials, m_outerLayerHoles, m_outerThroughHoleRings, m_outerThroughHoles, m_padHoles, m_platedPadsBack, m_platedPadsFront, RENDER_3D_BASE::m_reloadRequested, m_vias, RENDER_3D_BASE::m_windowSize, NONE, OglDrawBackground(), OglResetTextureState(), OglSetMaterial(), reload(), render3dArrows(), render3dModels(), renderBoardBody(), renderSolderMaskLayer(), REPORTER::Report(), setCopperMaterial(), setLayerMaterial(), setLightBottom(), setLightFront(), setLightTop(), setPlatedCopperAndDepthOffset(), setupMaterials(), and unsetDepthOffset().

◆ reload()

void RENDER_3D_OPENGL::reload ( REPORTER aStatusReporter,
REPORTER aWarningReporter 
)
private

Definition at line 433 of file opengl/create_scene.cpp.

434 {
435  m_reloadRequested = false;
436 
437  freeAllLists();
438 
440 
441  unsigned stats_startReloadTime = GetRunningMicroSecs();
442 
443  m_boardAdapter.InitSettings( aStatusReporter, aWarningReporter );
444 
445  SFVEC3F camera_pos = m_boardAdapter.GetBoardCenter();
446  m_camera.SetBoardLookAtPos( camera_pos );
447 
448  if( aStatusReporter )
449  aStatusReporter->Report( _( "Load OpenGL: board" ) );
450 
451  // Create Board
453 
455  {
458  m_antiBoardPolys.Append( VECTOR2I( -INT_MAX/2, -INT_MAX/2 ) );
459  m_antiBoardPolys.Append( VECTOR2I( INT_MAX/2, -INT_MAX/2 ) );
460  m_antiBoardPolys.Append( VECTOR2I( INT_MAX/2, INT_MAX/2 ) );
461  m_antiBoardPolys.Append( VECTOR2I( -INT_MAX/2, INT_MAX/2 ) );
462  m_antiBoardPolys.Outline( 0 ).SetClosed( true );
463 
467  }
468 
469  SHAPE_POLY_SET board_poly_with_holes = m_boardAdapter.GetBoardPoly();
470  board_poly_with_holes.BooleanSubtract( m_boardAdapter.GetThroughHoleOdPolys(),
474 
475  m_boardWithHoles = createBoard( board_poly_with_holes );
476 
477  if( m_antiBoard )
479 
480  // Create Through Holes and vias
481  if( aStatusReporter )
482  aStatusReporter->Report( _( "Load OpenGL: holes and vias" ) );
483 
485 
489 
491  outerPolyTHT, 1.0f, 0.0f, false,
493 
496  m_boardAdapter.GetThroughHoleViaOdPolys(), 1.0f, 0.0f, false );
497 
500  {
503  m_boardAdapter.GetThroughHoleAnnularRingPolys(), 1.0f, 0.0f, false );
504  }
505 
506  const MAP_POLY& innerMapHoles = m_boardAdapter.GetHoleIdPolysMap();
507  const MAP_POLY& outerMapHoles = m_boardAdapter.GetHoleOdPolysMap();
508 
509  wxASSERT( innerMapHoles.size() == outerMapHoles.size() );
510 
512 
513  if( outerMapHoles.size() > 0 )
514  {
515  float layer_z_bot = 0.0f;
516  float layer_z_top = 0.0f;
517 
518  for( const auto ii : outerMapHoles )
519  {
520  const PCB_LAYER_ID layer_id = ii.first;
521  const SHAPE_POLY_SET* poly = ii.second;
522  const BVH_CONTAINER_2D* container = map_holes.at( layer_id );
523 
524  getLayerZPos( layer_id, layer_z_top, layer_z_bot );
525 
526  m_outerLayerHoles[layer_id] = generateHoles( container->GetList(), *poly,
527  layer_z_top, layer_z_bot, false );
528  }
529 
530  for( const auto ii : innerMapHoles )
531  {
532  const PCB_LAYER_ID layer_id = ii.first;
533  const SHAPE_POLY_SET* poly = ii.second;
534  const BVH_CONTAINER_2D* container = map_holes.at( layer_id );
535 
536  getLayerZPos( layer_id, layer_z_top, layer_z_bot );
537 
538  m_innerLayerHoles[layer_id] = generateHoles( container->GetList(), *poly,
539  layer_z_top, layer_z_bot, false );
540  }
541  }
542 
543  // Generate vertical cylinders of vias and pads (copper)
545 
546  // Add layers maps
547  if( aStatusReporter )
548  aStatusReporter->Report( _( "Load OpenGL: layers" ) );
549 
550  const MAP_POLY& map_poly = m_boardAdapter.GetPolyMap();
551 
552  for( const auto ii : m_boardAdapter.GetLayerMap() )
553  {
554  const PCB_LAYER_ID layer_id = ii.first;
555 
556  if( !m_boardAdapter.Is3dLayerEnabled( layer_id ) )
557  continue;
558 
559  if( aStatusReporter )
560  aStatusReporter->Report( wxString::Format(
561  _( "Load OpenGL layer %d" ), (int)layer_id ) );
562 
563  const BVH_CONTAINER_2D* container2d = ii.second;
564 
565  SHAPE_POLY_SET polyListSubtracted;
566  SHAPE_POLY_SET* aPolyList = nullptr;
567 
568  // Load the vertical (Z axis) component of shapes
569 
570  if( map_poly.find( layer_id ) != map_poly.end() )
571  {
572  polyListSubtracted = *map_poly.at( layer_id );;
573 
575  {
576  polyListSubtracted.BooleanIntersection( m_boardAdapter.GetBoardPoly(),
578 
579  if( ( layer_id != B_Mask ) && ( layer_id != F_Mask ) )
580  {
583  polyListSubtracted.BooleanSubtract(
586  }
587 
589  {
590  if( layer_id == B_SilkS && map_poly.find( B_Mask ) != map_poly.end() )
591  {
592  polyListSubtracted.BooleanSubtract( *map_poly.at( B_Mask ),
594  }
595  else if( layer_id == F_SilkS && map_poly.find( F_Mask ) != map_poly.end() )
596  {
597  polyListSubtracted.BooleanSubtract( *map_poly.at( F_Mask ),
599  }
600  }
601  }
602 
603  aPolyList = &polyListSubtracted;
604  }
605 
606  OPENGL_RENDER_LIST* oglList = generateLayerList( container2d, aPolyList, layer_id,
608 
609  if( oglList != nullptr )
610  m_layers[layer_id] = oglList;
611 
612  }
613 
616  {
618  {
626 
628  &polySubtracted, F_Cu );
629  }
630 
632  {
640 
642  &polySubtracted, B_Cu );
643  }
644  }
645 
646  // Load 3D models
647  if( aStatusReporter )
648  aStatusReporter->Report( _( "Loading 3D models..." ) );
649 
650  load3dModels( aStatusReporter );
651 
652  if( aStatusReporter )
653  {
654  // Calculation time in seconds
655  const double calculation_time = (double)( GetRunningMicroSecs() -
656  stats_startReloadTime) / 1e6;
657 
658  aStatusReporter->Report( wxString::Format( _( "Reload time %.3f s" ), calculation_time ) );
659  }
660 }
OPENGL_RENDER_LIST * m_platedPadsBack
OPENGL_RENDER_LIST * m_antiBoard
bool GetFlag(DISPLAY3D_FLG aFlag) const
Get a configuration status of a flag.
void SetBoardLookAtPos(const SFVEC3F &aBoardPos)
Definition: camera.h:112
BOARD_ADAPTER & m_boardAdapter
OPENGL_RENDER_LIST * m_board
void load3dModels(REPORTER *aStatusReporter)
Load footprint models from the cache and load it to openGL lists in the form of MODEL_3D objects.
OPENGL_RENDER_LIST * m_outerViaThroughHoles
std::map< PCB_LAYER_ID, SHAPE_POLY_SET * > MAP_POLY
A type that stores polysets for each layer id.
Definition: board_adapter.h:57
OPENGL_RENDER_LIST * m_boardWithHoles
const SHAPE_POLY_SET & GetOuterNonPlatedThroughHolePoly() const noexcept
const BVH_CONTAINER_2D & GetThroughHoleAnnularRings() const noexcept
Get the through hole annular rings container.
const SHAPE_POLY_SET & GetThroughHoleOdPolys() const noexcept
Get through hole outside diameter 2D polygons.
MAP_OGL_DISP_LISTS m_innerLayerHoles
const MAP_CONTAINER_2D_BASE & GetLayerMap() const noexcept
Get the map of containers that have the objects per layer.
void getLayerZPos(PCB_LAYER_ID aLayerID, float &aOutZtop, float &aOutZbot) const
void InitSettings(REPORTER *aStatusReporter, REPORTER *aWarningReporter)
Function to be called by the render when it need to reload the settings for the board.
MAP_OGL_DISP_LISTS m_layers
OPENGL_RENDER_LIST * m_outerThroughHoles
const SHAPE_POLY_SET & GetThroughHoleViaOdPolys() const noexcept
const SHAPE_POLY_SET * GetFrontPlatedPadPolys()
VECTOR2< int > VECTOR2I
Definition: vector2d.h:622
SHAPE_POLY_SET m_antiBoardPolys
The negative polygon representation of the board outline.
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)=0
Report a string with a given severity.
const SHAPE_POLY_SET * GetBackPlatedPadPolys()
const SHAPE_POLY_SET & GetThroughHoleAnnularRingPolys() const noexcept
const LIST_OBJECT2D & GetList() const
Definition: container_2d.h:66
const BVH_CONTAINER_2D & GetThroughHoleIds() const noexcept
Get the through hole inner diameter container.
bool Is3dLayerEnabled(PCB_LAYER_ID aLayer) const
Check if a layer is enabled.
void SetClosed(bool aClosed)
Mark the line chain as closed (i.e.
const BVH_CONTAINER_2D * GetPlatedPadsBack() const noexcept
Represent a set of closed polygons.
SHAPE_LINE_CHAIN & Outline(int aIndex)
MAP_OGL_DISP_LISTS m_outerLayerHoles
OPENGL_RENDER_LIST * m_outerThroughHoleRings
static OBJECT_2D_STATS & Instance()
Definition: object_2d.h:137
const MAP_POLY & GetHoleIdPolysMap() const noexcept
#define _(s)
OPENGL_RENDER_LIST * createBoard(const SHAPE_POLY_SET &aBoardPoly, const BVH_CONTAINER_2D *aThroughHoles=nullptr)
const BVH_CONTAINER_2D & GetThroughHoleOds() const noexcept
Get the inflated through hole outside diameters container.
const MAP_POLY & GetHoleOdPolysMap() const noexcept
const SHAPE_POLY_SET & GetBoardPoly() const noexcept
Get the current polygon of the epoxy board.
std::map< PCB_LAYER_ID, BVH_CONTAINER_2D * > MAP_CONTAINER_2D_BASE
A type that stores a container of 2d objects for each layer id.
Definition: board_adapter.h:51
void BooleanIntersection(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Perform boolean polyset union between a and b, store the result in it self For aFastMode meaning,...
int NewOutline()
Creates a new hole in a given outline.
OPENGL_RENDER_LIST * m_platedPadsFront
const MAP_POLY & GetPolyMap() const noexcept
Get map of polygon's layers.
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
Store the OpenGL display lists to related with a layer.
bool m_reloadRequested
The window size that this camera is working.
const BVH_CONTAINER_2D * GetPlatedPadsFront() const noexcept
unsigned GetRunningMicroSecs()
An alternate way to calculate an elapsed time (in microsecondes) to class PROF_COUNTER.
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:65
glm::vec3 SFVEC3F
Definition: xv3d_types.h:44
const BVH_CONTAINER_2D & GetThroughHoleViaOds() const noexcept
Definition: layer_ids.h:71
const SFVEC3F & GetBoardCenter() const noexcept
The board center position in 3D units.
CAMERA & m_camera
Flag if the opengl specific for this render was already initialized.
void SetItIsTransparent(bool aSetTransparent)
OPENGL_RENDER_LIST * generateHoles(const LIST_OBJECT2D &aListHolesObject2d, const SHAPE_POLY_SET &aPoly, float aZtop, float aZbot, bool aInvertFaces, const BVH_CONTAINER_2D *aThroughHoles=nullptr)
void BooleanSubtract(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Perform boolean polyset intersection For aFastMode meaning, see function booleanOp.
void ResetStats()
Definition: object_2d.h:122
const MAP_CONTAINER_2D_BASE & GetLayerHoleMap() const noexcept
Get the map of container that have the holes per layer.
OPENGL_RENDER_LIST * generateLayerList(const BVH_CONTAINER_2D *aContainer, const SHAPE_POLY_SET *aPolyList, PCB_LAYER_ID aLayerId, const BVH_CONTAINER_2D *aThroughHoles=nullptr)
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Add a new vertex to the contour indexed by aOutline and aHole (defaults to the outline of the last po...

References _, SHAPE_POLY_SET::Append(), B_Cu, B_Mask, B_SilkS, SHAPE_POLY_SET::BooleanIntersection(), SHAPE_POLY_SET::BooleanSubtract(), createBoard(), F_Cu, F_Mask, F_SilkS, FL_CLIP_SILK_ON_VIA_ANNULUS, FL_RENDER_PLATED_PADS_AS_PLATED, FL_SUBTRACT_MASK_FROM_SILK, FL_USE_REALISTIC_MODE, Format(), freeAllLists(), generateHoles(), generateLayerList(), generateViasAndPads(), BOARD_ADAPTER::GetBackPlatedPadPolys(), BOARD_ADAPTER::GetBoardCenter(), BOARD_ADAPTER::GetBoardPoly(), BOARD_ADAPTER::GetFlag(), BOARD_ADAPTER::GetFrontPlatedPadPolys(), BOARD_ADAPTER::GetHoleIdPolysMap(), BOARD_ADAPTER::GetHoleOdPolysMap(), BOARD_ADAPTER::GetLayerHoleMap(), BOARD_ADAPTER::GetLayerMap(), getLayerZPos(), CONTAINER_2D_BASE::GetList(), BOARD_ADAPTER::GetOuterNonPlatedThroughHolePoly(), BOARD_ADAPTER::GetPlatedPadsBack(), BOARD_ADAPTER::GetPlatedPadsFront(), BOARD_ADAPTER::GetPolyMap(), GetRunningMicroSecs(), BOARD_ADAPTER::GetThroughHoleAnnularRingPolys(), BOARD_ADAPTER::GetThroughHoleAnnularRings(), BOARD_ADAPTER::GetThroughHoleIds(), BOARD_ADAPTER::GetThroughHoleOdPolys(), BOARD_ADAPTER::GetThroughHoleOds(), BOARD_ADAPTER::GetThroughHoleViaOdPolys(), BOARD_ADAPTER::GetThroughHoleViaOds(), BOARD_ADAPTER::InitSettings(), OBJECT_2D_STATS::Instance(), BOARD_ADAPTER::Is3dLayerEnabled(), load3dModels(), m_antiBoard, m_antiBoardPolys, m_board, RENDER_3D_BASE::m_boardAdapter, m_boardWithHoles, RENDER_3D_BASE::m_camera, m_innerLayerHoles, m_layers, m_outerLayerHoles, m_outerThroughHoleRings, m_outerThroughHoles, m_outerViaThroughHoles, m_platedPadsBack, m_platedPadsFront, RENDER_3D_BASE::m_reloadRequested, SHAPE_POLY_SET::NewOutline(), SHAPE_POLY_SET::Outline(), SHAPE_POLY_SET::PM_FAST, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE, SHAPE_POLY_SET::RemoveAllContours(), REPORTER::Report(), OBJECT_2D_STATS::ResetStats(), CAMERA::SetBoardLookAtPos(), SHAPE_LINE_CHAIN::SetClosed(), and OPENGL_RENDER_LIST::SetItIsTransparent().

Referenced by Redraw().

◆ ReloadRequest()

void RENDER_3D_BASE::ReloadRequest ( )
inlineinherited
Todo:
This must be reviewed to add flags to improve specific render.

Definition at line 70 of file render_3d_base.h.

70 { m_reloadRequested = true; }
bool m_reloadRequested
The window size that this camera is working.

References RENDER_3D_BASE::m_reloadRequested.

Referenced by EDA_3D_CANVAS::ReloadRequest(), EDA_3D_CANVAS::RenderEngineChanged(), and EDA_3D_CANVAS::RenderRaytracingRequest().

◆ render3dArrows()

void RENDER_3D_OPENGL::render3dArrows ( )
private

Definition at line 129 of file render_3d_opengl.cpp.

130 {
131  const float arrow_size = RANGE_SCALE_3D * 0.30f;
132 
133  glDisable( GL_CULL_FACE );
134 
135  // YxY squared view port, this is on propose
136  glViewport( 4, 4, m_windowSize.y / 8 , m_windowSize.y / 8 );
137  glClear( GL_DEPTH_BUFFER_BIT );
138 
139  glMatrixMode( GL_PROJECTION );
140  glLoadIdentity();
141  gluPerspective( 45.0f, 1.0f, 0.001f, RANGE_SCALE_3D );
142 
143  glMatrixMode( GL_MODELVIEW );
144  glLoadIdentity();
145 
146  const glm::mat4 TranslationMatrix =
147  glm::translate( glm::mat4( 1.0f ), SFVEC3F( 0.0f, 0.0f, -( arrow_size * 2.75f ) ) );
148 
149  const glm::mat4 ViewMatrix = TranslationMatrix * m_camera.GetRotationMatrix();
150 
151  glLoadMatrixf( glm::value_ptr( ViewMatrix ) );
152 
154 
155  glColor3f( 0.9f, 0.0f, 0.0f );
156  DrawRoundArrow( SFVEC3F( 0.0f, 0.0f, 0.0f ), SFVEC3F( arrow_size, 0.0f, 0.0f ), 0.275f );
157 
158  glColor3f( 0.0f, 0.9f, 0.0f );
159  DrawRoundArrow( SFVEC3F( 0.0f, 0.0f, 0.0f ), SFVEC3F( 0.0f, arrow_size, 0.0f ), 0.275f );
160 
161  glColor3f( 0.0f, 0.0f, 0.9f );
162  DrawRoundArrow( SFVEC3F( 0.0f, 0.0f, 0.0f ), SFVEC3F( 0.0f, 0.0f, arrow_size ), 0.275f );
163 
164  glEnable( GL_CULL_FACE );
165 }
const glm::mat4 GetRotationMatrix() const
Get the rotation matrix to be applied in a transformation camera.
Definition: camera.cpp:168
void DrawRoundArrow(SFVEC3F aPosition, SFVEC3F aTargetPos, float aSize)
Draw a round arrow.
glm::vec3 SFVEC3F
Definition: xv3d_types.h:44
CAMERA & m_camera
Flag if the opengl specific for this render was already initialized.
#define RANGE_SCALE_3D
This defines the range that all coord will have to be rendered.
Definition: board_adapter.h:62

References DrawRoundArrow(), CAMERA::GetRotationMatrix(), RENDER_3D_BASE::m_camera, RENDER_3D_BASE::m_windowSize, RANGE_SCALE_3D, and setArrowMaterial().

Referenced by Redraw().

◆ render3dModels()

void RENDER_3D_OPENGL::render3dModels ( bool  aRenderTopOrBot,
bool  aRenderTransparentOnly 
)
private
Parameters
aRenderTopOrBottrue will render Top, false will render bottom
aRenderTransparentOnlytrue will render only the transparent objects, false will render opaque

Definition at line 1215 of file render_3d_opengl.cpp.

1216 {
1218  render3dModelsSelected( aRenderTopOrBot, aRenderTransparentOnly, true );
1219 
1220  render3dModelsSelected( aRenderTopOrBot, aRenderTransparentOnly, false );
1221 }
bool GetFlag(DISPLAY3D_FLG aFlag) const
Get a configuration status of a flag.
BOARD_ADAPTER & m_boardAdapter
void render3dModelsSelected(bool aRenderTopOrBot, bool aRenderTransparentOnly, bool aRenderSelectedOnly)

References FL_USE_SELECTION, BOARD_ADAPTER::GetFlag(), RENDER_3D_BASE::m_boardAdapter, and render3dModelsSelected().

Referenced by Redraw().

◆ render3dModelsSelected()

void RENDER_3D_OPENGL::render3dModelsSelected ( bool  aRenderTopOrBot,
bool  aRenderTransparentOnly,
bool  aRenderSelectedOnly 
)
private

Definition at line 1176 of file render_3d_opengl.cpp.

1178 {
1179  if( !m_boardAdapter.GetBoard() )
1180  return;
1181 
1182  MODEL_3D::BeginDrawMulti( !aRenderSelectedOnly );
1183 
1184  // Go for all footprints
1185  for( FOOTPRINT* fp : m_boardAdapter.GetBoard()->Footprints() )
1186  {
1187  bool highlight = false;
1188 
1190  {
1191  if( fp->IsSelected() )
1192  highlight = true;
1193 
1195  highlight = true;
1196 
1197  if( aRenderSelectedOnly != highlight )
1198  continue;
1199  }
1200 
1201  if( !fp->Models().empty() )
1202  {
1203  if( m_boardAdapter.IsFootprintShown( (FOOTPRINT_ATTR_T) fp->GetAttributes() ) )
1204  {
1205  if( aRenderTopOrBot == !fp->IsFlipped() )
1206  renderFootprint( fp, aRenderTransparentOnly, highlight );
1207  }
1208  }
1209  }
1210 
1212 }
bool GetFlag(DISPLAY3D_FLG aFlag) const
Get a configuration status of a flag.
BOARD_ADAPTER & m_boardAdapter
bool IsFootprintShown(FOOTPRINT_ATTR_T aFPAttributes) const
Test if footprint should be displayed in relation to attributes and the flags.
BOARD_ITEM * m_currentRollOverItem
FOOTPRINT_ATTR_T
The set of attributes allowed within a FOOTPRINT, using FOOTPRINT::SetAttributes() and FOOTPRINT::Get...
Definition: footprint.h:66
FOOTPRINTS & Footprints()
Definition: board.h:234
const BOARD * GetBoard() const noexcept
Get current board to be rendered.
void renderFootprint(const FOOTPRINT *aFootprint, bool aRenderTransparentOnly, bool aIsSelected)
static void EndDrawMulti()
Cleanup render states after drawing multiple models.
Definition: 3d_model.cpp:401
static void BeginDrawMulti(bool aUseColorInformation)
Set some basic render states before drawing multiple models.
Definition: 3d_model.cpp:385

References MODEL_3D::BeginDrawMulti(), MODEL_3D::EndDrawMulti(), FL_HIGHLIGHT_ROLLOVER_ITEM, FL_USE_SELECTION, BOARD::Footprints(), BOARD_ADAPTER::GetBoard(), BOARD_ADAPTER::GetFlag(), BOARD_ADAPTER::IsFootprintShown(), RENDER_3D_BASE::m_boardAdapter, m_currentRollOverItem, and renderFootprint().

Referenced by render3dModels().

◆ renderBoardBody()

void RENDER_3D_OPENGL::renderBoardBody ( bool  aSkipRenderHoles)
private

Definition at line 518 of file render_3d_opengl.cpp.

519 {
520  m_materials.m_EpoxyBoard.m_Diffuse = m_boardAdapter.m_BoardBodyColor;
521 
522  // opacity to transparency
523  m_materials.m_EpoxyBoard.m_Transparency = 1.0f - m_boardAdapter.m_BoardBodyColor.a;
524 
525  OglSetMaterial( m_materials.m_EpoxyBoard, 1.0f );
526 
527  OPENGL_RENDER_LIST* ogl_disp_list = nullptr;
528 
529  if( aSkipRenderHoles )
530  ogl_disp_list = m_board;
531  else
532  ogl_disp_list = m_boardWithHoles;
533 
534  if( ogl_disp_list )
535  {
536  ogl_disp_list->ApplyScalePosition( -m_boardAdapter.GetEpoxyThickness() / 2.0f,
538 
539  ogl_disp_list->SetItIsTransparent( true );
540 
541  ogl_disp_list->DrawAll();
542  }
543 }
BOARD_ADAPTER & m_boardAdapter
OPENGL_RENDER_LIST * m_board
void OglSetMaterial(const SMATERIAL &aMaterial, float aOpacity, bool aUseSelectedMaterial, SFVEC3F aSelectionColor)
Set OpenGL materials.
Definition: ogl_utils.cpp:119
OPENGL_RENDER_LIST * m_boardWithHoles
SFVEC4F m_BoardBodyColor
in realistic mode: FR4 board color
struct RENDER_3D_OPENGL::@2 m_materials
void ApplyScalePosition(float aZposition, float aZscale)
void DrawAll(bool aDrawMiddle=true) const
Call to draw all the display lists.
Store the OpenGL display lists to related with a layer.
void SetItIsTransparent(bool aSetTransparent)
float GetEpoxyThickness() const noexcept
Get the current epoxy thickness.

References OPENGL_RENDER_LIST::ApplyScalePosition(), OPENGL_RENDER_LIST::DrawAll(), BOARD_ADAPTER::GetEpoxyThickness(), m_board, RENDER_3D_BASE::m_boardAdapter, BOARD_ADAPTER::m_BoardBodyColor, m_boardWithHoles, m_materials, OglSetMaterial(), and OPENGL_RENDER_LIST::SetItIsTransparent().

Referenced by Redraw().

◆ renderFootprint()

void RENDER_3D_OPENGL::renderFootprint ( const FOOTPRINT aFootprint,
bool  aRenderTransparentOnly,
bool  aIsSelected 
)
private

Definition at line 1224 of file render_3d_opengl.cpp.

1226 {
1227  if( !aFootprint->Models().empty() )
1228  {
1229  const double zpos = m_boardAdapter.GetFootprintZPos( aFootprint->IsFlipped() );
1230 
1231  glPushMatrix();
1232 
1233  wxPoint pos = aFootprint->GetPosition();
1234 
1235  glTranslatef( pos.x * m_boardAdapter.BiuTo3dUnits(), -pos.y * m_boardAdapter.BiuTo3dUnits(),
1236  zpos );
1237 
1238  if( aFootprint->GetOrientation() )
1239  glRotated( (double) aFootprint->GetOrientation() / 10.0, 0.0, 0.0, 1.0 );
1240 
1241  if( aFootprint->IsFlipped() )
1242  {
1243  glRotatef( 180.0f, 0.0f, 1.0f, 0.0f );
1244  glRotatef( 180.0f, 0.0f, 0.0f, 1.0f );
1245  }
1246 
1247  double modelunit_to_3d_units_factor = m_boardAdapter.BiuTo3dUnits() * UNITS3D_TO_UNITSPCB;
1248 
1249  glScaled( modelunit_to_3d_units_factor, modelunit_to_3d_units_factor,
1250  modelunit_to_3d_units_factor );
1251 
1252  // Get the list of model files for this model
1253  for( const FP_3DMODEL& sM : aFootprint->Models() )
1254  {
1255  if( !sM.m_Show || sM.m_Filename.empty() )
1256  continue;
1257 
1258  // Check if the model is present in our cache map
1259  auto cache_i = m_3dModelMap.find( sM.m_Filename );
1260 
1261  if( cache_i == m_3dModelMap.end() )
1262  continue;
1263 
1264  if( const MODEL_3D* modelPtr = cache_i->second )
1265  {
1266  bool opaque = sM.m_Opacity >= 1.0;
1267 
1268  if( ( !aRenderTransparentOnly && modelPtr->HasOpaqueMeshes() && opaque ) ||
1269  ( aRenderTransparentOnly && ( modelPtr->HasTransparentMeshes() || !opaque ) ) )
1270  {
1271  glPushMatrix();
1272 
1273  // FIXME: don't do this over and over again unless the
1274  // values have changed. cache the matrix somewhere.
1275  glm::mat4 mtx( 1 );
1276  mtx = glm::translate( mtx, { sM.m_Offset.x, sM.m_Offset.y, sM.m_Offset.z } );
1277  mtx = glm::rotate( mtx, glm::radians( (float) -sM.m_Rotation.z ),
1278  { 0.0f, 0.0f, 1.0f } );
1279  mtx = glm::rotate( mtx, glm::radians( (float) -sM.m_Rotation.y ),
1280  { 0.0f, 1.0f, 0.0f } );
1281  mtx = glm::rotate( mtx, glm::radians( (float) -sM.m_Rotation.x ),
1282  { 1.0f, 0.0f, 0.0f } );
1283  mtx = glm::scale( mtx, { sM.m_Scale.x, sM.m_Scale.y, sM.m_Scale.z } );
1284  glMultMatrixf( glm::value_ptr( mtx ) );
1285 
1286  if( aRenderTransparentOnly )
1287  {
1288  modelPtr->DrawTransparent( sM.m_Opacity,
1289  aFootprint->IsSelected() || aIsSelected,
1291  }
1292  else
1293  {
1294  modelPtr->DrawOpaque( aFootprint->IsSelected() || aIsSelected,
1296  }
1297 
1299  {
1300  glEnable( GL_BLEND );
1301  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
1302 
1303  glDisable( GL_LIGHTING );
1304 
1305  glLineWidth( 1 );
1306  modelPtr->DrawBboxes();
1307 
1308  glLineWidth( 4 );
1309  modelPtr->DrawBbox();
1310 
1311  glEnable( GL_LIGHTING );
1312  glDisable( GL_BLEND );
1313  }
1314 
1315  glPopMatrix();
1316  }
1317  }
1318  }
1319 
1320  glPopMatrix();
1321  }
1322 }
bool GetFlag(DISPLAY3D_FLG aFlag) const
Get a configuration status of a flag.
BOARD_ADAPTER & m_boardAdapter
std::list< FP_3DMODEL > & Models()
Definition: footprint.h:183
bool IsSelected() const
Definition: eda_item.h:122
double GetOrientation() const
Definition: footprint.h:191
#define UNITS3D_TO_UNITSPCB
Scale conversion from 3d model units to pcb units.
double BiuTo3dUnits() const noexcept
Board integer units To 3D units.
float GetFootprintZPos(bool aIsFlipped) const
Get the position of the footprint in 3d integer units considering if it is flipped or not.
bool IsFlipped() const
Definition: footprint.h:278
const int scale
wxPoint GetPosition() const override
Definition: footprint.h:187
SFVEC3F m_OpenGlSelectionColor
MAP_3DMODEL m_3dModelMap

References BOARD_ADAPTER::BiuTo3dUnits(), FL_RENDER_OPENGL_SHOW_MODEL_BBOX, BOARD_ADAPTER::GetFlag(), BOARD_ADAPTER::GetFootprintZPos(), FOOTPRINT::GetOrientation(), FOOTPRINT::GetPosition(), FOOTPRINT::IsFlipped(), EDA_ITEM::IsSelected(), m_3dModelMap, RENDER_3D_BASE::m_boardAdapter, BOARD_ADAPTER::m_OpenGlSelectionColor, FOOTPRINT::Models(), scale, and UNITS3D_TO_UNITSPCB.

Referenced by render3dModelsSelected().

◆ renderSolderMaskLayer()

void RENDER_3D_OPENGL::renderSolderMaskLayer ( PCB_LAYER_ID  aLayerID,
float  aZPosition,
bool  aDrawMiddleSegments,
bool  aSkipRenderHoles 
)
private

Definition at line 1118 of file render_3d_opengl.cpp.

1120 {
1121  wxASSERT( (aLayerID == B_Mask) || (aLayerID == F_Mask) );
1122 
1123  float nonCopperThickness = m_boardAdapter.GetNonCopperLayerThickness();
1124 
1125  if( m_board )
1126  {
1127  if( m_layers.find( aLayerID ) != m_layers.end() )
1128  {
1129  OPENGL_RENDER_LIST* pLayerDispListMask = m_layers.at( aLayerID );
1130 
1132  m_outerViaThroughHoles->ApplyScalePosition( aZPosition, nonCopperThickness );
1133 
1134  m_board->ApplyScalePosition( aZPosition, nonCopperThickness );
1135 
1136  setLayerMaterial( aLayerID );
1137 
1138  m_board->SetItIsTransparent( true );
1139 
1140  if( aSkipRenderHoles )
1141  {
1142  m_board->DrawAllCameraCulled( m_camera.GetPos().z, aDrawMiddleSegments );
1143  }
1144  else
1145  {
1146  m_board->DrawAllCameraCulledSubtractLayer( aDrawMiddleSegments, pLayerDispListMask,
1148  }
1149  }
1150  else
1151  {
1152  // This case there is no layer with mask, so we will render the full board as mask
1154  m_outerViaThroughHoles->ApplyScalePosition( aZPosition, nonCopperThickness );
1155 
1156  m_board->ApplyScalePosition( aZPosition, nonCopperThickness );
1157 
1158  setLayerMaterial( aLayerID );
1159 
1160  m_board->SetItIsTransparent( true );
1161 
1162  if( aSkipRenderHoles )
1163  {
1164  m_board->DrawAllCameraCulled( m_camera.GetPos().z, aDrawMiddleSegments );
1165  }
1166  else
1167  {
1168  m_board->DrawAllCameraCulledSubtractLayer( aDrawMiddleSegments,
1170  }
1171  }
1172  }
1173 }
BOARD_ADAPTER & m_boardAdapter
OPENGL_RENDER_LIST * m_board
OPENGL_RENDER_LIST * m_outerViaThroughHoles
void DrawAllCameraCulledSubtractLayer(bool aDrawMiddle, const OPENGL_RENDER_LIST *aLayerToSubtractA=nullptr, const OPENGL_RENDER_LIST *aLayerToSubtractB=nullptr, const OPENGL_RENDER_LIST *aLayerToSubtractC=nullptr, const OPENGL_RENDER_LIST *aLayerToSubtractD=nullptr) const
void DrawAllCameraCulled(float zCameraPos, bool aDrawMiddle=true) const
Draw all layers if they are visible by the camera if camera position is above the layer.
float GetNonCopperLayerThickness() const noexcept
Get the current non copper layers thickness.
const SFVEC3F & GetPos() const
Definition: camera.h:107
MAP_OGL_DISP_LISTS m_layers
void ApplyScalePosition(float aZposition, float aZscale)
Store the OpenGL display lists to related with a layer.
void setLayerMaterial(PCB_LAYER_ID aLayerID)
CAMERA & m_camera
Flag if the opengl specific for this render was already initialized.
void SetItIsTransparent(bool aSetTransparent)

References OPENGL_RENDER_LIST::ApplyScalePosition(), B_Mask, OPENGL_RENDER_LIST::DrawAllCameraCulled(), OPENGL_RENDER_LIST::DrawAllCameraCulledSubtractLayer(), F_Mask, BOARD_ADAPTER::GetNonCopperLayerThickness(), CAMERA::GetPos(), m_board, RENDER_3D_BASE::m_boardAdapter, RENDER_3D_BASE::m_camera, m_layers, m_outerViaThroughHoles, OPENGL_RENDER_LIST::SetItIsTransparent(), and setLayerMaterial().

Referenced by Redraw().

◆ setArrowMaterial()

void RENDER_3D_OPENGL::setArrowMaterial ( )
private

Definition at line 1017 of file render_3d_opengl.cpp.

1018 {
1019  glEnable( GL_COLOR_MATERIAL );
1020  glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
1021 
1022  const SFVEC4F ambient = SFVEC4F( 0.0f, 0.0f, 0.0f, 1.0f );
1023  const SFVEC4F diffuse = SFVEC4F( 0.0f, 0.0f, 0.0f, 1.0f );
1024  const SFVEC4F emissive = SFVEC4F( 0.0f, 0.0f, 0.0f, 1.0f );
1025  const SFVEC4F specular = SFVEC4F( 0.1f, 0.1f, 0.1f, 1.0f );
1026 
1027  glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.r );
1028  glMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, 96.0f );
1029 
1030  glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, &ambient.r );
1031  glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, &diffuse.r );
1032  glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, &emissive.r );
1033 }
glm::vec4 SFVEC4F
Definition: xv3d_types.h:46

Referenced by render3dArrows().

◆ SetBusyIndicatorFactory()

void RENDER_3D_BASE::SetBusyIndicatorFactory ( BUSY_INDICATOR::FACTORY  aNewFactory)
inherited

Set a new busy indicator factory.

When set, this factory will be used to generate busy indicators when suitable. If not set, no busy indicator will be used.

Definition at line 64 of file render_3d_base.cpp.

65 {
66  m_busyIndicatorFactory = aNewFactory;
67 }
BUSY_INDICATOR::FACTORY m_busyIndicatorFactory
< Factory that returns a suitable busy indicator for the context.

References RENDER_3D_BASE::m_busyIndicatorFactory.

◆ setCopperMaterial()

void RENDER_3D_OPENGL::setCopperMaterial ( )
private

Definition at line 498 of file render_3d_opengl.cpp.

499 {
500  OglSetMaterial( m_materials.m_NonPlatedCopper, 1.0f );
501 }
void OglSetMaterial(const SMATERIAL &aMaterial, float aOpacity, bool aUseSelectedMaterial, SFVEC3F aSelectionColor)
Set OpenGL materials.
Definition: ogl_utils.cpp:119
struct RENDER_3D_OPENGL::@2 m_materials

References m_materials, and OglSetMaterial().

Referenced by Redraw().

◆ SetCurrentRollOverItem()

void RENDER_3D_OPENGL::SetCurrentRollOverItem ( BOARD_ITEM aRollOverItem)
inline

Definition at line 66 of file render_3d_opengl.h.

67  {
68  m_currentRollOverItem = aRollOverItem;
69  }
BOARD_ITEM * m_currentRollOverItem

References m_currentRollOverItem.

Referenced by EDA_3D_CANVAS::OnMouseMove().

◆ SetCurWindowSize()

void RENDER_3D_OPENGL::SetCurWindowSize ( const wxSize &  aSize)
overridevirtual

Before each render, the canvas will tell the render what is the size of its windows, so render can take actions if it changed.

Parameters
aSizethe current size of the render window

Implements RENDER_3D_BASE.

Definition at line 90 of file render_3d_opengl.cpp.

91 {
92  if( m_windowSize != aSize )
93  {
94  m_windowSize = aSize;
95  glViewport( 0, 0, m_windowSize.x, m_windowSize.y );
96 
97  // Initialize here any screen dependent data here
98  }
99 }

References RENDER_3D_BASE::m_windowSize.

◆ setLayerMaterial()

void RENDER_3D_OPENGL::setLayerMaterial ( PCB_LAYER_ID  aLayerID)
private

Definition at line 317 of file render_3d_opengl.cpp.

318 {
319  switch( aLayerID )
320  {
321  case F_Mask:
322  case B_Mask:
323  {
324  const SFVEC4F layerColor = getLayerColor( aLayerID );
325 
326  m_materials.m_SolderMask.m_Diffuse = layerColor;
327 
328  // Convert Opacity to Transparency
329  m_materials.m_SolderMask.m_Transparency = 1.0f - layerColor.a;
330 
332  {
333  m_materials.m_SolderMask.m_Ambient = m_materials.m_SolderMask.m_Diffuse * 0.3f;
334 
335  m_materials.m_SolderMask.m_Specular =
336  m_materials.m_SolderMask.m_Diffuse * m_materials.m_SolderMask.m_Diffuse;
337  }
338 
339  OglSetMaterial( m_materials.m_SolderMask, 1.0f );
340  break;
341  }
342 
343  case B_Paste:
344  case F_Paste:
345  m_materials.m_Paste.m_Diffuse = getLayerColor( aLayerID );
346  OglSetMaterial( m_materials.m_Paste, 1.0f );
347  break;
348 
349  case B_SilkS:
350  m_materials.m_SilkSBot.m_Diffuse = getLayerColor( aLayerID );
351  OglSetMaterial( m_materials.m_SilkSBot, 1.0f );
352  break;
353 
354  case F_SilkS:
355  m_materials.m_SilkSTop.m_Diffuse = getLayerColor( aLayerID );
356  OglSetMaterial( m_materials.m_SilkSTop, 1.0f );
357  break;
358 
359  case B_Adhes:
360  case F_Adhes:
361  case Dwgs_User:
362  case Cmts_User:
363  case Eco1_User:
364  case Eco2_User:
365  case Edge_Cuts:
366  case Margin:
367  case B_CrtYd:
368  case F_CrtYd:
369  case B_Fab:
370  case F_Fab:
371  m_materials.m_Plastic.m_Diffuse = getLayerColor( aLayerID );
372 
373  m_materials.m_Plastic.m_Ambient = SFVEC3F( m_materials.m_Plastic.m_Diffuse.r * 0.05f,
374  m_materials.m_Plastic.m_Diffuse.g * 0.05f,
375  m_materials.m_Plastic.m_Diffuse.b * 0.05f );
376 
377  m_materials.m_Plastic.m_Specular = SFVEC3F( m_materials.m_Plastic.m_Diffuse.r * 0.7f,
378  m_materials.m_Plastic.m_Diffuse.g * 0.7f,
379  m_materials.m_Plastic.m_Diffuse.b * 0.7f );
380 
381  m_materials.m_Plastic.m_Shininess = 0.078125f * 128.0f;
382  m_materials.m_Plastic.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
383  OglSetMaterial( m_materials.m_Plastic, 1.0f );
384  break;
385 
386  default:
387  m_materials.m_Copper.m_Diffuse = getLayerColor( aLayerID );
388  OglSetMaterial( m_materials.m_Copper, 1.0f );
389  break;
390  }
391 }
bool GetFlag(DISPLAY3D_FLG aFlag) const
Get a configuration status of a flag.
BOARD_ADAPTER & m_boardAdapter
void OglSetMaterial(const SMATERIAL &aMaterial, float aOpacity, bool aUseSelectedMaterial, SFVEC3F aSelectionColor)
Set OpenGL materials.
Definition: ogl_utils.cpp:119
glm::vec4 SFVEC4F
Definition: xv3d_types.h:46
struct RENDER_3D_OPENGL::@2 m_materials
glm::vec3 SFVEC3F
Definition: xv3d_types.h:44
SFVEC4F getLayerColor(PCB_LAYER_ID aLayerID)

References B_Adhes, B_CrtYd, B_Fab, B_Mask, B_Paste, B_SilkS, Cmts_User, Dwgs_User, Eco1_User, Eco2_User, Edge_Cuts, F_Adhes, F_CrtYd, F_Fab, F_Mask, F_Paste, F_SilkS, FL_USE_REALISTIC_MODE, BOARD_ADAPTER::GetFlag(), getLayerColor(), RENDER_3D_BASE::m_boardAdapter, m_materials, Margin, and OglSetMaterial().

Referenced by Redraw(), renderSolderMaskLayer(), and setPlatedCopperAndDepthOffset().

◆ setLightBottom()

void RENDER_3D_OPENGL::setLightBottom ( bool  enabled)
private

Definition at line 120 of file render_3d_opengl.cpp.

121 {
122  if( enabled )
123  glEnable( GL_LIGHT2 );
124  else
125  glDisable( GL_LIGHT2 );
126 }

Referenced by Redraw().

◆ setLightFront()

void RENDER_3D_OPENGL::setLightFront ( bool  enabled)
private

Definition at line 102 of file render_3d_opengl.cpp.

103 {
104  if( enabled )
105  glEnable( GL_LIGHT0 );
106  else
107  glDisable( GL_LIGHT0 );
108 }

Referenced by Redraw().

◆ setLightTop()

void RENDER_3D_OPENGL::setLightTop ( bool  enabled)
private

Definition at line 111 of file render_3d_opengl.cpp.

112 {
113  if( enabled )
114  glEnable( GL_LIGHT1 );
115  else
116  glDisable( GL_LIGHT1 );
117 }

Referenced by Redraw().

◆ setPlatedCopperAndDepthOffset()

void RENDER_3D_OPENGL::setPlatedCopperAndDepthOffset ( PCB_LAYER_ID  aLayer_id)
private

Definition at line 504 of file render_3d_opengl.cpp.

505 {
506  glEnable( GL_POLYGON_OFFSET_FILL );
507  glPolygonOffset(-0.1f, -2.0f );
508  setLayerMaterial( aLayer_id );
509 }
void setLayerMaterial(PCB_LAYER_ID aLayerID)

References setLayerMaterial().

Referenced by Redraw().

◆ setupMaterials()

void RENDER_3D_OPENGL::setupMaterials ( )
private

Definition at line 168 of file render_3d_opengl.cpp.

169 {
170  m_materials = {};
171 
173  {
174  // http://devernay.free.fr/cours/opengl/materials.html
175 
176  // Plated copper
177  // Copper material mixed with the copper color
178  m_materials.m_Copper.m_Ambient = SFVEC3F( m_boardAdapter.m_CopperColor.r * 0.1f,
179  m_boardAdapter.m_CopperColor.g * 0.1f,
180  m_boardAdapter.m_CopperColor.b * 0.1f);
181 
182  m_materials.m_Copper.m_Specular = SFVEC3F( m_boardAdapter.m_CopperColor.r * 0.75f + 0.25f,
183  m_boardAdapter.m_CopperColor.g * 0.75f + 0.25f,
184  m_boardAdapter.m_CopperColor.b * 0.75f + 0.25f );
185 
186  // This guess the material type(ex: copper vs gold) to determine the
187  // shininess factor between 0.1 and 0.4
188  float shininessfactor = 0.40f - mapf( fabs( m_boardAdapter.m_CopperColor.r -
190  0.15f, 1.00f,
191  0.00f, 0.30f );
192 
193  m_materials.m_Copper.m_Shininess = shininessfactor * 128.0f;
194  m_materials.m_Copper.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
195 
196 
197  // Non plated copper (raw copper)
198  m_materials.m_NonPlatedCopper.m_Ambient = SFVEC3F( 0.191f, 0.073f, 0.022f );
199  m_materials.m_NonPlatedCopper.m_Diffuse = SFVEC3F( 184.0f / 255.0f, 115.0f / 255.0f,
200  50.0f / 255.0f );
201  m_materials.m_NonPlatedCopper.m_Specular = SFVEC3F( 0.256f, 0.137f, 0.086f );
202  m_materials.m_NonPlatedCopper.m_Shininess = 0.1f * 128.0f;
203  m_materials.m_NonPlatedCopper.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
204 
205  // Paste material mixed with paste color
206  m_materials.m_Paste.m_Ambient = SFVEC3F( m_boardAdapter.m_SolderPasteColor.r,
209 
210  m_materials.m_Paste.m_Specular = SFVEC3F( m_boardAdapter.m_SolderPasteColor.r *
216 
217  m_materials.m_Paste.m_Shininess = 0.1f * 128.0f;
218  m_materials.m_Paste.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
219 
220  // Silk screen material mixed with silk screen color
221  m_materials.m_SilkSTop.m_Ambient = SFVEC3F( m_boardAdapter.m_SilkScreenColorTop.r,
224 
225  m_materials.m_SilkSTop.m_Specular = SFVEC3F(
227  0.10f,
229  0.10f,
231  0.10f );
232 
233  m_materials.m_SilkSTop.m_Shininess = 0.078125f * 128.0f;
234  m_materials.m_SilkSTop.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
235 
236  // Silk screen material mixed with silk screen color
237  m_materials.m_SilkSBot.m_Ambient = SFVEC3F( m_boardAdapter.m_SilkScreenColorBot.r,
240 
241  m_materials.m_SilkSBot.m_Specular = SFVEC3F(
243  0.10f,
245  0.10f,
247  0.10f );
248 
249  m_materials.m_SilkSBot.m_Shininess = 0.078125f * 128.0f;
250  m_materials.m_SilkSBot.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
251 
252  m_materials.m_SolderMask.m_Shininess = 0.8f * 128.0f;
253  m_materials.m_SolderMask.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
254 
255  // Epoxy material
256  m_materials.m_EpoxyBoard.m_Ambient = SFVEC3F( 117.0f / 255.0f, 97.0f / 255.0f,
257  47.0f / 255.0f );
258 
259  m_materials.m_EpoxyBoard.m_Specular = SFVEC3F( 18.0f / 255.0f, 3.0f / 255.0f,
260  20.0f / 255.0f );
261 
262  m_materials.m_EpoxyBoard.m_Shininess = 0.1f * 128.0f;
263  m_materials.m_EpoxyBoard.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
264  }
265  else // Technical Mode
266  {
267  const SFVEC3F matAmbientColor = SFVEC3F( 0.10f );
268  const SFVEC3F matSpecularColor = SFVEC3F( 0.10f );
269  const float matShininess = 0.1f * 128.0f;
270 
271  // Copper material
272  m_materials.m_Copper.m_Ambient = matAmbientColor;
273  m_materials.m_Copper.m_Specular = matSpecularColor;
274  m_materials.m_Copper.m_Shininess = matShininess;
275  m_materials.m_Copper.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
276 
277  // Paste material
278  m_materials.m_Paste.m_Ambient = matAmbientColor;
279  m_materials.m_Paste.m_Specular = matSpecularColor;
280  m_materials.m_Paste.m_Shininess = matShininess;
281  m_materials.m_Paste.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
282 
283  // Silk screen material
284  m_materials.m_SilkSTop.m_Ambient = matAmbientColor;
285  m_materials.m_SilkSTop.m_Specular = matSpecularColor;
286  m_materials.m_SilkSTop.m_Shininess = matShininess;
287  m_materials.m_SilkSTop.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
288 
289  // Silk screen material
290  m_materials.m_SilkSBot.m_Ambient = matAmbientColor;
291  m_materials.m_SilkSBot.m_Specular = matSpecularColor;
292  m_materials.m_SilkSBot.m_Shininess = matShininess;
293  m_materials.m_SilkSBot.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
294 
295  // Solder mask material
296  m_materials.m_SolderMask.m_Ambient = matAmbientColor;
297  m_materials.m_SolderMask.m_Specular = matSpecularColor;
298  m_materials.m_SolderMask.m_Shininess = matShininess;
299  m_materials.m_SolderMask.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
300 
301  // Epoxy material
302  m_materials.m_EpoxyBoard.m_Ambient = matAmbientColor;
303  m_materials.m_EpoxyBoard.m_Specular = matSpecularColor;
304  m_materials.m_EpoxyBoard.m_Shininess = matShininess;
305  m_materials.m_EpoxyBoard.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
306 
307  // Gray material (used for example in technical vias and pad holes)
308  m_materials.m_GrayMaterial.m_Ambient = SFVEC3F( 0.8f, 0.8f, 0.8f );
309  m_materials.m_GrayMaterial.m_Diffuse = SFVEC3F( 0.3f, 0.3f, 0.3f );
310  m_materials.m_GrayMaterial.m_Specular = SFVEC3F( 0.4f, 0.4f, 0.4f );
311  m_materials.m_GrayMaterial.m_Shininess = 0.01f * 128.0f;
312  m_materials.m_GrayMaterial.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
313  }
314 }
bool GetFlag(DISPLAY3D_FLG aFlag) const
Get a configuration status of a flag.
BOARD_ADAPTER & m_boardAdapter
SFVEC4F m_SilkScreenColorBot
in realistic mode: SilkScreen color ( bot )
float mapf(float x, float in_min, float in_max, float out_min, float out_max)
Definition: 3d_math.h:133
SFVEC4F m_SolderPasteColor
in realistic mode: solder paste color
struct RENDER_3D_OPENGL::@2 m_materials
glm::vec3 SFVEC3F
Definition: xv3d_types.h:44
SFVEC4F m_CopperColor
in realistic mode: copper color
SFVEC4F m_SilkScreenColorTop
in realistic mode: SilkScreen color ( top )

References FL_USE_REALISTIC_MODE, BOARD_ADAPTER::GetFlag(), RENDER_3D_BASE::m_boardAdapter, BOARD_ADAPTER::m_CopperColor, m_materials, BOARD_ADAPTER::m_SilkScreenColorBot, BOARD_ADAPTER::m_SilkScreenColorTop, BOARD_ADAPTER::m_SolderPasteColor, and mapf().

Referenced by Redraw().

◆ unsetDepthOffset()

void RENDER_3D_OPENGL::unsetDepthOffset ( )
private

Definition at line 512 of file render_3d_opengl.cpp.

513 {
514  glDisable( GL_POLYGON_OFFSET_FILL );
515 }

Referenced by Redraw().

Member Data Documentation

◆ m_3dModelMap

MAP_3DMODEL RENDER_3D_OPENGL::m_3dModelMap
private

◆ m_antiBoard

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_antiBoard
private

Definition at line 197 of file render_3d_opengl.h.

Referenced by freeAllLists(), Redraw(), reload(), and RENDER_3D_OPENGL().

◆ m_antiBoardPolys

SHAPE_POLY_SET RENDER_3D_OPENGL::m_antiBoardPolys
private

The negative polygon representation of the board outline.

Definition at line 215 of file render_3d_opengl.h.

Referenced by generateViasAndPads(), and reload().

◆ m_board

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_board
private

◆ m_boardAdapter

◆ m_boardWithHoles

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_boardWithHoles
private

Definition at line 196 of file render_3d_opengl.h.

Referenced by freeAllLists(), reload(), RENDER_3D_OPENGL(), and renderBoardBody().

◆ m_camera

CAMERA& RENDER_3D_BASE::m_camera
protectedinherited

◆ m_canvas

EDA_3D_CANVAS* RENDER_3D_BASE::m_canvas
protectedinherited

Settings reference in use for this render.

Definition at line 102 of file render_3d_base.h.

Referenced by Load3dModelsIfNeeded(), and RENDER_3D_BASE::RENDER_3D_BASE().

◆ m_circleTexture

GLuint RENDER_3D_OPENGL::m_circleTexture
private

◆ m_Copper

SMATERIAL RENDER_3D_OPENGL::m_Copper

Definition at line 185 of file render_3d_opengl.h.

◆ m_currentRollOverItem

BOARD_ITEM* RENDER_3D_OPENGL::m_currentRollOverItem
private

◆ m_EpoxyBoard

SMATERIAL RENDER_3D_OPENGL::m_EpoxyBoard

Definition at line 183 of file render_3d_opengl.h.

◆ m_GrayMaterial

SMATERIAL RENDER_3D_OPENGL::m_GrayMaterial

Definition at line 187 of file render_3d_opengl.h.

◆ m_grid

GLuint RENDER_3D_OPENGL::m_grid
private

oGL list that stores current grid

Definition at line 205 of file render_3d_opengl.h.

Referenced by freeAllLists(), generate3dGrid(), Redraw(), and RENDER_3D_OPENGL().

◆ m_innerLayerHoles

MAP_OGL_DISP_LISTS RENDER_3D_OPENGL::m_innerLayerHoles
private

Definition at line 194 of file render_3d_opengl.h.

Referenced by freeAllLists(), reload(), and RENDER_3D_OPENGL().

◆ m_is_opengl_initialized

bool RENDER_3D_BASE::m_is_opengl_initialized
protectedinherited
Todo:
This must be reviewed in order to flag change types.

Definition at line 110 of file render_3d_base.h.

Referenced by RENDER_3D_RAYTRACE::initializeOpenGL(), initializeOpenGL(), Redraw(), RENDER_3D_RAYTRACE::Redraw(), and RENDER_3D_BASE::RENDER_3D_BASE().

◆ m_lastGridType

GRID3D_TYPE RENDER_3D_OPENGL::m_lastGridType
private

Stores the last grid type.

Definition at line 206 of file render_3d_opengl.h.

Referenced by Redraw(), and RENDER_3D_OPENGL().

◆ m_layers

MAP_OGL_DISP_LISTS RENDER_3D_OPENGL::m_layers
private

◆ m_materials

struct { ... } RENDER_3D_OPENGL::m_materials

◆ m_NonPlatedCopper

SMATERIAL RENDER_3D_OPENGL::m_NonPlatedCopper

Definition at line 184 of file render_3d_opengl.h.

◆ m_outerLayerHoles

MAP_OGL_DISP_LISTS RENDER_3D_OPENGL::m_outerLayerHoles
private

Definition at line 193 of file render_3d_opengl.h.

Referenced by freeAllLists(), Redraw(), reload(), and RENDER_3D_OPENGL().

◆ m_outerThroughHoleRings

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_outerThroughHoleRings
private

Definition at line 200 of file render_3d_opengl.h.

Referenced by freeAllLists(), Redraw(), reload(), and RENDER_3D_OPENGL().

◆ m_outerThroughHoles

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_outerThroughHoles
private

Definition at line 198 of file render_3d_opengl.h.

Referenced by freeAllLists(), Redraw(), reload(), and RENDER_3D_OPENGL().

◆ m_outerViaThroughHoles

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_outerViaThroughHoles
private

Definition at line 199 of file render_3d_opengl.h.

Referenced by freeAllLists(), reload(), RENDER_3D_OPENGL(), and renderSolderMaskLayer().

◆ m_padHoles

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_padHoles
private

Definition at line 209 of file render_3d_opengl.h.

Referenced by freeAllLists(), generateViasAndPads(), Redraw(), and RENDER_3D_OPENGL().

◆ m_Paste

SMATERIAL RENDER_3D_OPENGL::m_Paste

Definition at line 179 of file render_3d_opengl.h.

◆ m_Plastic

SMATERIAL RENDER_3D_OPENGL::m_Plastic

Definition at line 186 of file render_3d_opengl.h.

◆ m_platedPadsBack

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_platedPadsBack
private

Definition at line 192 of file render_3d_opengl.h.

Referenced by freeAllLists(), Redraw(), reload(), and RENDER_3D_OPENGL().

◆ m_platedPadsFront

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_platedPadsFront
private

Definition at line 191 of file render_3d_opengl.h.

Referenced by freeAllLists(), Redraw(), reload(), and RENDER_3D_OPENGL().

◆ m_reloadRequested

bool RENDER_3D_BASE::m_reloadRequested
protectedinherited

◆ m_SilkSBot

SMATERIAL RENDER_3D_OPENGL::m_SilkSBot

Definition at line 180 of file render_3d_opengl.h.

◆ m_SilkSTop

SMATERIAL RENDER_3D_OPENGL::m_SilkSTop

Definition at line 181 of file render_3d_opengl.h.

◆ m_SolderMask

SMATERIAL RENDER_3D_OPENGL::m_SolderMask

Definition at line 182 of file render_3d_opengl.h.

◆ m_triangles

LIST_TRIANGLES RENDER_3D_OPENGL::m_triangles
private

store pointers so can be deleted latter

Definition at line 202 of file render_3d_opengl.h.

Referenced by freeAllLists(), generateLayerList(), and RENDER_3D_OPENGL().

◆ m_vias

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_vias
private

Definition at line 208 of file render_3d_opengl.h.

Referenced by freeAllLists(), generateViasAndPads(), Redraw(), and RENDER_3D_OPENGL().

◆ m_windowSize


The documentation for this class was generated from the following files: