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)
 
OPENGL_RENDER_LISTgenerateEmptyLayerList (PCB_LAYER_ID aLayerId)
 
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 685 of file opengl/create_scene.cpp.

688 {
689  aDst->m_layer_bot_triangles->AddTriangle( SFVEC3F( v0.x, v0.y, bot ),
690  SFVEC3F( v1.x, v1.y, bot ),
691  SFVEC3F( v2.x, v2.y, bot ) );
692 
693  aDst->m_layer_top_triangles->AddTriangle( SFVEC3F( v2.x, v2.y, top ),
694  SFVEC3F( v1.x, v1.y, top ),
695  SFVEC3F( v0.x, v0.y, top ) );
696 }
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 393 of file opengl/create_scene.cpp.

395 {
396  OPENGL_RENDER_LIST* dispLists = nullptr;
397  CONTAINER_2D boardContainer;
398  SHAPE_POLY_SET brd_outlines = aBoardPoly;
399 
400  ConvertPolygonToTriangles( brd_outlines, boardContainer, m_boardAdapter.BiuTo3dUnits(),
401  (const BOARD_ITEM &)*m_boardAdapter.GetBoard() );
402 
403  const LIST_OBJECT2D& listBoardObject2d = boardContainer.GetList();
404 
405  if( listBoardObject2d.size() > 0 )
406  {
407  // We will set a unitary Z so it will in future used with transformations since the
408  // board poly will be used not only to draw itself but also the solder mask layers.
409  const float layer_z_top = 1.0f;
410  const float layer_z_bot = 0.0f;
411 
412  TRIANGLE_DISPLAY_LIST* layerTriangles =
413  new TRIANGLE_DISPLAY_LIST( listBoardObject2d.size() );
414 
415  // Convert the list of objects(triangles) to triangle layer structure
416  for( const OBJECT_2D* itemOnLayer : listBoardObject2d )
417  {
418  const OBJECT_2D* object2d_A = itemOnLayer;
419 
420  wxASSERT( object2d_A->GetObjectType() == OBJECT_2D_TYPE::TRIANGLE );
421 
422  const TRIANGLE_2D* tri = static_cast<const TRIANGLE_2D*>( object2d_A );
423 
424  const SFVEC2F& v1 = tri->GetP1();
425  const SFVEC2F& v2 = tri->GetP2();
426  const SFVEC2F& v3 = tri->GetP3();
427 
428  addTopAndBottomTriangles( layerTriangles, v1, v2, v3, layer_z_top, layer_z_bot );
429  }
430 
431  if( aBoardPoly.OutlineCount() > 0 )
432  {
433  layerTriangles->AddToMiddleContourns( aBoardPoly, layer_z_bot, layer_z_top,
434  m_boardAdapter.BiuTo3dUnits(), false,
435  aThroughHoles );
436 
437  dispLists = new OPENGL_RENDER_LIST( *layerTriangles, m_circleTexture,
438  layer_z_top, layer_z_top );
439  }
440 
441  delete layerTriangles;
442  }
443 
444  return dispLists;
445 }
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 1024 of file render_3d_opengl.cpp.

1025 {
1026  if( glIsList( m_grid ) )
1027  glDeleteLists( m_grid, 1 );
1028 
1029  m_grid = 0;
1030 
1031  for( MAP_OGL_DISP_LISTS::const_iterator ii = m_layers.begin(); ii != m_layers.end(); ++ii )
1032  {
1033  OPENGL_RENDER_LIST* pLayerDispList = static_cast<OPENGL_RENDER_LIST*>( ii->second );
1034  delete pLayerDispList;
1035  }
1036 
1037  m_layers.clear();
1038 
1039  delete m_platedPadsFront;
1040  m_platedPadsFront = nullptr;
1041 
1042  delete m_platedPadsBack;
1043  m_platedPadsBack = nullptr;
1044 
1045  for( MAP_OGL_DISP_LISTS::const_iterator ii = m_outerLayerHoles.begin();
1046  ii != m_outerLayerHoles.end();
1047  ++ii )
1048  {
1049  OPENGL_RENDER_LIST* pLayerDispList = static_cast<OPENGL_RENDER_LIST*>( ii->second );
1050  delete pLayerDispList;
1051  }
1052 
1053  m_outerLayerHoles.clear();
1054 
1055  for( MAP_OGL_DISP_LISTS::const_iterator ii = m_innerLayerHoles.begin();
1056  ii != m_innerLayerHoles.end();
1057  ++ii )
1058  {
1059  OPENGL_RENDER_LIST* pLayerDispList = static_cast<OPENGL_RENDER_LIST*>( ii->second );
1060  delete pLayerDispList;
1061  }
1062 
1063  m_innerLayerHoles.clear();
1064 
1065  for( LIST_TRIANGLES::const_iterator ii = m_triangles.begin(); ii != m_triangles.end(); ++ii )
1066  {
1067  delete *ii;
1068  }
1069 
1070  m_triangles.clear();
1071 
1072  for( MAP_3DMODEL::const_iterator ii = m_3dModelMap.begin(); ii != m_3dModelMap.end(); ++ii )
1073  {
1074  MODEL_3D* pointer = static_cast<MODEL_3D*>(ii->second);
1075  delete pointer;
1076  }
1077 
1078  m_3dModelMap.clear();
1079 
1080  delete m_board;
1081  m_board = nullptr;
1082 
1083  delete m_boardWithHoles;
1084  m_boardWithHoles = nullptr;
1085 
1086  delete m_antiBoard;
1087  m_antiBoard = nullptr;
1088 
1089  delete m_outerThroughHoles;
1090  m_outerThroughHoles = nullptr;
1091 
1092  delete m_outerViaThroughHoles;
1093  m_outerViaThroughHoles = nullptr;
1094 
1095  delete m_outerThroughHoleRings;
1096  m_outerThroughHoleRings = nullptr;
1097 
1098  delete m_vias;
1099  m_vias = nullptr;
1100 
1101  delete m_padHoles;
1102  m_padHoles = nullptr;
1103 }
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 1313 of file render_3d_opengl.cpp.

1314 {
1315  if( glIsList( m_grid ) )
1316  glDeleteLists( m_grid, 1 );
1317 
1318  m_grid = 0;
1319 
1320  if( aGridType == GRID3D_TYPE::NONE )
1321  return;
1322 
1323  m_grid = glGenLists( 1 );
1324 
1325  if( !glIsList( m_grid ) )
1326  return;
1327 
1328  glNewList( m_grid, GL_COMPILE );
1329 
1330  glEnable( GL_BLEND );
1331  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
1332 
1333  const double zpos = 0.0;
1334 
1335  // Color of grid lines
1336  const SFVEC3F gridColor = m_boardAdapter.GetColor( DARKGRAY );
1337 
1338  // Color of grid lines every 5 lines
1339  const SFVEC3F gridColor_marker = m_boardAdapter.GetColor( LIGHTBLUE );
1340  const double scale = m_boardAdapter.BiuTo3dUnits();
1341  const GLfloat transparency = 0.35f;
1342 
1343  double griSizeMM = 0.0;
1344 
1345  switch( aGridType )
1346  {
1347  default:
1348  case GRID3D_TYPE::NONE:
1349  return;
1350  case GRID3D_TYPE::GRID_1MM:
1351  griSizeMM = 1.0;
1352  break;
1354  griSizeMM = 2.5;
1355  break;
1356  case GRID3D_TYPE::GRID_5MM:
1357  griSizeMM = 5.0;
1358  break;
1360  griSizeMM = 10.0;
1361  break;
1362  }
1363 
1364  glNormal3f( 0.0, 0.0, 1.0 );
1365 
1366  const wxSize brd_size = m_boardAdapter.GetBoardSize();
1367  wxPoint brd_center_pos = m_boardAdapter.GetBoardPos();
1368 
1369  brd_center_pos.y = -brd_center_pos.y;
1370 
1371  const int xsize = std::max( brd_size.x, Millimeter2iu( 100 ) ) * 1.2;
1372  const int ysize = std::max( brd_size.y, Millimeter2iu( 100 ) ) * 1.2;
1373 
1374  // Grid limits, in 3D units
1375  double xmin = ( brd_center_pos.x - xsize / 2 ) * scale;
1376  double xmax = ( brd_center_pos.x + xsize / 2 ) * scale;
1377  double ymin = ( brd_center_pos.y - ysize / 2 ) * scale;
1378  double ymax = ( brd_center_pos.y + ysize / 2 ) * scale;
1379  double zmin = Millimeter2iu( -50 ) * scale;
1380  double zmax = Millimeter2iu( 100 ) * scale;
1381 
1382  // Set rasterised line width (min value = 1)
1383  glLineWidth( 1 );
1384 
1385  // Draw horizontal grid centered on 3D origin (center of the board)
1386  for( int ii = 0; ; ii++ )
1387  {
1388  if( (ii % 5) )
1389  glColor4f( gridColor.r, gridColor.g, gridColor.b, transparency );
1390  else
1391  glColor4f( gridColor_marker.r, gridColor_marker.g, gridColor_marker.b,
1392  transparency );
1393 
1394  const int delta = KiROUND( ii * griSizeMM * IU_PER_MM );
1395 
1396  if( delta <= xsize / 2 ) // Draw grid lines parallel to X axis
1397  {
1398  glBegin( GL_LINES );
1399  glVertex3f( (brd_center_pos.x + delta) * scale, -ymin, zpos );
1400  glVertex3f( (brd_center_pos.x + delta) * scale, -ymax, zpos );
1401  glEnd();
1402 
1403  if( ii != 0 )
1404  {
1405  glBegin( GL_LINES );
1406  glVertex3f( (brd_center_pos.x - delta) * scale, -ymin, zpos );
1407  glVertex3f( (brd_center_pos.x - delta) * scale, -ymax, zpos );
1408  glEnd();
1409  }
1410  }
1411 
1412  if( delta <= ysize / 2 ) // Draw grid lines parallel to Y axis
1413  {
1414  glBegin( GL_LINES );
1415  glVertex3f( xmin, -( brd_center_pos.y + delta ) * scale, zpos );
1416  glVertex3f( xmax, -( brd_center_pos.y + delta ) * scale, zpos );
1417  glEnd();
1418 
1419  if( ii != 0 )
1420  {
1421  glBegin( GL_LINES );
1422  glVertex3f( xmin, -( brd_center_pos.y - delta ) * scale, zpos );
1423  glVertex3f( xmax, -( brd_center_pos.y - delta ) * scale, zpos );
1424  glEnd();
1425  }
1426  }
1427 
1428  if( ( delta > ysize / 2 ) && ( delta > xsize / 2 ) )
1429  break;
1430  }
1431 
1432  // Draw vertical grid on Z axis
1433  glNormal3f( 0.0, -1.0, 0.0 );
1434 
1435  // Draw vertical grid lines (parallel to Z axis)
1436  double posy = -brd_center_pos.y * scale;
1437 
1438  for( int ii = 0; ; ii++ )
1439  {
1440  if( (ii % 5) )
1441  glColor4f( gridColor.r, gridColor.g, gridColor.b, transparency );
1442  else
1443  glColor4f( gridColor_marker.r, gridColor_marker.g, gridColor_marker.b,
1444  transparency );
1445 
1446  const double delta = ii * griSizeMM * IU_PER_MM;
1447 
1448  glBegin( GL_LINES );
1449  xmax = ( brd_center_pos.x + delta ) * scale;
1450 
1451  glVertex3f( xmax, posy, zmin );
1452  glVertex3f( xmax, posy, zmax );
1453  glEnd();
1454 
1455  if( ii != 0 )
1456  {
1457  glBegin( GL_LINES );
1458  xmin = ( brd_center_pos.x - delta ) * scale;
1459  glVertex3f( xmin, posy, zmin );
1460  glVertex3f( xmin, posy, zmax );
1461  glEnd();
1462  }
1463 
1464  if( delta > xsize / 2.0f )
1465  break;
1466  }
1467 
1468  // Draw horizontal grid lines on Z axis (parallel to X axis)
1469  for( int ii = 0; ; ii++ )
1470  {
1471  if( ii % 5 )
1472  glColor4f( gridColor.r, gridColor.g, gridColor.b, transparency );
1473  else
1474  glColor4f( gridColor_marker.r, gridColor_marker.g, gridColor_marker.b, transparency );
1475 
1476  const double delta = ii * griSizeMM * IU_PER_MM * scale;
1477 
1478  if( delta <= zmax )
1479  {
1480  // Draw grid lines on Z axis (positive Z axis coordinates)
1481  glBegin( GL_LINES );
1482  glVertex3f( xmin, posy, delta );
1483  glVertex3f( xmax, posy, delta );
1484  glEnd();
1485  }
1486 
1487  if( delta <= -zmin && ( ii != 0 ) )
1488  {
1489  // Draw grid lines on Z axis (negative Z axis coordinates)
1490  glBegin( GL_LINES );
1491  glVertex3f( xmin, posy, -delta );
1492  glVertex3f( xmax, posy, -delta );
1493  glEnd();
1494  }
1495 
1496  if( ( delta > zmax ) && ( delta > -zmin ) )
1497  break;
1498  }
1499 
1500  glDisable( GL_BLEND );
1501 
1502  glEndList();
1503 }
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 713 of file opengl/create_scene.cpp.

717 {
718  std::vector< SFVEC2F > innerContour;
719  std::vector< SFVEC2F > outerContour;
720 
721  generateRing( aCenter, aInnerRadius, aOuterRadius, aNr_sides_per_circle, innerContour,
722  outerContour, false );
723 
724  for( unsigned int i = 0; i < ( innerContour.size() - 1 ); ++i )
725  {
726  const SFVEC2F& vi0 = innerContour[i + 0];
727  const SFVEC2F& vi1 = innerContour[i + 1];
728  const SFVEC2F& vo0 = outerContour[i + 0];
729  const SFVEC2F& vo1 = outerContour[i + 1];
730 
731  aDstLayer->m_layer_top_triangles->AddQuad( SFVEC3F( vi1.x, vi1.y, aZtop ),
732  SFVEC3F( vi0.x, vi0.y, aZtop ),
733  SFVEC3F( vo0.x, vo0.y, aZtop ),
734  SFVEC3F( vo1.x, vo1.y, aZtop ) );
735 
736  aDstLayer->m_layer_bot_triangles->AddQuad( SFVEC3F( vi1.x, vi1.y, aZbot ),
737  SFVEC3F( vo1.x, vo1.y, aZbot ),
738  SFVEC3F( vo0.x, vo0.y, aZbot ),
739  SFVEC3F( vi0.x, vi0.y, aZbot ) );
740  }
741 
742  aDstLayer->AddToMiddleContourns( outerContour, aZbot, aZtop, true );
743  aDstLayer->AddToMiddleContourns( innerContour, aZbot, aZtop, false );
744 }
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().

◆ generateEmptyLayerList()

OPENGL_RENDER_LIST * RENDER_3D_OPENGL::generateEmptyLayerList ( PCB_LAYER_ID  aLayerId)
private

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

378 {
379  float layer_z_bot = 0.0f;
380  float layer_z_top = 0.0f;
381 
382  getLayerZPos( aLayerId, layer_z_top, layer_z_bot );
383 
384  TRIANGLE_DISPLAY_LIST* layerTriangles = new TRIANGLE_DISPLAY_LIST( 1 );
385 
386  // store in a list so it will be latter deleted
387  m_triangles.push_back( layerTriangles );
388 
389  return new OPENGL_RENDER_LIST( *layerTriangles, m_circleTexture, layer_z_bot, layer_z_top );
390 }
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
Store the OpenGL display lists to related with a layer.

References getLayerZPos(), m_circleTexture, and m_triangles.

Referenced by reload().

◆ 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( wxT( "RENDER_3D_OPENGL::generateHoles: Object type 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( wxT( "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 747 of file opengl/create_scene.cpp.

748 {
749  if( !m_boardAdapter.GetBoard() )
750  return;
751 
752  const int platingThickness = m_boardAdapter.GetHolePlatingThickness();
753  const float platingThickness3d = platingThickness * m_boardAdapter.BiuTo3dUnits();
754 
755  if( m_boardAdapter.GetViaCount() > 0 )
756  {
757  const unsigned int reserve_nr_triangles_estimation =
761 
762  TRIANGLE_DISPLAY_LIST* layerTriangleVIA =
763  new TRIANGLE_DISPLAY_LIST( reserve_nr_triangles_estimation );
764 
765  // Insert plated vertical holes inside the board
766 
767  // Insert vias holes (vertical cylinders)
768  for( const PCB_TRACK* track : m_boardAdapter.GetBoard()->Tracks() )
769  {
770  if( track->Type() == PCB_VIA_T )
771  {
772  const PCB_VIA* via = static_cast<const PCB_VIA*>( track );
773 
774  const float holediameter = via->GetDrillValue() * m_boardAdapter.BiuTo3dUnits();
775  const int nrSegments = m_boardAdapter.GetCircleSegmentCount( via->GetDrillValue() );
776  const float hole_inner_radius = holediameter / 2.0f;
777 
778  const SFVEC2F via_center( via->GetStart().x * m_boardAdapter.BiuTo3dUnits(),
779  -via->GetStart().y * m_boardAdapter.BiuTo3dUnits() );
780 
781  PCB_LAYER_ID top_layer, bottom_layer;
782  via->LayerPair( &top_layer, &bottom_layer );
783 
784  float ztop, zbot, dummy;
785 
786  getLayerZPos( top_layer, ztop, dummy );
787  getLayerZPos( bottom_layer, dummy, zbot );
788 
789  wxASSERT( zbot < ztop );
790 
791  generateCylinder( via_center, hole_inner_radius,
792  hole_inner_radius + platingThickness3d,
793  ztop, zbot, nrSegments, layerTriangleVIA );
794  }
795  }
796 
797  m_vias = new OPENGL_RENDER_LIST( *layerTriangleVIA, 0, 0.0f, 0.0f );
798 
799  delete layerTriangleVIA;
800  }
801 
802 
803  if( m_boardAdapter.GetHoleCount() > 0 )
804  {
805  SHAPE_POLY_SET tht_outer_holes_poly; // Stores the outer poly of the copper holes (the pad)
806  SHAPE_POLY_SET tht_inner_holes_poly; // Stores the inner poly of the copper holes (the hole)
807 
808  tht_outer_holes_poly.RemoveAllContours();
809  tht_inner_holes_poly.RemoveAllContours();
810 
811  // Insert pads holes (vertical cylinders)
812  for( const FOOTPRINT* footprint : m_boardAdapter.GetBoard()->Footprints() )
813  {
814  for( const PAD* pad : footprint->Pads() )
815  {
816  if( pad->GetAttribute() != PAD_ATTRIB::NPTH )
817  {
818  const wxSize drillsize = pad->GetDrillSize();
819  const bool hasHole = drillsize.x && drillsize.y;
820 
821  if( !hasHole )
822  continue;
823 
824  pad->TransformHoleWithClearanceToPolygon( tht_outer_holes_poly,
825  platingThickness,
826  ARC_HIGH_DEF, ERROR_INSIDE );
827  pad->TransformHoleWithClearanceToPolygon( tht_inner_holes_poly, 0,
828  ARC_HIGH_DEF, ERROR_INSIDE );
829  }
830  }
831  }
832 
833  // Subtract the holes
834  tht_outer_holes_poly.BooleanSubtract( tht_inner_holes_poly, SHAPE_POLY_SET::PM_FAST );
835 
838 
839  CONTAINER_2D holesContainer;
840 
841  ConvertPolygonToTriangles( tht_outer_holes_poly, holesContainer,
843  (const BOARD_ITEM &)*m_boardAdapter.GetBoard() );
844 
845  const LIST_OBJECT2D& listHolesObject2d = holesContainer.GetList();
846 
847  if( listHolesObject2d.size() > 0 )
848  {
849  float layer_z_top, layer_z_bot, dummy;
850 
851  getLayerZPos( F_Cu, layer_z_top, dummy );
852  getLayerZPos( B_Cu, dummy, layer_z_bot );
853 
854  TRIANGLE_DISPLAY_LIST* layerTriangles =
855  new TRIANGLE_DISPLAY_LIST( listHolesObject2d.size() );
856 
857  // Convert the list of objects(triangles) to triangle layer structure
858  for( const OBJECT_2D* itemOnLayer : listHolesObject2d )
859  {
860  const OBJECT_2D* object2d_A = itemOnLayer;
861 
862  wxASSERT( object2d_A->GetObjectType() == OBJECT_2D_TYPE::TRIANGLE );
863 
864  const TRIANGLE_2D* tri = static_cast<const TRIANGLE_2D*>( object2d_A );
865 
866  const SFVEC2F& v1 = tri->GetP1();
867  const SFVEC2F& v2 = tri->GetP2();
868  const SFVEC2F& v3 = tri->GetP3();
869 
870  addTopAndBottomTriangles( layerTriangles, v1, v2, v3, layer_z_top, layer_z_bot );
871  }
872 
873  wxASSERT( tht_outer_holes_poly.OutlineCount() > 0 );
874 
875  if( tht_outer_holes_poly.OutlineCount() > 0 )
876  {
877  layerTriangles->AddToMiddleContourns( tht_outer_holes_poly,
878  layer_z_bot, layer_z_top,
879  m_boardAdapter.BiuTo3dUnits(), false );
880 
881  m_padHoles = new OPENGL_RENDER_LIST( *layerTriangles, m_circleTexture,
882  layer_z_top, layer_z_top );
883  }
884 
885  delete layerTriangles;
886  }
887  }
888 }
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 699 of file opengl/create_scene.cpp.

700 {
701  aOutZbot = m_boardAdapter.GetLayerBottomZPos( aLayerID );
702  aOutZtop = m_boardAdapter.GetLayerTopZPos( aLayerID );
703 
704  if( aOutZtop < aOutZbot )
705  {
706  float tmpFloat = aOutZbot;
707  aOutZbot = aOutZtop;
708  aOutZtop = tmpFloat;
709  }
710 }
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 generateEmptyLayerList(), 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 962 of file render_3d_opengl.cpp.

963 {
964  glEnable( GL_LINE_SMOOTH );
965  glShadeModel( GL_SMOOTH );
966 
967  // 4-byte pixel alignment
968  glPixelStorei( GL_UNPACK_ALIGNMENT, 4 );
969 
970  // Initialize the open GL texture to draw the filled semi-circle of the segments
972 
973  if( !circleImage )
974  return false;
975 
976  unsigned int circleRadius = ( SIZE_OF_CIRCLE_TEXTURE / 2 ) - 4;
977 
978  circleImage->CircleFilled( ( SIZE_OF_CIRCLE_TEXTURE / 2 ) - 0,
979  ( SIZE_OF_CIRCLE_TEXTURE / 2 ) - 0,
980  circleRadius,
981  0xFF );
982 
983  IMAGE* circleImageBlured = new IMAGE( circleImage->GetWidth(), circleImage->GetHeight() );
984 
985  circleImageBlured->EfxFilter_SkipCenter( circleImage, IMAGE_FILTER::GAUSSIAN_BLUR, circleRadius - 8 );
986 
987  m_circleTexture = OglLoadTexture( *circleImageBlured );
988 
989  delete circleImageBlured;
990  circleImageBlured = nullptr;
991 
992  delete circleImage;
993  circleImage = nullptr;
994 
995  init_lights();
996 
997  // Use this mode if you want see the triangle lines (debug proposes)
998  //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
1000 
1001  return true;
1002 }
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 909 of file opengl/create_scene.cpp.

910 {
911  if( !m_boardAdapter.GetBoard() )
912  return;
913 
917  {
918  return;
919  }
920 
921  // Go for all footprints
922  for( const FOOTPRINT* footprint : m_boardAdapter.GetBoard()->Footprints() )
923  {
924  for( const FP_3DMODEL& model : footprint->Models() )
925  {
926  if( model.m_Show && !model.m_Filename.empty() )
927  {
928  if( aStatusReporter )
929  {
930  // Display the short filename of the 3D model loaded:
931  // (the full name is usually too long to be displayed)
932  wxFileName fn( model.m_Filename );
933  aStatusReporter->Report( wxString::Format( _( "Loading %s..." ),
934  fn.GetFullName() ) );
935  }
936 
937  // Check if the model is not present in our cache map
938  // (Not already loaded in memory)
939  if( m_3dModelMap.find( model.m_Filename ) == m_3dModelMap.end() )
940  {
941  // It is not present, try get it from cache
942  const S3DMODEL* modelPtr =
943  m_boardAdapter.Get3dCacheManager()->GetModel( model.m_Filename );
944 
945  // only add it if the return is not NULL
946  if( modelPtr )
947  {
949  MODEL_3D* ogl_model = new MODEL_3D( *modelPtr, materialMode );
950 
951  if( ogl_model )
952  m_3dModelMap[ model.m_Filename ] = ogl_model;
953  }
954  }
955  }
956  }
957  }
958 }
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:646
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 891 of file opengl/create_scene.cpp.

892 {
893  if( m_3dModelMap.size() > 0 )
894  return;
895 
896  wxFrame* frame = dynamic_cast<EDA_3D_VIEWER_FRAME*>( m_canvas->GetParent() );
897 
898  if( frame )
899  {
900  STATUSBAR_REPORTER activityReporter( frame->GetStatusBar(),
902  load3dModels( &activityReporter );
903  }
904  else
905  load3dModels( nullptr );
906 }
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 plated pads
708  if( layer_id == F_Cu && m_platedPadsFront )
709  {
710  setPlatedCopperAndDepthOffset( layer_id );
712  drawMiddleSegments );
713  }
714  else if( layer_id == B_Cu && m_platedPadsBack )
715  {
716  setPlatedCopperAndDepthOffset( layer_id );
718  drawMiddleSegments );
719  }
720 
722  }
723  else
724  {
725  if( m_outerThroughHoles )
726  {
727  m_outerThroughHoles->ApplyScalePosition( pLayerDispList->GetZBot(),
728  pLayerDispList->GetZTop()
729  - pLayerDispList->GetZBot() );
730  }
731 
732  if( m_antiBoard )
733  {
734  m_antiBoard->ApplyScalePosition( pLayerDispList->GetZBot(),
735  pLayerDispList->GetZTop()
736  - pLayerDispList->GetZBot() );
737  }
738 
739  if( m_outerLayerHoles.find( layer_id ) != m_outerLayerHoles.end() )
740  {
741  const OPENGL_RENDER_LIST* viasHolesLayer = m_outerLayerHoles.at( layer_id );
742 
743  wxASSERT( viasHolesLayer != nullptr );
744 
745  if( viasHolesLayer != nullptr )
746  {
747  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
749  viasHolesLayer,
750  m_antiBoard );
751 
752  // Draw plated pads
753  if( layer_id == F_Cu && m_platedPadsFront )
754  {
755  setPlatedCopperAndDepthOffset( layer_id );
757  drawMiddleSegments,
759  viasHolesLayer,
760  m_antiBoard );
761  }
762  else if( layer_id == B_Cu && m_platedPadsBack )
763  {
764  setPlatedCopperAndDepthOffset( layer_id );
766  drawMiddleSegments,
768  viasHolesLayer,
769  m_antiBoard );
770  }
771 
773  }
774  }
775  else
776  {
777  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
779  m_antiBoard );
780 
781  if( layer_id == F_Cu && m_platedPadsFront )
782  {
783  setPlatedCopperAndDepthOffset( layer_id );
786  m_antiBoard );
787  }
788  else if( layer_id == B_Cu && m_platedPadsBack )
789  {
790  setPlatedCopperAndDepthOffset( layer_id );
793  m_antiBoard );
794  }
795 
797  }
798  }
799  }
800  else
801  {
802  setLayerMaterial( layer_id );
803 
804  OPENGL_RENDER_LIST* throughHolesOuter =
807  && ( layer_id == B_SilkS || layer_id == F_SilkS )
810 
811  if( throughHolesOuter )
812  {
813  throughHolesOuter->ApplyScalePosition(
814  pLayerDispList->GetZBot(),
815  pLayerDispList->GetZTop() - pLayerDispList->GetZBot() );
816  }
817 
818  OPENGL_RENDER_LIST* anti_board = m_antiBoard;
819 
820  if( anti_board )
821  {
822  anti_board->ApplyScalePosition(
823  pLayerDispList->GetZBot(),
824  pLayerDispList->GetZTop() - pLayerDispList->GetZBot() );
825  }
826 
827  if( !skipRenderHoles
830  && ( ( layer_id == B_SilkS && m_layers.find( B_Mask ) != m_layers.end() )
831  || ( layer_id == F_SilkS && m_layers.find( F_Mask ) != m_layers.end() ) ) )
832  {
833  const PCB_LAYER_ID layerMask_id = (layer_id == B_SilkS) ? B_Mask : F_Mask;
834 
835  const OPENGL_RENDER_LIST* pLayerDispListMask = m_layers.at( layerMask_id );
836 
837  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
838  pLayerDispListMask,
839  throughHolesOuter, anti_board );
840  }
841  else
842  {
843  if( !skipRenderHoles && throughHolesOuter
844  && ( layer_id == B_SilkS || layer_id == F_SilkS ) )
845  {
846  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments, nullptr,
847  throughHolesOuter,
848  anti_board );
849  }
850  else
851  {
852  // Do not render Paste layers when skipRenderHoles is enabled
853  // otherwise it will cause z-fight issues
854  if( !( skipRenderHoles && ( layer_id == B_Paste || layer_id == F_Paste ) ) )
855  {
856  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
857  anti_board );
858  }
859  }
860  }
861  }
862 
863  glPopMatrix();
864  }
865 
866  // Render 3D Models (Non-transparent)
867  render3dModels( false, false );
868  render3dModels( true, false );
869 
870  // Display board body
872  {
873  renderBoardBody( skipRenderHoles );
874  }
875 
876  // Display transparent mask layers
878  {
879  // add a depth buffer offset, it will help to hide some artifacts
880  // on silkscreen where the SolderMask is removed
881  glEnable( GL_POLYGON_OFFSET_FILL );
882  glPolygonOffset( 0.0f, -2.0f );
883 
884  if( m_camera.GetPos().z > 0 )
885  {
887  drawMiddleSegments, skipRenderHoles );
888 
890  drawMiddleSegments, skipRenderHoles );
891  }
892  else
893  {
895  drawMiddleSegments, skipRenderHoles );
896 
898  drawMiddleSegments, skipRenderHoles );
899  }
900 
901  glDisable( GL_POLYGON_OFFSET_FILL );
902  glPolygonOffset( 0.0f, 0.0f );
903  }
904 
905  // Render 3D Models (Transparent)
906  // !TODO: this can be optimized. If there are no transparent models (or no opacity),
907  // then there is no need to make this function call.
908  glDepthMask( GL_FALSE );
909  glEnable( GL_BLEND );
910  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
911 
912  // Enables Texture Env so it can combine model transparency with each footprint opacity
913  glEnable( GL_TEXTURE_2D );
914  glActiveTexture( GL_TEXTURE0 );
915 
916  glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE );
917  glTexEnvf( GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE );
918  glTexEnvf( GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE );
919 
920  glTexEnvi( GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PRIMARY_COLOR );
921  glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR );
922 
923  glTexEnvi( GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PREVIOUS );
924  glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR );
925 
926  glTexEnvi( GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PRIMARY_COLOR );
927  glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA );
928  glTexEnvi( GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_CONSTANT );
929  glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA );
930 
931  render3dModels( false, true );
932  render3dModels( true, true );
933 
934  glDisable( GL_BLEND );
936 
937  glDepthMask( GL_TRUE );
938 
939  // Render Grid
941  {
942  glDisable( GL_LIGHTING );
943 
944  if( glIsList( m_grid ) )
945  glCallList( m_grid );
946 
947  glEnable( GL_LIGHTING );
948  }
949 
950  // Render 3D arrows
952  render3dArrows();
953 
954  // Return back to the original viewport (this is important if we want
955  // to take a screenshot after the render)
956  glViewport( 0, 0, m_windowSize.x, m_windowSize.y );
957 
958  return false;
959 }
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 448 of file opengl/create_scene.cpp.

449 {
450  m_reloadRequested = false;
451 
452  freeAllLists();
453 
455 
456  unsigned stats_startReloadTime = GetRunningMicroSecs();
457 
458  m_boardAdapter.InitSettings( aStatusReporter, aWarningReporter );
459 
460  SFVEC3F camera_pos = m_boardAdapter.GetBoardCenter();
461  m_camera.SetBoardLookAtPos( camera_pos );
462 
463  if( aStatusReporter )
464  aStatusReporter->Report( _( "Load OpenGL: board" ) );
465 
466  // Create Board
468 
470  {
473  m_antiBoardPolys.Append( VECTOR2I( -INT_MAX/2, -INT_MAX/2 ) );
474  m_antiBoardPolys.Append( VECTOR2I( INT_MAX/2, -INT_MAX/2 ) );
475  m_antiBoardPolys.Append( VECTOR2I( INT_MAX/2, INT_MAX/2 ) );
476  m_antiBoardPolys.Append( VECTOR2I( -INT_MAX/2, INT_MAX/2 ) );
477  m_antiBoardPolys.Outline( 0 ).SetClosed( true );
478 
482  }
483 
484  SHAPE_POLY_SET board_poly_with_holes = m_boardAdapter.GetBoardPoly();
485  board_poly_with_holes.BooleanSubtract( m_boardAdapter.GetThroughHoleOdPolys(),
489 
490  m_boardWithHoles = createBoard( board_poly_with_holes );
491 
492  if( m_antiBoard )
494 
495  // Create Through Holes and vias
496  if( aStatusReporter )
497  aStatusReporter->Report( _( "Load OpenGL: holes and vias" ) );
498 
500 
504 
506  outerPolyTHT, 1.0f, 0.0f, false,
508 
511  m_boardAdapter.GetThroughHoleViaOdPolys(), 1.0f, 0.0f, false );
512 
515  {
518  m_boardAdapter.GetThroughHoleAnnularRingPolys(), 1.0f, 0.0f, false );
519  }
520 
521  const MAP_POLY& innerMapHoles = m_boardAdapter.GetHoleIdPolysMap();
522  const MAP_POLY& outerMapHoles = m_boardAdapter.GetHoleOdPolysMap();
523 
524  wxASSERT( innerMapHoles.size() == outerMapHoles.size() );
525 
527 
528  if( outerMapHoles.size() > 0 )
529  {
530  float layer_z_bot = 0.0f;
531  float layer_z_top = 0.0f;
532 
533  for( const auto ii : outerMapHoles )
534  {
535  const PCB_LAYER_ID layer_id = ii.first;
536  const SHAPE_POLY_SET* poly = ii.second;
537  const BVH_CONTAINER_2D* container = map_holes.at( layer_id );
538 
539  getLayerZPos( layer_id, layer_z_top, layer_z_bot );
540 
541  m_outerLayerHoles[layer_id] = generateHoles( container->GetList(), *poly,
542  layer_z_top, layer_z_bot, false );
543  }
544 
545  for( const auto ii : innerMapHoles )
546  {
547  const PCB_LAYER_ID layer_id = ii.first;
548  const SHAPE_POLY_SET* poly = ii.second;
549  const BVH_CONTAINER_2D* container = map_holes.at( layer_id );
550 
551  getLayerZPos( layer_id, layer_z_top, layer_z_bot );
552 
553  m_innerLayerHoles[layer_id] = generateHoles( container->GetList(), *poly,
554  layer_z_top, layer_z_bot, false );
555  }
556  }
557 
558  // Generate vertical cylinders of vias and pads (copper)
560 
561  // Add layers maps
562  if( aStatusReporter )
563  aStatusReporter->Report( _( "Load OpenGL: layers" ) );
564 
565  const MAP_POLY& map_poly = m_boardAdapter.GetPolyMap();
566 
567  for( const auto ii : m_boardAdapter.GetLayerMap() )
568  {
569  const PCB_LAYER_ID layer_id = ii.first;
570 
571  if( !m_boardAdapter.Is3dLayerEnabled( layer_id ) )
572  continue;
573 
574  if( aStatusReporter )
575  aStatusReporter->Report( wxString::Format(
576  _( "Load OpenGL layer %d" ), (int)layer_id ) );
577 
578  const BVH_CONTAINER_2D* container2d = ii.second;
579 
580  SHAPE_POLY_SET polyListSubtracted;
581  SHAPE_POLY_SET* polyList = nullptr;
582 
583  // Load the vertical (Z axis) component of shapes
584 
585  if( map_poly.find( layer_id ) != map_poly.end() )
586  {
587  polyListSubtracted = *map_poly.at( layer_id );;
588 
590  {
591  polyListSubtracted.BooleanIntersection( m_boardAdapter.GetBoardPoly(),
593 
594  if( ( layer_id != B_Mask ) && ( layer_id != F_Mask ) )
595  {
600  }
601 
603  {
604  if( layer_id == B_SilkS && map_poly.find( B_Mask ) != map_poly.end() )
605  {
606  polyListSubtracted.BooleanSubtract( *map_poly.at( B_Mask ),
608  }
609  else if( layer_id == F_SilkS && map_poly.find( F_Mask ) != map_poly.end() )
610  {
611  polyListSubtracted.BooleanSubtract( *map_poly.at( F_Mask ),
613  }
614  }
615  }
616 
617  polyList = &polyListSubtracted;
618  }
619 
620  OPENGL_RENDER_LIST* oglList = generateLayerList( container2d, polyList, layer_id,
622 
623  if( oglList != nullptr )
624  m_layers[layer_id] = oglList;
625 
626  }
627 
630  {
632  {
640 
642  &polySubtracted, F_Cu );
643 
644  // An entry for F_Cu must exist in m_layers or we'll never look at m_platedPadsFront
645  if( m_layers.count( F_Cu ) == 0 )
647  }
648 
650  {
658 
660  &polySubtracted, B_Cu );
661 
662  // An entry for B_Cu must exist in m_layers or we'll never look at m_platedPadsBack
663  if( m_layers.count( B_Cu ) == 0 )
665  }
666  }
667 
668  // Load 3D models
669  if( aStatusReporter )
670  aStatusReporter->Report( _( "Loading 3D models..." ) );
671 
672  load3dModels( aStatusReporter );
673 
674  if( aStatusReporter )
675  {
676  // Calculation time in seconds
677  const double calculation_time = (double)( GetRunningMicroSecs() -
678  stats_startReloadTime) / 1e6;
679 
680  aStatusReporter->Report( wxString::Format( _( "Reload time %.3f s" ), calculation_time ) );
681  }
682 }
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
OPENGL_RENDER_LIST * generateEmptyLayerList(PCB_LAYER_ID aLayerId)
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(), generateEmptyLayerList(), 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 1203 of file render_3d_opengl.cpp.

1204 {
1206  render3dModelsSelected( aRenderTopOrBot, aRenderTransparentOnly, true );
1207 
1208  render3dModelsSelected( aRenderTopOrBot, aRenderTransparentOnly, false );
1209 }
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 1164 of file render_3d_opengl.cpp.

1166 {
1167  if( !m_boardAdapter.GetBoard() )
1168  return;
1169 
1170  MODEL_3D::BeginDrawMulti( !aRenderSelectedOnly );
1171 
1172  // Go for all footprints
1173  for( FOOTPRINT* fp : m_boardAdapter.GetBoard()->Footprints() )
1174  {
1175  bool highlight = false;
1176 
1178  {
1179  if( fp->IsSelected() )
1180  highlight = true;
1181 
1183  highlight = true;
1184 
1185  if( aRenderSelectedOnly != highlight )
1186  continue;
1187  }
1188 
1189  if( !fp->Models().empty() )
1190  {
1191  if( m_boardAdapter.IsFootprintShown( (FOOTPRINT_ATTR_T) fp->GetAttributes() ) )
1192  {
1193  if( aRenderTopOrBot == !fp->IsFlipped() )
1194  renderFootprint( fp, aRenderTransparentOnly, highlight );
1195  }
1196  }
1197  }
1198 
1200 }
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 1212 of file render_3d_opengl.cpp.

1214 {
1215  if( !aFootprint->Models().empty() )
1216  {
1217  const double zpos = m_boardAdapter.GetFootprintZPos( aFootprint->IsFlipped() );
1218 
1219  glPushMatrix();
1220 
1221  wxPoint pos = aFootprint->GetPosition();
1222 
1223  glTranslatef( pos.x * m_boardAdapter.BiuTo3dUnits(), -pos.y * m_boardAdapter.BiuTo3dUnits(),
1224  zpos );
1225 
1226  if( aFootprint->GetOrientation() )
1227  glRotated( (double) aFootprint->GetOrientation() / 10.0, 0.0, 0.0, 1.0 );
1228 
1229  if( aFootprint->IsFlipped() )
1230  {
1231  glRotatef( 180.0f, 0.0f, 1.0f, 0.0f );
1232  glRotatef( 180.0f, 0.0f, 0.0f, 1.0f );
1233  }
1234 
1235  double modelunit_to_3d_units_factor = m_boardAdapter.BiuTo3dUnits() * UNITS3D_TO_UNITSPCB;
1236 
1237  glScaled( modelunit_to_3d_units_factor, modelunit_to_3d_units_factor,
1238  modelunit_to_3d_units_factor );
1239 
1240  // Get the list of model files for this model
1241  for( const FP_3DMODEL& sM : aFootprint->Models() )
1242  {
1243  if( !sM.m_Show || sM.m_Filename.empty() )
1244  continue;
1245 
1246  // Check if the model is present in our cache map
1247  auto cache_i = m_3dModelMap.find( sM.m_Filename );
1248 
1249  if( cache_i == m_3dModelMap.end() )
1250  continue;
1251 
1252  if( const MODEL_3D* modelPtr = cache_i->second )
1253  {
1254  bool opaque = sM.m_Opacity >= 1.0;
1255 
1256  if( ( !aRenderTransparentOnly && modelPtr->HasOpaqueMeshes() && opaque ) ||
1257  ( aRenderTransparentOnly && ( modelPtr->HasTransparentMeshes() || !opaque ) ) )
1258  {
1259  glPushMatrix();
1260 
1261  // FIXME: don't do this over and over again unless the
1262  // values have changed. cache the matrix somewhere.
1263  glm::mat4 mtx( 1 );
1264  mtx = glm::translate( mtx, { sM.m_Offset.x, sM.m_Offset.y, sM.m_Offset.z } );
1265  mtx = glm::rotate( mtx, glm::radians( (float) -sM.m_Rotation.z ),
1266  { 0.0f, 0.0f, 1.0f } );
1267  mtx = glm::rotate( mtx, glm::radians( (float) -sM.m_Rotation.y ),
1268  { 0.0f, 1.0f, 0.0f } );
1269  mtx = glm::rotate( mtx, glm::radians( (float) -sM.m_Rotation.x ),
1270  { 1.0f, 0.0f, 0.0f } );
1271  mtx = glm::scale( mtx, { sM.m_Scale.x, sM.m_Scale.y, sM.m_Scale.z } );
1272  glMultMatrixf( glm::value_ptr( mtx ) );
1273 
1274  if( aRenderTransparentOnly )
1275  {
1276  modelPtr->DrawTransparent( sM.m_Opacity,
1277  aFootprint->IsSelected() || aIsSelected,
1279  }
1280  else
1281  {
1282  modelPtr->DrawOpaque( aFootprint->IsSelected() || aIsSelected,
1284  }
1285 
1287  {
1288  glEnable( GL_BLEND );
1289  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
1290 
1291  glDisable( GL_LIGHTING );
1292 
1293  glLineWidth( 1 );
1294  modelPtr->DrawBboxes();
1295 
1296  glLineWidth( 4 );
1297  modelPtr->DrawBbox();
1298 
1299  glEnable( GL_LIGHTING );
1300  glDisable( GL_BLEND );
1301  }
1302 
1303  glPopMatrix();
1304  }
1305  }
1306  }
1307 
1308  glPopMatrix();
1309  }
1310 }
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:281
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 1106 of file render_3d_opengl.cpp.

1108 {
1109  wxASSERT( (aLayerID == B_Mask) || (aLayerID == F_Mask) );
1110 
1111  float nonCopperThickness = m_boardAdapter.GetNonCopperLayerThickness();
1112 
1113  if( m_board )
1114  {
1115  if( m_layers.find( aLayerID ) != m_layers.end() )
1116  {
1117  OPENGL_RENDER_LIST* pLayerDispListMask = m_layers.at( aLayerID );
1118 
1120  m_outerViaThroughHoles->ApplyScalePosition( aZPosition, nonCopperThickness );
1121 
1122  m_board->ApplyScalePosition( aZPosition, nonCopperThickness );
1123 
1124  setLayerMaterial( aLayerID );
1125 
1126  m_board->SetItIsTransparent( true );
1127 
1128  if( aSkipRenderHoles )
1129  {
1130  m_board->DrawAllCameraCulled( m_camera.GetPos().z, aDrawMiddleSegments );
1131  }
1132  else
1133  {
1134  m_board->DrawAllCameraCulledSubtractLayer( aDrawMiddleSegments, pLayerDispListMask,
1136  }
1137  }
1138  else
1139  {
1140  // This case there is no layer with mask, so we will render the full board as mask
1142  m_outerViaThroughHoles->ApplyScalePosition( aZPosition, nonCopperThickness );
1143 
1144  m_board->ApplyScalePosition( aZPosition, nonCopperThickness );
1145 
1146  setLayerMaterial( aLayerID );
1147 
1148  m_board->SetItIsTransparent( true );
1149 
1150  if( aSkipRenderHoles )
1151  {
1152  m_board->DrawAllCameraCulled( m_camera.GetPos().z, aDrawMiddleSegments );
1153  }
1154  else
1155  {
1156  m_board->DrawAllCameraCulledSubtractLayer( aDrawMiddleSegments,
1158  }
1159  }
1160  }
1161 }
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 1005 of file render_3d_opengl.cpp.

1006 {
1007  glEnable( GL_COLOR_MATERIAL );
1008  glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
1009 
1010  const SFVEC4F ambient = SFVEC4F( 0.0f, 0.0f, 0.0f, 1.0f );
1011  const SFVEC4F diffuse = SFVEC4F( 0.0f, 0.0f, 0.0f, 1.0f );
1012  const SFVEC4F emissive = SFVEC4F( 0.0f, 0.0f, 0.0f, 1.0f );
1013  const SFVEC4F specular = SFVEC4F( 0.1f, 0.1f, 0.1f, 1.0f );
1014 
1015  glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.r );
1016  glMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, 96.0f );
1017 
1018  glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, &ambient.r );
1019  glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, &diffuse.r );
1020  glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, &emissive.r );
1021 }
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 199 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 217 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 198 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 187 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 185 of file render_3d_opengl.h.

◆ m_GrayMaterial

SMATERIAL RENDER_3D_OPENGL::m_GrayMaterial

Definition at line 189 of file render_3d_opengl.h.

◆ m_grid

GLuint RENDER_3D_OPENGL::m_grid
private

oGL list that stores current grid

Definition at line 207 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 196 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 208 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 186 of file render_3d_opengl.h.

◆ m_outerLayerHoles

MAP_OGL_DISP_LISTS RENDER_3D_OPENGL::m_outerLayerHoles
private

Definition at line 195 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 202 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 200 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 201 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 211 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 181 of file render_3d_opengl.h.

◆ m_Plastic

SMATERIAL RENDER_3D_OPENGL::m_Plastic

Definition at line 188 of file render_3d_opengl.h.

◆ m_platedPadsBack

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_platedPadsBack
private

Definition at line 194 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 193 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 182 of file render_3d_opengl.h.

◆ m_SilkSTop

SMATERIAL RENDER_3D_OPENGL::m_SilkSTop

Definition at line 183 of file render_3d_opengl.h.

◆ m_SolderMask

SMATERIAL RENDER_3D_OPENGL::m_SolderMask

Definition at line 184 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 204 of file render_3d_opengl.h.

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

◆ m_vias

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_vias
private

Definition at line 210 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: