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

#include <render_3d_opengl.h>

Inheritance diagram for RENDER_3D_OPENGL:

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_INDICATOR >	CreateBusyIndicator () const
	Return a created busy indicator, if a factory has been set, else a null pointer. More...

Protected Attributes
EDA_3D_CANVAS *	m_canvas
	Settings reference in use for this render. More...

BOARD_ADAPTER &	m_boardAdapter

CAMERA &	m_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_LIST *	generateHoles (const LIST_OBJECT2D &aListHolesObject2d, const SHAPE_POLY_SET &aPoly, float aZtop, float aZbot, bool aInvertFaces, const BVH_CONTAINER_2D *aThroughHoles=nullptr)

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

void	addTopAndBottomTriangles (TRIANGLE_DISPLAY_LIST *aDst, const SFVEC2F &v0, const SFVEC2F &v1, const SFVEC2F &v2, float top, float bot)

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

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

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

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

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

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

void	renderBoardBody (bool aSkipRenderHoles)

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

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

void	generateCylinder (const SFVEC2F &aCenter, float aInnerRadius, float aOuterRadius, float aZtop, float aZbot, unsigned int aNr_sides_per_circle, TRIANGLE_DISPLAY_LIST *aDstLayer)

void	generateViasAndPads ()

void	load3dModels (REPORTER *aStatusReporter)
	Load footprint models from the cache and load it to openGL lists in the form of MODEL_3D objects. More...

void	render3dModels (bool aRenderTopOrBot, bool aRenderTransparentOnly)

void	render3dModelsSelected (bool aRenderTopOrBot, bool aRenderTransparentOnly, bool aRenderSelectedOnly)

void	renderFootprint (const FOOTPRINT *aFootprint, bool aRenderTransparentOnly, bool aIsSelected)

void	setLightFront (bool enabled)

void	setLightTop (bool enabled)

void	setLightBottom (bool enabled)

void	render3dArrows ()

void	generate3dGrid (GRID3D_TYPE aGridType)
	Create a 3D grid to an OpenGL display list. More...

void	setupMaterials ()

void	setCopperMaterial ()

void	setPlatedCopperAndDepthOffset (PCB_LAYER_ID aLayer_id)

void	unsetDepthOffset ()

void	setLayerMaterial (PCB_LAYER_ID aLayerID)

SFVEC4F	getLayerColor (PCB_LAYER_ID aLayerID)

bool	initializeOpenGL ()

OPENGL_RENDER_LIST *	createBoard (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_LIST *	m_platedPadsFront

OPENGL_RENDER_LIST *	m_platedPadsBack

MAP_OGL_DISP_LISTS	m_outerLayerHoles

MAP_OGL_DISP_LISTS	m_innerLayerHoles

OPENGL_RENDER_LIST *	m_board

OPENGL_RENDER_LIST *	m_boardWithHoles

OPENGL_RENDER_LIST *	m_antiBoard

OPENGL_RENDER_LIST *	m_outerThroughHoles

OPENGL_RENDER_LIST *	m_outerViaThroughHoles

OPENGL_RENDER_LIST *	m_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_LIST *	m_vias

OPENGL_RENDER_LIST *	m_padHoles

MAP_3DMODEL	m_3dModelMap

BOARD_ITEM *	m_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.

  :
  RENDER_3D_BASE( aCanvas, aAdapter, aCamera )
 {
  wxLogTrace( m_logTrace, wxT( "RENDER_3D_OPENGL::RENDER_3D_OPENGL" ) );
 
  m_layers.clear();
  m_outerLayerHoles.clear();
  m_innerLayerHoles.clear();
  m_triangles.clear();
  m_board = nullptr;
  m_antiBoard = nullptr;
 
  m_platedPadsFront = nullptr;
  m_platedPadsBack = nullptr;
 
  m_outerThroughHoles = nullptr;
  m_outerThroughHoleRings = nullptr;
  m_outerViaThroughHoles = nullptr;
  m_vias = nullptr;
  m_padHoles = nullptr;
 
  m_circleTexture = 0;
  m_grid = 0;
  m_lastGridType = GRID3D_TYPE::NONE;
  m_currentRollOverItem = nullptr;
  m_boardWithHoles = nullptr;
 
  m_3dModelMap.clear();
 }

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.

 {
  wxLogTrace( m_logTrace, wxT( "RENDER_3D_OPENGL::RENDER_3D_OPENGL" ) );
 
  freeAllLists();
 
  glDeleteTextures( 1, &m_circleTexture );
 }

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.

 {
  const SFVEC2F& center = aRing->GetCenter();
  const float inner = aRing->GetInnerRadius();
  const float outer = aRing->GetOuterRadius();
 
  std::vector< SFVEC2F > innerContour;
  std::vector< SFVEC2F > outerContour;
 
  generateRing( center, inner, outer, m_boardAdapter.GetCircleSegmentCount( outer * 2.0f ),
  innerContour, outerContour, false );
 
  // This will add the top and bot quads that will form the approximated ring
  for( unsigned int i = 0; i < ( innerContour.size() - 1 ); ++i )
  {
  const SFVEC2F& vi0 = innerContour[i + 0];
  const SFVEC2F& vi1 = innerContour[i + 1];
  const SFVEC2F& vo0 = outerContour[i + 0];
  const SFVEC2F& vo1 = outerContour[i + 1];
 
  aDstLayer->m_layer_top_triangles->AddQuad( SFVEC3F( vi1.x, vi1.y, aZtop ),
  SFVEC3F( vi0.x, vi0.y, aZtop ),
  SFVEC3F( vo0.x, vo0.y, aZtop ),
  SFVEC3F( vo1.x, vo1.y, aZtop ) );
 
  aDstLayer->m_layer_bot_triangles->AddQuad( SFVEC3F( vi1.x, vi1.y, aZbot ),
  SFVEC3F( vo1.x, vo1.y, aZbot ),
  SFVEC3F( vo0.x, vo0.y, aZbot ),
  SFVEC3F( vi0.x, vi0.y, aZbot ) );
  }
 }

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.

 {
  const SFVEC2F& v0 = aPoly->GetV0();
  const SFVEC2F& v1 = aPoly->GetV1();
  const SFVEC2F& v2 = aPoly->GetV2();
  const SFVEC2F& v3 = aPoly->GetV3();
 
  addTopAndBottomTriangles( aDstLayer, v0, v2, v1, aZtop, aZbot );
  addTopAndBottomTriangles( aDstLayer, v2, v0, v3, aZtop, aZbot );
 }

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.

 {
  const SFVEC2F& center = aFilledCircle->GetCenter();
  const float radius = aFilledCircle->GetRadius() * 2.0f; // Double because the render triangle
 
  // This is a small adjustment to the circle texture
  const float texture_factor = ( 8.0f / (float) SIZE_OF_CIRCLE_TEXTURE ) + 1.0f;
  const float f = ( sqrtf( 2.0f ) / 2.0f ) * radius * texture_factor;
 
  // Top and Bot segments ends are just triangle semi-circles, so need to add it in duplicated.
  aDstLayer->m_layer_top_segment_ends->AddTriangle( SFVEC3F( center.x + f, center.y, aZtop ),
  SFVEC3F( center.x - f, center.y, aZtop ),
  SFVEC3F( center.x, center.y - f, aZtop ) );
 
  aDstLayer->m_layer_top_segment_ends->AddTriangle( SFVEC3F( center.x - f, center.y, aZtop ),
  SFVEC3F( center.x + f, center.y, aZtop ),
  SFVEC3F( center.x, center.y + f, aZtop ) );
 
  aDstLayer->m_layer_bot_segment_ends->AddTriangle( SFVEC3F( center.x - f, center.y, aZbot ),
  SFVEC3F( center.x + f, center.y, aZbot ),
  SFVEC3F( center.x, center.y - f, aZbot ) );
 
  aDstLayer->m_layer_bot_segment_ends->AddTriangle( SFVEC3F( center.x + f, center.y, aZbot ),
  SFVEC3F( center.x - f, center.y, aZbot ),
  SFVEC3F( center.x, center.y + f, aZbot ) );
 }

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.

 {
  const SFVEC2F& v1 = aTri->GetP1();
  const SFVEC2F& v2 = aTri->GetP2();
  const SFVEC2F& v3 = aTri->GetP3();
 
  addTopAndBottomTriangles( aDstLayer, v1, v2, v3, aZtop, aZbot );
 }

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.

 {
  const SFVEC2F& leftStart = aSeg->GetLeftStar();
  const SFVEC2F& leftEnd = aSeg->GetLeftEnd();
  const SFVEC2F& leftDir = aSeg->GetLeftDir();
 
  const SFVEC2F& rightStart = aSeg->GetRightStar();
  const SFVEC2F& rightEnd = aSeg->GetRightEnd();
  const SFVEC2F& rightDir = aSeg->GetRightDir();
  const float radius = aSeg->GetRadius();
 
  const SFVEC2F& start = aSeg->GetStart();
  const SFVEC2F& end = aSeg->GetEnd();
 
  const float texture_factor = ( 12.0f / (float) SIZE_OF_CIRCLE_TEXTURE ) + 1.0f;
  const float texture_factorF = ( 6.0f / (float) SIZE_OF_CIRCLE_TEXTURE ) + 1.0f;
 
  const float radius_of_the_square = sqrtf( aSeg->GetRadiusSquared() * 2.0f );
  const float radius_triangle_factor = ( radius_of_the_square - radius ) / radius;
 
  const SFVEC2F factorS = SFVEC2F( -rightDir.y * radius * radius_triangle_factor,
  rightDir.x * radius * radius_triangle_factor );
 
  const SFVEC2F factorE = SFVEC2F( -leftDir.y * radius * radius_triangle_factor,
  leftDir.x * radius * radius_triangle_factor );
 
  // Top end segment triangles (semi-circles)
  aDstLayer->m_layer_top_segment_ends->AddTriangle(
  SFVEC3F( rightEnd.x + texture_factor * factorS.x,
  rightEnd.y + texture_factor * factorS.y,
  aZtop ),
  SFVEC3F( leftStart.x + texture_factor * factorE.x,
  leftStart.y + texture_factor * factorE.y,
  aZtop ),
  SFVEC3F( start.x - texture_factorF * leftDir.x * radius * sqrtf( 2.0f ),
  start.y - texture_factorF * leftDir.y * radius * sqrtf( 2.0f ),
  aZtop ) );
 
  aDstLayer->m_layer_top_segment_ends->AddTriangle(
   SFVEC3F( leftEnd.x + texture_factor * factorE.x,
  leftEnd.y + texture_factor * factorE.y, aZtop ),
  SFVEC3F( rightStart.x + texture_factor * factorS.x,
  rightStart.y + texture_factor * factorS.y, aZtop ),
  SFVEC3F( end.x - texture_factorF * rightDir.x * radius * sqrtf( 2.0f ),
  end.y - texture_factorF * rightDir.y * radius * sqrtf( 2.0f ),
  aZtop ) );
 
  // Bot end segment triangles (semi-circles)
  aDstLayer->m_layer_bot_segment_ends->AddTriangle(
  SFVEC3F( leftStart.x + texture_factor * factorE.x,
  leftStart.y + texture_factor * factorE.y,
  aZbot ),
  SFVEC3F( rightEnd.x + texture_factor * factorS.x,
  rightEnd.y + texture_factor * factorS.y,
  aZbot ),
  SFVEC3F( start.x - texture_factorF * leftDir.x * radius * sqrtf( 2.0f ),
  start.y - texture_factorF * leftDir.y * radius * sqrtf( 2.0f ),
  aZbot ) );
 
  aDstLayer->m_layer_bot_segment_ends->AddTriangle(
  SFVEC3F( rightStart.x + texture_factor * factorS.x,
  rightStart.y + texture_factor * factorS.y, aZbot ),
  SFVEC3F( leftEnd.x + texture_factor * factorE.x,
  leftEnd.y + texture_factor * factorE.y, aZbot ),
  SFVEC3F( end.x - texture_factorF * rightDir.x * radius * sqrtf( 2.0f ),
  end.y - texture_factorF * rightDir.y * radius * sqrtf( 2.0f ),
  aZbot ) );
 
  // Segment top and bot planes
  aDstLayer->m_layer_top_triangles->AddQuad(
  SFVEC3F( rightEnd.x, rightEnd.y, aZtop ),
  SFVEC3F( rightStart.x, rightStart.y, aZtop ),
  SFVEC3F( leftEnd.x, leftEnd.y, aZtop ),
  SFVEC3F( leftStart.x, leftStart.y, aZtop ) );
 
  aDstLayer->m_layer_bot_triangles->AddQuad(
  SFVEC3F( rightEnd.x, rightEnd.y, aZbot ),
  SFVEC3F( leftStart.x, leftStart.y, aZbot ),
  SFVEC3F( leftEnd.x, leftEnd.y, aZbot ),
  SFVEC3F( rightStart.x, rightStart.y, aZbot ) );
 }

◆ addTopAndBottomTriangles()

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

private

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

 {
  aDst->m_layer_bot_triangles->AddTriangle( SFVEC3F( v0.x, v0.y, bot ),
  SFVEC3F( v1.x, v1.y, bot ),
  SFVEC3F( v2.x, v2.y, bot ) );
 
  aDst->m_layer_top_triangles->AddTriangle( SFVEC3F( v2.x, v2.y, top ),
  SFVEC3F( v1.x, v1.y, top ),
  SFVEC3F( v0.x, v0.y, top ) );
 }

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

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

◆ createBoard()

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

private

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

 {
  OPENGL_RENDER_LIST* dispLists = nullptr;
  CONTAINER_2D boardContainer;
  SHAPE_POLY_SET brd_outlines = aBoardPoly;
 
  ConvertPolygonToTriangles( brd_outlines, boardContainer, m_boardAdapter.BiuTo3dUnits(),
  (const BOARD_ITEM &)*m_boardAdapter.GetBoard() );
 
  const LIST_OBJECT2D& listBoardObject2d = boardContainer.GetList();
 
  if( listBoardObject2d.size() > 0 )
  {
  // We will set a unitary Z so it will in future used with transformations
  // since the board poly will be used not only to draw itself but also the
  // solder mask layers.
  const float layer_z_top = 1.0f;
  const float layer_z_bot = 0.0f;
 
  TRIANGLE_DISPLAY_LIST* layerTriangles =
  new TRIANGLE_DISPLAY_LIST( listBoardObject2d.size() );
 
  // Convert the list of objects(triangles) to triangle layer structure
  for( const OBJECT_2D* itemOnLayer : listBoardObject2d )
  {
  const OBJECT_2D* object2d_A = itemOnLayer;
 
  wxASSERT( object2d_A->GetObjectType() == OBJECT_2D_TYPE::TRIANGLE );
 
  const TRIANGLE_2D* tri = static_cast<const TRIANGLE_2D*>( object2d_A );
 
  const SFVEC2F& v1 = tri->GetP1();
  const SFVEC2F& v2 = tri->GetP2();
  const SFVEC2F& v3 = tri->GetP3();
 
  addTopAndBottomTriangles( layerTriangles, v1, v2, v3, layer_z_top, layer_z_bot );
  }
 
  if( aBoardPoly.OutlineCount() > 0 )
  {
  layerTriangles->AddToMiddleContourns( aBoardPoly, layer_z_bot, layer_z_top,
  m_boardAdapter.BiuTo3dUnits(), false,
  aThroughHoles );
 
  dispLists = new OPENGL_RENDER_LIST( *layerTriangles, m_circleTexture,
  layer_z_top, layer_z_top );
  }
 
  delete layerTriangles;
  }
 
  return dispLists;
 }

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.

 {
  std::unique_ptr<BUSY_INDICATOR> busy;
 
  if( m_busyIndicatorFactory )
  busy = m_busyIndicatorFactory();
 
  return busy;
 }

References RENDER_3D_BASE::m_busyIndicatorFactory.

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

◆ freeAllLists()

void RENDER_3D_OPENGL::freeAllLists ( )

private

Definition at line 1036 of file render_3d_opengl.cpp.

 {
  if( glIsList( m_grid ) )
  glDeleteLists( m_grid, 1 );
 
  m_grid = 0;
 
  for( MAP_OGL_DISP_LISTS::const_iterator ii = m_layers.begin(); ii != m_layers.end(); ++ii )
  {
  OPENGL_RENDER_LIST* pLayerDispList = static_cast<OPENGL_RENDER_LIST*>( ii->second );
  delete pLayerDispList;
  }
 
  m_layers.clear();
 
  delete m_platedPadsFront;
  m_platedPadsFront = nullptr;
 
  delete m_platedPadsBack;
  m_platedPadsBack = nullptr;
 
  for( MAP_OGL_DISP_LISTS::const_iterator ii = m_outerLayerHoles.begin();
  ii != m_outerLayerHoles.end();
  ++ii )
  {
  OPENGL_RENDER_LIST* pLayerDispList = static_cast<OPENGL_RENDER_LIST*>( ii->second );
  delete pLayerDispList;
  }
 
  m_outerLayerHoles.clear();
 
  for( MAP_OGL_DISP_LISTS::const_iterator ii = m_innerLayerHoles.begin();
  ii != m_innerLayerHoles.end();
  ++ii )
  {
  OPENGL_RENDER_LIST* pLayerDispList = static_cast<OPENGL_RENDER_LIST*>( ii->second );
  delete pLayerDispList;
  }
 
  m_innerLayerHoles.clear();
 
  for( LIST_TRIANGLES::const_iterator ii = m_triangles.begin(); ii != m_triangles.end(); ++ii )
  {
  delete *ii;
  }
 
  m_triangles.clear();
 
  for( MAP_3DMODEL::const_iterator ii = m_3dModelMap.begin(); ii != m_3dModelMap.end(); ++ii )
  {
  MODEL_3D* pointer = static_cast<MODEL_3D*>(ii->second);
  delete pointer;
  }
 
  m_3dModelMap.clear();
 
  delete m_board;
  m_board = nullptr;
 
  delete m_boardWithHoles;
  m_boardWithHoles = nullptr;
 
  delete m_antiBoard;
  m_antiBoard = nullptr;
 
  delete m_outerThroughHoles;
  m_outerThroughHoles = nullptr;
 
  delete m_outerViaThroughHoles;
  m_outerViaThroughHoles = nullptr;
 
  delete m_outerThroughHoleRings;
  m_outerThroughHoleRings = nullptr;
 
  delete m_vias;
  m_vias = nullptr;
 
  delete m_padHoles;
  m_padHoles = nullptr;
 }

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

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

◆ generate3dGrid()

void RENDER_3D_OPENGL::generate3dGrid ( GRID3D_TYPE aGridType )

private

Create a 3D grid to an OpenGL display list.

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

Definition at line 1325 of file render_3d_opengl.cpp.

 {
  if( glIsList( m_grid ) )
  glDeleteLists( m_grid, 1 );
 
  m_grid = 0;
 
  if( aGridType == GRID3D_TYPE::NONE )
  return;
 
  m_grid = glGenLists( 1 );
 
  if( !glIsList( m_grid ) )
  return;
 
  glNewList( m_grid, GL_COMPILE );
 
  glEnable( GL_BLEND );
  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 
  const double zpos = 0.0;
 
  // Color of grid lines
  const SFVEC3F gridColor = m_boardAdapter.GetColor( DARKGRAY );
 
  // Color of grid lines every 5 lines
  const SFVEC3F gridColor_marker = m_boardAdapter.GetColor( LIGHTBLUE );
  const double scale = m_boardAdapter.BiuTo3dUnits();
  const GLfloat transparency = 0.35f;
 
  double griSizeMM = 0.0;
 
  switch( aGridType )
  {
  default:
  case GRID3D_TYPE::NONE:
  return;
  case GRID3D_TYPE::GRID_1MM:
  griSizeMM = 1.0;
  break;
  case GRID3D_TYPE::GRID_2P5MM:
  griSizeMM = 2.5;
  break;
  case GRID3D_TYPE::GRID_5MM:
  griSizeMM = 5.0;
  break;
  case GRID3D_TYPE::GRID_10MM:
  griSizeMM = 10.0;
  break;
  }
 
  glNormal3f( 0.0, 0.0, 1.0 );
 
  const wxSize brd_size = m_boardAdapter.GetBoardSize();
  wxPoint brd_center_pos = m_boardAdapter.GetBoardPos();
 
  brd_center_pos.y = -brd_center_pos.y;
 
  const int xsize = std::max( brd_size.x, Millimeter2iu( 100 ) ) * 1.2;
  const int ysize = std::max( brd_size.y, Millimeter2iu( 100 ) ) * 1.2;
 
  // Grid limits, in 3D units
  double xmin = ( brd_center_pos.x - xsize / 2 ) * scale;
  double xmax = ( brd_center_pos.x + xsize / 2 ) * scale;
  double ymin = ( brd_center_pos.y - ysize / 2 ) * scale;
  double ymax = ( brd_center_pos.y + ysize / 2 ) * scale;
  double zmin = Millimeter2iu( -50 ) * scale;
  double zmax = Millimeter2iu( 100 ) * scale;
 
  // Set rasterised line width (min value = 1)
  glLineWidth( 1 );
 
  // Draw horizontal grid centered on 3D origin (center of the board)
  for( int ii = 0; ; ii++ )
  {
  if( (ii % 5) )
  glColor4f( gridColor.r, gridColor.g, gridColor.b, transparency );
  else
  glColor4f( gridColor_marker.r, gridColor_marker.g, gridColor_marker.b,
  transparency );
 
  const int delta = KiROUND( ii * griSizeMM * IU_PER_MM );
 
  if( delta <= xsize / 2 ) // Draw grid lines parallel to X axis
  {
  glBegin( GL_LINES );
  glVertex3f( (brd_center_pos.x + delta) * scale, -ymin, zpos );
  glVertex3f( (brd_center_pos.x + delta) * scale, -ymax, zpos );
  glEnd();
 
  if( ii != 0 )
  {
  glBegin( GL_LINES );
  glVertex3f( (brd_center_pos.x - delta) * scale, -ymin, zpos );
  glVertex3f( (brd_center_pos.x - delta) * scale, -ymax, zpos );
  glEnd();
  }
  }
 
  if( delta <= ysize / 2 ) // Draw grid lines parallel to Y axis
  {
  glBegin( GL_LINES );
  glVertex3f( xmin, -( brd_center_pos.y + delta ) * scale, zpos );
  glVertex3f( xmax, -( brd_center_pos.y + delta ) * scale, zpos );
  glEnd();
 
  if( ii != 0 )
  {
  glBegin( GL_LINES );
  glVertex3f( xmin, -( brd_center_pos.y - delta ) * scale, zpos );
  glVertex3f( xmax, -( brd_center_pos.y - delta ) * scale, zpos );
  glEnd();
  }
  }
 
  if( ( delta > ysize / 2 ) && ( delta > xsize / 2 ) )
  break;
  }
 
  // Draw vertical grid on Z axis
  glNormal3f( 0.0, -1.0, 0.0 );
 
  // Draw vertical grid lines (parallel to Z axis)
  double posy = -brd_center_pos.y * scale;
 
  for( int ii = 0; ; ii++ )
  {
  if( (ii % 5) )
  glColor4f( gridColor.r, gridColor.g, gridColor.b, transparency );
  else
  glColor4f( gridColor_marker.r, gridColor_marker.g, gridColor_marker.b,
  transparency );
 
  const double delta = ii * griSizeMM * IU_PER_MM;
 
  glBegin( GL_LINES );
  xmax = ( brd_center_pos.x + delta ) * scale;
 
  glVertex3f( xmax, posy, zmin );
  glVertex3f( xmax, posy, zmax );
  glEnd();
 
  if( ii != 0 )
  {
  glBegin( GL_LINES );
  xmin = ( brd_center_pos.x - delta ) * scale;
  glVertex3f( xmin, posy, zmin );
  glVertex3f( xmin, posy, zmax );
  glEnd();
  }
 
  if( delta > xsize / 2.0f )
  break;
  }
 
  // Draw horizontal grid lines on Z axis (parallel to X axis)
  for( int ii = 0; ; ii++ )
  {
  if( ii % 5 )
  glColor4f( gridColor.r, gridColor.g, gridColor.b, transparency );
  else
  glColor4f( gridColor_marker.r, gridColor_marker.g, gridColor_marker.b, transparency );
 
  const double delta = ii * griSizeMM * IU_PER_MM * scale;
 
  if( delta <= zmax )
  {
  // Draw grid lines on Z axis (positive Z axis coordinates)
  glBegin( GL_LINES );
  glVertex3f( xmin, posy, delta );
  glVertex3f( xmax, posy, delta );
  glEnd();
  }
 
  if( delta <= -zmin && ( ii != 0 ) )
  {
  // Draw grid lines on Z axis (negative Z axis coordinates)
  glBegin( GL_LINES );
  glVertex3f( xmin, posy, -delta );
  glVertex3f( xmax, posy, -delta );
  glEnd();
  }
 
  if( ( delta > zmax ) && ( delta > -zmin ) )
  break;
  }
 
  glDisable( GL_BLEND );
 
  glEndList();
 }

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

Referenced by Redraw().

◆ generateCylinder()

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

private

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

 {
  std::vector< SFVEC2F > innerContour;
  std::vector< SFVEC2F > outerContour;
 
  generateRing( aCenter, aInnerRadius, aOuterRadius, aNr_sides_per_circle, innerContour,
  outerContour, false );
 
  for( unsigned int i = 0; i < ( innerContour.size() - 1 ); ++i )
  {
  const SFVEC2F& vi0 = innerContour[i + 0];
  const SFVEC2F& vi1 = innerContour[i + 1];
  const SFVEC2F& vo0 = outerContour[i + 0];
  const SFVEC2F& vo1 = outerContour[i + 1];
 
  aDstLayer->m_layer_top_triangles->AddQuad( SFVEC3F( vi1.x, vi1.y, aZtop ),
  SFVEC3F( vi0.x, vi0.y, aZtop ),
  SFVEC3F( vo0.x, vo0.y, aZtop ),
  SFVEC3F( vo1.x, vo1.y, aZtop ) );
 
  aDstLayer->m_layer_bot_triangles->AddQuad( SFVEC3F( vi1.x, vi1.y, aZbot ),
  SFVEC3F( vo1.x, vo1.y, aZbot ),
  SFVEC3F( vo0.x, vo0.y, aZbot ),
  SFVEC3F( vi0.x, vi0.y, aZbot ) );
  }
 
  aDstLayer->AddToMiddleContourns( outerContour, aZbot, aZtop, true );
  aDstLayer->AddToMiddleContourns( innerContour, aZbot, aZtop, false );
 }

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

Referenced by generateViasAndPads().

◆ generateHoles()

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

private

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

 {
  OPENGL_RENDER_LIST* ret = nullptr;
 
  if( aListHolesObject2d.size() > 0 )
  {
  TRIANGLE_DISPLAY_LIST* layerTriangles =
  new TRIANGLE_DISPLAY_LIST( aListHolesObject2d.size() * 2 );
 
  // Convert the list of objects(filled circles) to triangle layer structure
  for( const OBJECT_2D* itemOnLayer : aListHolesObject2d )
  {
  const OBJECT_2D* object2d_A = itemOnLayer;
 
  wxASSERT( ( object2d_A->GetObjectType() == OBJECT_2D_TYPE::FILLED_CIRCLE )
  || ( object2d_A->GetObjectType() == OBJECT_2D_TYPE::ROUNDSEG ) );
 
  switch( object2d_A->GetObjectType() )
  {
  case OBJECT_2D_TYPE::FILLED_CIRCLE:
  addObjectTriangles( static_cast<const FILLED_CIRCLE_2D*>( object2d_A ),
  layerTriangles, aZtop, aZbot );
  break;
 
  case OBJECT_2D_TYPE::ROUNDSEG:
  addObjectTriangles( static_cast<const ROUND_SEGMENT_2D*>( object2d_A ),
  layerTriangles, aZtop, aZbot );
  break;
 
  default:
  wxFAIL_MSG( "RENDER_3D_OPENGL::generateHoles: Object type is not implemented" );
  break;
  }
  }
 
  // Note: he can have a aListHolesObject2d with holes but without contours
  // eg: when there are only NPTH on the list and the contours were not added
  if( aPoly.OutlineCount() > 0 )
  {
  layerTriangles->AddToMiddleContourns( aPoly, aZbot, aZtop,
  m_boardAdapter.BiuTo3dUnits(),
  aInvertFaces, aThroughHoles );
  }
 
  ret = new OPENGL_RENDER_LIST( *layerTriangles, m_circleTexture, aZbot, aZtop );
 
  delete layerTriangles;
  }
 
  return ret;
 }

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.

 {
  if( aContainer == nullptr )
  return nullptr;
 
  const LIST_OBJECT2D& listObject2d = aContainer->GetList();
 
  if( listObject2d.size() == 0 )
  return nullptr;
 
  float layer_z_bot = 0.0f;
  float layer_z_top = 0.0f;
 
  getLayerZPos( aLayerId, layer_z_top, layer_z_bot );
 
  // Calculate an estimation for the nr of triangles based on the nr of objects
  unsigned int nrTrianglesEstimation = listObject2d.size() * 8;
 
  TRIANGLE_DISPLAY_LIST* layerTriangles = new TRIANGLE_DISPLAY_LIST( nrTrianglesEstimation );
 
  // store in a list so it will be latter deleted
  m_triangles.push_back( layerTriangles );
 
  // Load the 2D (X,Y axis) component of shapes
  for( const OBJECT_2D* itemOnLayer : listObject2d )
  {
  const OBJECT_2D* object2d_A = itemOnLayer;
 
  switch( object2d_A->GetObjectType() )
  {
  case OBJECT_2D_TYPE::FILLED_CIRCLE:
  addObjectTriangles( static_cast<const FILLED_CIRCLE_2D*>( object2d_A ),
  layerTriangles, layer_z_top, layer_z_bot );
  break;
 
  case OBJECT_2D_TYPE::POLYGON4PT:
  addObjectTriangles( static_cast<const POLYGON_4PT_2D*>( object2d_A ),
  layerTriangles, layer_z_top, layer_z_bot );
  break;
 
  case OBJECT_2D_TYPE::RING:
  addObjectTriangles( static_cast<const RING_2D*>( object2d_A ),
  layerTriangles, layer_z_top, layer_z_bot );
  break;
 
  case OBJECT_2D_TYPE::TRIANGLE:
  addObjectTriangles( static_cast<const TRIANGLE_2D*>( object2d_A ),
  layerTriangles, layer_z_top, layer_z_bot );
  break;
 
  case OBJECT_2D_TYPE::ROUNDSEG:
  addObjectTriangles( static_cast<const ROUND_SEGMENT_2D*>( object2d_A ),
  layerTriangles, layer_z_top, layer_z_bot );
  break;
 
  default:
  wxFAIL_MSG( "RENDER_3D_OPENGL: Object type is not implemented" );
  break;
  }
  }
 
  if( aPolyList && aPolyList->OutlineCount() > 0 )
  {
  layerTriangles->AddToMiddleContourns( *aPolyList, layer_z_bot, layer_z_top,
  m_boardAdapter.BiuTo3dUnits(), false, aThroughHoles );
  }
 
  // Create display list
  return new OPENGL_RENDER_LIST( *layerTriangles, m_circleTexture, layer_z_bot, layer_z_top );
 }

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.

 {
  aInnerContourResult.clear();
  aInnerContourResult.reserve( aNr_sides_per_circle + 2 );
 
  aOuterContourResult.clear();
  aOuterContourResult.reserve( aNr_sides_per_circle + 2 );
 
  const int delta = 3600 / aNr_sides_per_circle;
 
  for( int ii = 0; ii < 3600; ii += delta )
  {
  float angle = (float)( aInvertOrder ? ( 3600 - ii ) : ii )
  * 2.0f * glm::pi<float>() / 3600.0f;
  const SFVEC2F rotatedDir = SFVEC2F( cos( angle ), sin( angle ) );
 
  aInnerContourResult.emplace_back( aCenter.x + rotatedDir.x * aInnerRadius,
  aCenter.y + rotatedDir.y * aInnerRadius );
 
  aOuterContourResult.emplace_back( aCenter.x + rotatedDir.x * aOuterRadius,
  aCenter.y + rotatedDir.y * aOuterRadius );
  }
 
  aInnerContourResult.push_back( aInnerContourResult[0] );
  aOuterContourResult.push_back( aOuterContourResult[0] );
 
  wxASSERT( aInnerContourResult.size() == aOuterContourResult.size() );
 }

References PNS::angle(), and delta.

Referenced by addObjectTriangles(), and generateCylinder().

◆ generateViasAndPads()

void RENDER_3D_OPENGL::generateViasAndPads ( )

private

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

 {
  if( !m_boardAdapter.GetBoard() )
  return;
 
  const int platingThickness = m_boardAdapter.GetHolePlatingThickness();
  const float platingThickness3d = platingThickness * m_boardAdapter.BiuTo3dUnits();
 
  if( m_boardAdapter.GetViaCount() > 0 )
  {
  const unsigned int reserve_nr_triangles_estimation =
  m_boardAdapter.GetCircleSegmentCount(
  m_boardAdapter.GetAverageViaHoleDiameter() ) * 8 *
  m_boardAdapter.GetViaCount();
 
  TRIANGLE_DISPLAY_LIST* layerTriangleVIA =
  new TRIANGLE_DISPLAY_LIST( reserve_nr_triangles_estimation );
 
  // Insert plated vertical holes inside the board
 
  // Insert vias holes (vertical cylinders)
  for( const PCB_TRACK* track : m_boardAdapter.GetBoard()->Tracks() )
  {
  if( track->Type() == PCB_VIA_T )
  {
  const PCB_VIA* via = static_cast<const PCB_VIA*>( track );
 
  const float holediameter = via->GetDrillValue() * m_boardAdapter.BiuTo3dUnits();
  const int nrSegments = m_boardAdapter.GetCircleSegmentCount( via->GetDrillValue() );
  const float hole_inner_radius = holediameter / 2.0f;
 
  const SFVEC2F via_center( via->GetStart().x * m_boardAdapter.BiuTo3dUnits(),
  -via->GetStart().y * m_boardAdapter.BiuTo3dUnits() );
 
  PCB_LAYER_ID top_layer, bottom_layer;
  via->LayerPair( &top_layer, &bottom_layer );
 
  float ztop, zbot, dummy;
 
  getLayerZPos( top_layer, ztop, dummy );
  getLayerZPos( bottom_layer, dummy, zbot );
 
  wxASSERT( zbot < ztop );
 
  generateCylinder( via_center, hole_inner_radius,
  hole_inner_radius + platingThickness3d,
  ztop, zbot, nrSegments, layerTriangleVIA );
  }
  }
 
  m_vias = new OPENGL_RENDER_LIST( *layerTriangleVIA, 0, 0.0f, 0.0f );
 
  delete layerTriangleVIA;
  }
 
 
  if( m_boardAdapter.GetHoleCount() > 0 )
  {
  SHAPE_POLY_SET tht_outer_holes_poly; // Stores the outer poly of the copper holes (the pad)
  SHAPE_POLY_SET tht_inner_holes_poly; // Stores the inner poly of the copper holes (the hole)
 
  tht_outer_holes_poly.RemoveAllContours();
  tht_inner_holes_poly.RemoveAllContours();
 
  // Insert pads holes (vertical cylinders)
  for( const FOOTPRINT* footprint : m_boardAdapter.GetBoard()->Footprints() )
  {
  for( const PAD* pad : footprint->Pads() )
  {
  if( pad->GetAttribute() != PAD_ATTRIB::NPTH )
  {
  const wxSize drillsize = pad->GetDrillSize();
  const bool hasHole = drillsize.x && drillsize.y;
 
  if( !hasHole )
  continue;
 
  pad->TransformHoleWithClearanceToPolygon( tht_outer_holes_poly,
  platingThickness,
  ARC_HIGH_DEF, ERROR_INSIDE );
  pad->TransformHoleWithClearanceToPolygon( tht_inner_holes_poly, 0,
  ARC_HIGH_DEF, ERROR_INSIDE );
  }
  }
  }
 
  // Subtract the holes
  tht_outer_holes_poly.BooleanSubtract( tht_inner_holes_poly, SHAPE_POLY_SET::PM_FAST );
 
  if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
  tht_outer_holes_poly.BooleanSubtract( m_antiBoardPolys, SHAPE_POLY_SET::PM_FAST );
 
  CONTAINER_2D holesContainer;
 
  ConvertPolygonToTriangles( tht_outer_holes_poly, holesContainer,
  m_boardAdapter.BiuTo3dUnits(),
  (const BOARD_ITEM &)*m_boardAdapter.GetBoard() );
 
  const LIST_OBJECT2D& listHolesObject2d = holesContainer.GetList();
 
  if( listHolesObject2d.size() > 0 )
  {
  float layer_z_top, layer_z_bot, dummy;
 
  getLayerZPos( F_Cu, layer_z_top, dummy );
  getLayerZPos( B_Cu, dummy, layer_z_bot );
 
  TRIANGLE_DISPLAY_LIST* layerTriangles =
  new TRIANGLE_DISPLAY_LIST( listHolesObject2d.size() );
 
  // Convert the list of objects(triangles) to triangle layer structure
  for( const OBJECT_2D* itemOnLayer : listHolesObject2d )
  {
  const OBJECT_2D* object2d_A = itemOnLayer;
 
  wxASSERT( object2d_A->GetObjectType() == OBJECT_2D_TYPE::TRIANGLE );
 
  const TRIANGLE_2D* tri = static_cast<const TRIANGLE_2D*>( object2d_A );
 
  const SFVEC2F& v1 = tri->GetP1();
  const SFVEC2F& v2 = tri->GetP2();
  const SFVEC2F& v3 = tri->GetP3();
 
  addTopAndBottomTriangles( layerTriangles, v1, v2, v3, layer_z_top, layer_z_bot );
  }
 
  wxASSERT( tht_outer_holes_poly.OutlineCount() > 0 );
 
  if( tht_outer_holes_poly.OutlineCount() > 0 )
  {
  layerTriangles->AddToMiddleContourns( tht_outer_holes_poly,
  layer_z_bot, layer_z_top,
  m_boardAdapter.BiuTo3dUnits(), false );
 
  m_padHoles = new OPENGL_RENDER_LIST( *layerTriangles, m_circleTexture,
  layer_z_top, layer_z_top );
  }
 
  delete layerTriangles;
  }
  }
 }

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.

 {
  SFVEC4F layerColor = m_boardAdapter.GetLayerColor( aLayerID );
 
  if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
  {
  switch( aLayerID )
  {
  case B_Adhes:
  case F_Adhes:
  break;
 
  case B_Mask:
  layerColor = m_boardAdapter.m_SolderMaskColorBot;
  break;
  case F_Mask:
  layerColor = m_boardAdapter.m_SolderMaskColorTop;
  break;
 
  case B_Paste:
  case F_Paste:
  layerColor = m_boardAdapter.m_SolderPasteColor;
  break;
 
  case B_SilkS:
  layerColor = m_boardAdapter.m_SilkScreenColorBot;
  break;
  case F_SilkS:
  layerColor = m_boardAdapter.m_SilkScreenColorTop;
  break;
 
  case Dwgs_User:
  case Cmts_User:
  case Eco1_User:
  case Eco2_User:
  case Edge_Cuts:
  case Margin:
  break;
 
  case B_CrtYd:
  case F_CrtYd:
  break;
 
  case B_Fab:
  case F_Fab:
  break;
 
  default:
  layerColor = m_boardAdapter.m_CopperColor;
  break;
  }
  }
 
  return layerColor;
 }

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

Referenced by setLayerMaterial().

◆ getLayerZPos()

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

private

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

 {
  aOutZbot = m_boardAdapter.GetLayerBottomZPos( aLayerID );
  aOutZtop = m_boardAdapter.GetLayerTopZPos( aLayerID );
 
  if( aOutZtop < aOutZbot )
  {
  float tmpFloat = aOutZbot;
  aOutZbot = aOutZtop;
  aOutZtop = tmpFloat;
  }
 }

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

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

◆ GetWaitForEditingTimeOut()

int RENDER_3D_OPENGL::GetWaitForEditingTimeOut ( )

overridevirtual

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

Returns: a value in milliseconds

Implements RENDER_3D_BASE.

Definition at line 84 of file render_3d_opengl.cpp.

 {
  return 50; // ms
 }

◆ initializeOpenGL()

bool RENDER_3D_OPENGL::initializeOpenGL ( )

private

Definition at line 974 of file render_3d_opengl.cpp.

 {
  glEnable( GL_LINE_SMOOTH );
  glShadeModel( GL_SMOOTH );
 
  // 4-byte pixel alignment
  glPixelStorei( GL_UNPACK_ALIGNMENT, 4 );
 
  // Initialize the open GL texture to draw the filled semi-circle of the segments
  IMAGE* circleImage = new IMAGE( SIZE_OF_CIRCLE_TEXTURE, SIZE_OF_CIRCLE_TEXTURE );
 
  if( !circleImage )
  return false;
 
  unsigned int circleRadius = ( SIZE_OF_CIRCLE_TEXTURE / 2 ) - 4;
 
  circleImage->CircleFilled( ( SIZE_OF_CIRCLE_TEXTURE / 2 ) - 0,
  ( SIZE_OF_CIRCLE_TEXTURE / 2 ) - 0,
  circleRadius,
  0xFF );
 
  IMAGE* circleImageBlured = new IMAGE( circleImage->GetWidth(), circleImage->GetHeight() );
 
  circleImageBlured->EfxFilter_SkipCenter( circleImage, IMAGE_FILTER::GAUSSIAN_BLUR, circleRadius - 8 );
 
  m_circleTexture = OglLoadTexture( *circleImageBlured );
 
  delete circleImageBlured;
  circleImageBlured = nullptr;
 
  delete circleImage;
  circleImage = nullptr;
 
  init_lights();
 
  // Use this mode if you want see the triangle lines (debug proposes)
  //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
  m_is_opengl_initialized = true;
 
  return true;
 }

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; }

RENDER_3D_BASE::m_reloadRequested

bool m_reloadRequested

The window size that this camera is working.

Definition: render_3d_base.h:113

References RENDER_3D_BASE::m_reloadRequested.

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

◆ load3dModels()

void RENDER_3D_OPENGL::load3dModels ( REPORTER * aStatusReporter )

private

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

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

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

 {
  if( !m_boardAdapter.GetBoard() )
  return;
 
  if( !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_NORMAL )
  && !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_NORMAL_INSERT )
  && !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_VIRTUAL ) )
  {
  return;
  }
 
  // Go for all footprints
  for( const FOOTPRINT* footprint : m_boardAdapter.GetBoard()->Footprints() )
  {
  for( const FP_3DMODEL& model : footprint->Models() )
  {
  if( model.m_Show && !model.m_Filename.empty() )
  {
  if( aStatusReporter )
  {
  // Display the short filename of the 3D model loaded:
  // (the full name is usually too long to be displayed)
  wxFileName fn( model.m_Filename );
  aStatusReporter->Report( wxString::Format( _( "Loading %s..." ),
  fn.GetFullName() ) );
  }
 
  // Check if the model is not present in our cache map
  // (Not already loaded in memory)
  if( m_3dModelMap.find( model.m_Filename ) == m_3dModelMap.end() )
  {
  // It is not present, try get it from cache
  const S3DMODEL* modelPtr =
  m_boardAdapter.Get3dCacheManager()->GetModel( model.m_Filename );
 
  // only add it if the return is not NULL
  if( modelPtr )
  {
  MATERIAL_MODE materialMode = m_boardAdapter.GetMaterialMode();
  MODEL_3D* ogl_model = new MODEL_3D( *modelPtr, materialMode );
 
  if( ogl_model )
  m_3dModelMap[ model.m_Filename ] = ogl_model;
  }
  }
  }
  }
  }
 }

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

Referenced by Load3dModelsIfNeeded(), and reload().

◆ Load3dModelsIfNeeded()

void RENDER_3D_OPENGL::Load3dModelsIfNeeded ( )

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

if m_3dModelMap is empty

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

 {
  if( m_3dModelMap.size() > 0 )
  return;
 
  wxFrame* frame = dynamic_cast<EDA_3D_VIEWER_FRAME*>( m_canvas->GetParent() );
 
  if( frame )
  {
  STATUSBAR_REPORTER activityReporter( frame->GetStatusBar(),
  (int) EDA_3D_VIEWER_STATUSBAR::ACTIVITY );
  load3dModels( &activityReporter );
  }
  else
  load3dModels( nullptr );
 }

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

aIsMoving	if the user is moving the scene, it should be render in preview mode.
aStatusReporter	a 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.

 {
  // Initialize OpenGL
  if( !m_is_opengl_initialized )
  {
  if( !initializeOpenGL() )
  return false;
  }
 
  if( m_reloadRequested )
  {
  std::unique_ptr<BUSY_INDICATOR> busy = CreateBusyIndicator();
 
  if( aStatusReporter )
  aStatusReporter->Report( _( "Loading..." ) );
 
  reload( aStatusReporter, aWarningReporter );
 
  // generate a new 3D grid as the size of the board may had changed
  m_lastGridType = m_boardAdapter.GetGridType();
  generate3dGrid( m_lastGridType );
  }
  else
  {
  // Check if grid was changed
  if( m_boardAdapter.GetGridType() != m_lastGridType )
  {
  // and generate a new one
  m_lastGridType = m_boardAdapter.GetGridType();
  generate3dGrid( m_lastGridType );
  }
  }
 
  setupMaterials();
 
  // Initial setup
  glDepthFunc( GL_LESS );
  glEnable( GL_CULL_FACE );
  glFrontFace( GL_CCW ); // This is the OpenGL default
  glEnable( GL_NORMALIZE ); // This allow OpenGL to normalize the normals after transformations
  glViewport( 0, 0, m_windowSize.x, m_windowSize.y );
 
  if( m_boardAdapter.GetFlag( FL_RENDER_OPENGL_AA_DISABLE_ON_MOVE ) && aIsMoving )
  glDisable( GL_MULTISAMPLE );
  else
  glEnable( GL_MULTISAMPLE );
 
  // clear color and depth buffers
  glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
  glClearDepth( 1.0f );
  glClearStencil( 0x00 );
  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
 
  OglResetTextureState();
 
  // Draw the background ( rectangle with color gradient)
  OglDrawBackground( SFVEC3F( m_boardAdapter.m_BgColorTop ),
  SFVEC3F( m_boardAdapter.m_BgColorBot ) );
 
  glEnable( GL_DEPTH_TEST );
 
  // Set projection and modelview matrixes
  glMatrixMode( GL_PROJECTION );
  glLoadMatrixf( glm::value_ptr( m_camera.GetProjectionMatrix() ) );
  glMatrixMode( GL_MODELVIEW );
  glLoadIdentity();
  glLoadMatrixf( glm::value_ptr( m_camera.GetViewMatrix() ) );
 
  // Position the headlight
  setLightFront( true );
  setLightTop( true );
  setLightBottom( true );
 
  glEnable( GL_LIGHTING );
 
  {
  const SFVEC3F& cameraPos = m_camera.GetPos();
 
  // Place the light at a minimum Z so the diffuse factor will not drop
  // and the board will still look with good light.
  float zpos;
 
  if( cameraPos.z > 0.0f )
  {
  zpos = glm::max( cameraPos.z, 0.5f ) + cameraPos.z * cameraPos.z;
  }
  else
  {
  zpos = glm::min( cameraPos.z,-0.5f ) - cameraPos.z * cameraPos.z;
  }
 
  // This is a point light.
  const GLfloat headlight_pos[] = { cameraPos.x, cameraPos.y, zpos, 1.0f };
 
  glLightfv( GL_LIGHT0, GL_POSITION, headlight_pos );
  }
 
  const bool drawMiddleSegments = !( aIsMoving &&
  m_boardAdapter.GetFlag( FL_RENDER_OPENGL_THICKNESS_DISABLE_ON_MOVE ) );
 
  const bool skipRenderHoles = aIsMoving &&
  m_boardAdapter.GetFlag( FL_RENDER_OPENGL_HOLES_DISABLE_ON_MOVE );
 
  const bool skipRenderVias = aIsMoving &&
  m_boardAdapter.GetFlag( FL_RENDER_OPENGL_VIAS_DISABLE_ON_MOVE );
 
  if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
  {
  // Draw vias and pad holes with copper material
  setLayerMaterial( B_Cu );
  }
  else
  {
  OglSetMaterial( m_materials.m_GrayMaterial, 1.0f );
  }
 
  if( !( skipRenderVias || skipRenderHoles ) && m_vias )
  m_vias->DrawAll();
 
  if( !skipRenderHoles && m_padHoles )
  m_padHoles->DrawAll();
 
  // Display copper and tech layers
  for( MAP_OGL_DISP_LISTS::const_iterator ii = m_layers.begin(); ii != m_layers.end(); ++ii )
  {
  const PCB_LAYER_ID layer_id = ( PCB_LAYER_ID )( ii->first );
 
  // Mask layers are not processed here because they are a special case
  if( ( layer_id == B_Mask ) || ( layer_id == F_Mask ) )
  continue;
 
  // Do not show inner layers when it is displaying the board and board body is opaque
  // enough: the time to create inner layers can be *really significant*.
  // So avoid creating them is they are not very visible
  const double opacity_min = 0.8;
 
  if( m_boardAdapter.GetFlag( FL_SHOW_BOARD_BODY ) &&
  ( m_boardAdapter.m_BoardBodyColor.a > opacity_min ) )
  {
  if( ( layer_id > F_Cu ) && ( layer_id < B_Cu ) )
  continue;
  }
 
  glPushMatrix();
 
  OPENGL_RENDER_LIST* pLayerDispList = static_cast<OPENGL_RENDER_LIST*>( ii->second );
 
  if( ( layer_id >= F_Cu ) && ( layer_id <= B_Cu ) )
  {
  if( !m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ||
  !( m_boardAdapter.GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) &&
  m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) )
  setLayerMaterial( layer_id );
  else
  setCopperMaterial();
 
  if( skipRenderHoles )
  {
  pLayerDispList->DrawAllCameraCulled( m_camera.GetPos().z, drawMiddleSegments );
 
  // Draw copper plated pads
  if( ( ( layer_id == F_Cu ) || ( layer_id == B_Cu ) ) &&
  ( m_platedPadsFront || m_platedPadsBack ) )
  setPlatedCopperAndDepthOffset( layer_id );
 
  if( layer_id == F_Cu && m_platedPadsFront )
  {
  m_platedPadsFront->DrawAllCameraCulled( m_camera.GetPos().z,
  drawMiddleSegments );
  }
  else if( layer_id == B_Cu && m_platedPadsBack )
  {
  m_platedPadsBack->DrawAllCameraCulled( m_camera.GetPos().z,
  drawMiddleSegments );
  }
 
  unsetDepthOffset();
  }
  else
  {
  if( m_outerThroughHoles )
  {
  m_outerThroughHoles->ApplyScalePosition( pLayerDispList->GetZBot(),
  pLayerDispList->GetZTop()
  - pLayerDispList->GetZBot() );
  }
 
  if( m_antiBoard )
  {
  m_antiBoard->ApplyScalePosition( pLayerDispList->GetZBot(),
  pLayerDispList->GetZTop()
  - pLayerDispList->GetZBot() );
  }
 
  if( m_outerLayerHoles.find( layer_id ) != m_outerLayerHoles.end() )
  {
  const OPENGL_RENDER_LIST* viasHolesLayer = m_outerLayerHoles.at( layer_id );
 
  wxASSERT( viasHolesLayer != nullptr );
 
  if( viasHolesLayer != nullptr )
  {
  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
  m_outerThroughHoles,
  viasHolesLayer,
  m_antiBoard );
 
  // Draw copper plated pads
 
  if( ( ( layer_id == F_Cu ) || ( layer_id == B_Cu ) ) &&
  ( m_platedPadsFront || m_platedPadsBack ) )
  {
  setPlatedCopperAndDepthOffset( layer_id );
  }
 
  if( layer_id == F_Cu && m_platedPadsFront )
  {
  m_platedPadsFront->DrawAllCameraCulledSubtractLayer(
   drawMiddleSegments,
  m_outerThroughHoles,
  viasHolesLayer,
  m_antiBoard );
  }
  else if( layer_id == B_Cu && m_platedPadsBack )
  {
  m_platedPadsBack->DrawAllCameraCulledSubtractLayer(
  drawMiddleSegments,
  m_outerThroughHoles,
  viasHolesLayer,
  m_antiBoard );
  }
 
  unsetDepthOffset();
  }
  }
  else
  {
  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
  m_outerThroughHoles,
  m_antiBoard );
 
  // Draw copper plated pads
  if( ( ( layer_id == F_Cu ) || ( layer_id == B_Cu ) ) &&
  ( m_platedPadsFront || m_platedPadsBack ) )
  {
  setPlatedCopperAndDepthOffset( layer_id );
  }
 
  if( layer_id == F_Cu && m_platedPadsFront )
  {
  m_platedPadsFront->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
  m_outerThroughHoles,
  m_antiBoard );
  }
  else if( layer_id == B_Cu && m_platedPadsBack )
  {
  m_platedPadsBack->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
  m_outerThroughHoles,
  m_antiBoard );
  }
 
  unsetDepthOffset();
  }
  }
  }
  else
  {
  setLayerMaterial( layer_id );
 
  OPENGL_RENDER_LIST* throughHolesOuter =
  m_boardAdapter.GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS )
  && m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE )
  && ( layer_id == B_SilkS || layer_id == F_SilkS )
  ? m_outerThroughHoleRings
  : m_outerThroughHoles;
 
  if( throughHolesOuter )
  {
  throughHolesOuter->ApplyScalePosition(
  pLayerDispList->GetZBot(),
  pLayerDispList->GetZTop() - pLayerDispList->GetZBot() );
  }
 
  OPENGL_RENDER_LIST* anti_board = m_antiBoard;
 
  if( anti_board )
  {
  anti_board->ApplyScalePosition(
  pLayerDispList->GetZBot(),
  pLayerDispList->GetZTop() - pLayerDispList->GetZBot() );
  }
 
  if( !skipRenderHoles
  && m_boardAdapter.GetFlag( FL_SUBTRACT_MASK_FROM_SILK )
  && m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE )
  && ( ( layer_id == B_SilkS && m_layers.find( B_Mask ) != m_layers.end() )
  || ( layer_id == F_SilkS && m_layers.find( F_Mask ) != m_layers.end() ) ) )
  {
  const PCB_LAYER_ID layerMask_id = (layer_id == B_SilkS) ? B_Mask : F_Mask;
 
  const OPENGL_RENDER_LIST* pLayerDispListMask = m_layers.at( layerMask_id );
 
  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
  pLayerDispListMask,
  throughHolesOuter, anti_board );
  }
  else
  {
  if( !skipRenderHoles && throughHolesOuter
  && ( layer_id == B_SilkS || layer_id == F_SilkS ) )
  {
  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments, nullptr,
  throughHolesOuter,
  anti_board );
  }
  else
  {
  // Do not render Paste layers when skipRenderHoles is enabled
  // otherwise it will cause z-fight issues
  if( !( skipRenderHoles && ( layer_id == B_Paste || layer_id == F_Paste ) ) )
  {
  pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
  anti_board );
  }
  }
  }
  }
 
  glPopMatrix();
  }
 
  // Render 3D Models (Non-transparent)
  render3dModels( false, false );
  render3dModels( true, false );
 
  // Display board body
  if( m_boardAdapter.GetFlag( FL_SHOW_BOARD_BODY ) )
  {
  renderBoardBody( skipRenderHoles );
  }
 
  // Display transparent mask layers
  if( m_boardAdapter.GetFlag( FL_SOLDERMASK ) )
  {
  // add a depth buffer offset, it will help to hide some artifacts
  // on silkscreen where the SolderMask is removed
  glEnable( GL_POLYGON_OFFSET_FILL );
  glPolygonOffset( 0.0f, -2.0f );
 
  if( m_camera.GetPos().z > 0 )
  {
  renderSolderMaskLayer( B_Mask, m_boardAdapter.GetLayerTopZPos( B_Mask ),
  drawMiddleSegments, skipRenderHoles );
 
  renderSolderMaskLayer( F_Mask, m_boardAdapter.GetLayerBottomZPos( F_Mask ),
  drawMiddleSegments, skipRenderHoles );
  }
  else
  {
  renderSolderMaskLayer( F_Mask, m_boardAdapter.GetLayerBottomZPos( F_Mask ),
  drawMiddleSegments, skipRenderHoles );
 
  renderSolderMaskLayer( B_Mask, m_boardAdapter.GetLayerTopZPos( B_Mask ),
  drawMiddleSegments, skipRenderHoles );
  }
 
  glDisable( GL_POLYGON_OFFSET_FILL );
  glPolygonOffset( 0.0f, 0.0f );
  }
 
  // Render 3D Models (Transparent)
  // !TODO: this can be optimized. If there are no transparent models (or no opacity),
  // then there is no need to make this function call.
  glDepthMask( GL_FALSE );
  glEnable( GL_BLEND );
  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 
  // Enables Texture Env so it can combine model transparency with each footprint opacity
  glEnable( GL_TEXTURE_2D );
  glActiveTexture( GL_TEXTURE0 );
 
  glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE );
  glTexEnvf( GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE );
  glTexEnvf( GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE );
 
  glTexEnvi( GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PRIMARY_COLOR );
  glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR );
 
  glTexEnvi( GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PREVIOUS );
  glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR );
 
  glTexEnvi( GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PRIMARY_COLOR );
  glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA );
  glTexEnvi( GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_CONSTANT );
  glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_CONSTANT );
 
  render3dModels( false, true );
  render3dModels( true, true );
 
  glDisable( GL_BLEND );
  OglResetTextureState();
 
  glDepthMask( GL_TRUE );
 
  // Render Grid
  if( m_boardAdapter.GetGridType() != GRID3D_TYPE::NONE )
  {
  glDisable( GL_LIGHTING );
 
  if( glIsList( m_grid ) )
  glCallList( m_grid );
 
  glEnable( GL_LIGHTING );
  }
 
  // Render 3D arrows
  if( m_boardAdapter.GetFlag( FL_AXIS ) )
  render3dArrows();
 
  // Return back to the original viewport (this is important if we want
  // to take a screenshot after the render)
  glViewport( 0, 0, m_windowSize.x, m_windowSize.y );
 
  return false;
 }

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

◆ reload()

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

private

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

 {
  m_reloadRequested = false;
 
  freeAllLists();
 
  OBJECT_2D_STATS::Instance().ResetStats();
 
  unsigned stats_startReloadTime = GetRunningMicroSecs();
 
  m_boardAdapter.InitSettings( aStatusReporter, aWarningReporter );
 
  SFVEC3F camera_pos = m_boardAdapter.GetBoardCenter();
  m_camera.SetBoardLookAtPos( camera_pos );
 
  if( aStatusReporter )
  aStatusReporter->Report( _( "Load OpenGL: board" ) );
 
  // Create Board
  m_board = createBoard( m_boardAdapter.GetBoardPoly(), &m_boardAdapter.GetThroughHoleIds() );
 
  if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
  {
  m_antiBoardPolys.RemoveAllContours();
  m_antiBoardPolys.NewOutline();
  m_antiBoardPolys.Append( VECTOR2I( -INT_MAX/2, -INT_MAX/2 ) );
  m_antiBoardPolys.Append( VECTOR2I( INT_MAX/2, -INT_MAX/2 ) );
  m_antiBoardPolys.Append( VECTOR2I( INT_MAX/2, INT_MAX/2 ) );
  m_antiBoardPolys.Append( VECTOR2I( -INT_MAX/2, INT_MAX/2 ) );
  m_antiBoardPolys.Outline( 0 ).SetClosed( true );
 
  m_antiBoardPolys.BooleanSubtract( m_boardAdapter.GetBoardPoly(),
  SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
  m_antiBoard = createBoard( m_antiBoardPolys );
  }
 
  SHAPE_POLY_SET board_poly_with_holes = m_boardAdapter.GetBoardPoly();
  board_poly_with_holes.BooleanSubtract( m_boardAdapter.GetThroughHoleOdPolys(),
  SHAPE_POLY_SET::PM_FAST );
  board_poly_with_holes.BooleanSubtract( m_boardAdapter.GetOuterNonPlatedThroughHolePoly(),
  SHAPE_POLY_SET::PM_FAST );
 
  m_boardWithHoles = createBoard( board_poly_with_holes );
 
  if( m_antiBoard )
  m_antiBoard->SetItIsTransparent( true );
 
  // Create Through Holes and vias
  if( aStatusReporter )
  aStatusReporter->Report( _( "Load OpenGL: holes and vias" ) );
 
  SHAPE_POLY_SET outerPolyTHT = m_boardAdapter.GetThroughHoleOdPolys();
 
  if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
  outerPolyTHT.BooleanIntersection( m_boardAdapter.GetBoardPoly(),
  SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
 
  m_outerThroughHoles = generateHoles( m_boardAdapter.GetThroughHoleOds().GetList(),
  outerPolyTHT, 1.0f, 0.0f, false,
  &m_boardAdapter.GetThroughHoleIds() );
 
  m_outerViaThroughHoles = generateHoles(
  m_boardAdapter.GetThroughHoleViaOds().GetList(),
  m_boardAdapter.GetThroughHoleViaOdPolys(), 1.0f, 0.0f, false );
 
  if( m_boardAdapter.GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) &&
  m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
  {
  m_outerThroughHoleRings = generateHoles(
  m_boardAdapter.GetThroughHoleAnnularRings().GetList(),
  m_boardAdapter.GetThroughHoleAnnularRingPolys(), 1.0f, 0.0f, false );
  }
 
  const MAP_POLY& innerMapHoles = m_boardAdapter.GetHoleIdPolysMap();
  const MAP_POLY& outerMapHoles = m_boardAdapter.GetHoleOdPolysMap();
 
  wxASSERT( innerMapHoles.size() == outerMapHoles.size() );
 
  const MAP_CONTAINER_2D_BASE& map_holes = m_boardAdapter.GetLayerHoleMap();
 
  if( outerMapHoles.size() > 0 )
  {
  float layer_z_bot = 0.0f;
  float layer_z_top = 0.0f;
 
  for( const auto ii : outerMapHoles )
  {
  const PCB_LAYER_ID layer_id = ii.first;
  const SHAPE_POLY_SET* poly = ii.second;
  const BVH_CONTAINER_2D* container = map_holes.at( layer_id );
 
  getLayerZPos( layer_id, layer_z_top, layer_z_bot );
 
  m_outerLayerHoles[layer_id] = generateHoles( container->GetList(), *poly,
  layer_z_top, layer_z_bot, false );
  }
 
  for( const auto ii : innerMapHoles )
  {
  const PCB_LAYER_ID layer_id = ii.first;
  const SHAPE_POLY_SET* poly = ii.second;
  const BVH_CONTAINER_2D* container = map_holes.at( layer_id );
 
  getLayerZPos( layer_id, layer_z_top, layer_z_bot );
 
  m_innerLayerHoles[layer_id] = generateHoles( container->GetList(), *poly,
  layer_z_top, layer_z_bot, false );
  }
  }
 
  // Generate vertical cylinders of vias and pads (copper)
  generateViasAndPads();
 
  // Add layers maps
  if( aStatusReporter )
  aStatusReporter->Report( _( "Load OpenGL: layers" ) );
 
  const MAP_POLY& map_poly = m_boardAdapter.GetPolyMap();
 
  for( const auto ii : m_boardAdapter.GetLayerMap() )
  {
  const PCB_LAYER_ID layer_id = ii.first;
 
  if( !m_boardAdapter.Is3dLayerEnabled( layer_id ) )
  continue;
 
  if( aStatusReporter )
  aStatusReporter->Report( wxString::Format(
  _( "Load OpenGL layer %d" ), (int)layer_id ) );
 
  const BVH_CONTAINER_2D* container2d = ii.second;
 
  SHAPE_POLY_SET polyListSubtracted;
  SHAPE_POLY_SET* aPolyList = nullptr;
 
  // Load the vertical (Z axis) component of shapes
 
  if( map_poly.find( layer_id ) != map_poly.end() )
  {
  polyListSubtracted = *map_poly.at( layer_id );;
 
  if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
  {
  polyListSubtracted.BooleanIntersection( m_boardAdapter.GetBoardPoly(),
  SHAPE_POLY_SET::PM_FAST );
 
  if( ( layer_id != B_Mask ) && ( layer_id != F_Mask ) )
  {
  polyListSubtracted.BooleanSubtract( m_boardAdapter.GetThroughHoleOdPolys(),
  SHAPE_POLY_SET::PM_FAST );
  polyListSubtracted.BooleanSubtract(
  m_boardAdapter.GetOuterNonPlatedThroughHolePoly(),
  SHAPE_POLY_SET::PM_FAST );
  }
 
  if( m_boardAdapter.GetFlag( FL_SUBTRACT_MASK_FROM_SILK ) )
  {
  if( layer_id == B_SilkS && map_poly.find( B_Mask ) != map_poly.end() )
  {
  polyListSubtracted.BooleanSubtract( *map_poly.at( B_Mask ),
  SHAPE_POLY_SET::PM_FAST );
  }
  else if( layer_id == F_SilkS && map_poly.find( F_Mask ) != map_poly.end() )
  {
  polyListSubtracted.BooleanSubtract( *map_poly.at( F_Mask ),
  SHAPE_POLY_SET::PM_FAST );
  }
  }
  }
 
  aPolyList = &polyListSubtracted;
  }
 
  OPENGL_RENDER_LIST* oglList = generateLayerList( container2d, aPolyList, layer_id,
  &m_boardAdapter.GetThroughHoleIds() );
 
  if( oglList != nullptr )
  m_layers[layer_id] = oglList;
 
  }
 
  if( m_boardAdapter.GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) &&
  m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
  {
  if( m_boardAdapter.GetFrontPlatedPadPolys() )
  {
  SHAPE_POLY_SET polySubtracted = *m_boardAdapter.GetFrontPlatedPadPolys();
  polySubtracted.BooleanIntersection( m_boardAdapter.GetBoardPoly(),
  SHAPE_POLY_SET::PM_FAST );
  polySubtracted.BooleanSubtract( m_boardAdapter.GetThroughHoleOdPolys(),
  SHAPE_POLY_SET::PM_FAST );
  polySubtracted.BooleanSubtract( m_boardAdapter.GetOuterNonPlatedThroughHolePoly(),
  SHAPE_POLY_SET::PM_FAST );
 
  m_platedPadsFront = generateLayerList( m_boardAdapter.GetPlatedPadsFront(),
  &polySubtracted, F_Cu );
  }
 
  if( m_boardAdapter.GetBackPlatedPadPolys() )
  {
  SHAPE_POLY_SET polySubtracted = *m_boardAdapter.GetBackPlatedPadPolys();
  polySubtracted.BooleanIntersection( m_boardAdapter.GetBoardPoly(),
  SHAPE_POLY_SET::PM_FAST );
  polySubtracted.BooleanSubtract( m_boardAdapter.GetThroughHoleOdPolys(),
  SHAPE_POLY_SET::PM_FAST );
  polySubtracted.BooleanSubtract( m_boardAdapter.GetOuterNonPlatedThroughHolePoly(),
  SHAPE_POLY_SET::PM_FAST );
 
  m_platedPadsBack = generateLayerList( m_boardAdapter.GetPlatedPadsBack(),
  &polySubtracted, B_Cu );
  }
  }
 
  // Load 3D models
  if( aStatusReporter )
  aStatusReporter->Report( _( "Loading 3D models..." ) );
 
  load3dModels( aStatusReporter );
 
  if( aStatusReporter )
  {
  // Calculation time in seconds
  const double calculation_time = (double)( GetRunningMicroSecs() -
  stats_startReloadTime) / 1e6;
 
  aStatusReporter->Report( wxString::Format( _( "Reload time %.3f s" ), calculation_time ) );
  }
 }

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; }

RENDER_3D_BASE::m_reloadRequested

bool m_reloadRequested

The window size that this camera is working.

Definition: render_3d_base.h:113

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.

 {
  const float arrow_size = RANGE_SCALE_3D * 0.30f;
 
  glDisable( GL_CULL_FACE );
 
  // YxY squared view port, this is on propose
  glViewport( 4, 4, m_windowSize.y / 8 , m_windowSize.y / 8 );
  glClear( GL_DEPTH_BUFFER_BIT );
 
  glMatrixMode( GL_PROJECTION );
  glLoadIdentity();
  gluPerspective( 45.0f, 1.0f, 0.001f, RANGE_SCALE_3D );
 
  glMatrixMode( GL_MODELVIEW );
  glLoadIdentity();
 
  const glm::mat4 TranslationMatrix =
  glm::translate( glm::mat4( 1.0f ), SFVEC3F( 0.0f, 0.0f, -( arrow_size * 2.75f ) ) );
 
  const glm::mat4 ViewMatrix = TranslationMatrix * m_camera.GetRotationMatrix();
 
  glLoadMatrixf( glm::value_ptr( ViewMatrix ) );
 
  setArrowMaterial();
 
  glColor3f( 0.9f, 0.0f, 0.0f );
  DrawRoundArrow( SFVEC3F( 0.0f, 0.0f, 0.0f ), SFVEC3F( arrow_size, 0.0f, 0.0f ), 0.275f );
 
  glColor3f( 0.0f, 0.9f, 0.0f );
  DrawRoundArrow( SFVEC3F( 0.0f, 0.0f, 0.0f ), SFVEC3F( 0.0f, arrow_size, 0.0f ), 0.275f );
 
  glColor3f( 0.0f, 0.0f, 0.9f );
  DrawRoundArrow( SFVEC3F( 0.0f, 0.0f, 0.0f ), SFVEC3F( 0.0f, 0.0f, arrow_size ), 0.275f );
 
  glEnable( GL_CULL_FACE );
 }

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

aRenderTopOrBot	true will render Top, false will render bottom
aRenderTransparentOnly	true will render only the transparent objects, false will render opaque

Definition at line 1215 of file render_3d_opengl.cpp.

 {
  if( m_boardAdapter.GetFlag( FL_USE_SELECTION ) )
  render3dModelsSelected( aRenderTopOrBot, aRenderTransparentOnly, true );
 
  render3dModelsSelected( aRenderTopOrBot, aRenderTransparentOnly, false );
 }

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

Referenced by Redraw().

◆ render3dModelsSelected()

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

private

Definition at line 1176 of file render_3d_opengl.cpp.

 {
  if( !m_boardAdapter.GetBoard() )
  return;
 
  MODEL_3D::BeginDrawMulti( !aRenderSelectedOnly );
 
  // Go for all footprints
  for( FOOTPRINT* fp : m_boardAdapter.GetBoard()->Footprints() )
  {
  bool highlight = false;
 
  if( m_boardAdapter.GetFlag( FL_USE_SELECTION ) )
  {
  if( fp->IsSelected() )
  highlight = true;
 
  if( m_boardAdapter.GetFlag( FL_HIGHLIGHT_ROLLOVER_ITEM ) && fp == m_currentRollOverItem )
  highlight = true;
 
  if( aRenderSelectedOnly != highlight )
  continue;
  }
 
  if( !fp->Models().empty() )
  {
  if( m_boardAdapter.IsFootprintShown( (FOOTPRINT_ATTR_T) fp->GetAttributes() ) )
  {
  if( aRenderTopOrBot == !fp->IsFlipped() )
  renderFootprint( fp, aRenderTransparentOnly, highlight );
  }
  }
  }
 
  MODEL_3D::EndDrawMulti();
 }

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.

 {
  m_materials.m_EpoxyBoard.m_Diffuse = m_boardAdapter.m_BoardBodyColor;
 
  // opacity to transparency
  m_materials.m_EpoxyBoard.m_Transparency = 1.0f - m_boardAdapter.m_BoardBodyColor.a;
 
  OglSetMaterial( m_materials.m_EpoxyBoard, 1.0f );
 
  OPENGL_RENDER_LIST* ogl_disp_list = nullptr;
 
  if( aSkipRenderHoles )
  ogl_disp_list = m_board;
  else
  ogl_disp_list = m_boardWithHoles;
 
  if( ogl_disp_list )
  {
  ogl_disp_list->ApplyScalePosition( -m_boardAdapter.GetEpoxyThickness() / 2.0f,
  m_boardAdapter.GetEpoxyThickness() );
 
  ogl_disp_list->SetItIsTransparent( true );
 
  ogl_disp_list->DrawAll();
  }
 }

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

Referenced by Redraw().

◆ renderFootprint()

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

private

Definition at line 1224 of file render_3d_opengl.cpp.

 {
  if( !aFootprint->Models().empty() )
  {
  const double zpos = m_boardAdapter.GetFootprintZPos( aFootprint->IsFlipped() );
 
  glPushMatrix();
 
  wxPoint pos = aFootprint->GetPosition();
 
  glTranslatef( pos.x * m_boardAdapter.BiuTo3dUnits(), -pos.y * m_boardAdapter.BiuTo3dUnits(),
  zpos );
 
  if( aFootprint->GetOrientation() )
  glRotated( (double) aFootprint->GetOrientation() / 10.0, 0.0, 0.0, 1.0 );
 
  if( aFootprint->IsFlipped() )
  {
  glRotatef( 180.0f, 0.0f, 1.0f, 0.0f );
  glRotatef( 180.0f, 0.0f, 0.0f, 1.0f );
  }
 
  double modelunit_to_3d_units_factor = m_boardAdapter.BiuTo3dUnits() * UNITS3D_TO_UNITSPCB;
 
  glScaled( modelunit_to_3d_units_factor, modelunit_to_3d_units_factor,
  modelunit_to_3d_units_factor );
 
  // Get the list of model files for this model
  for( const FP_3DMODEL& sM : aFootprint->Models() )
  {
  if( !sM.m_Show || sM.m_Filename.empty() )
  continue;
 
  // Check if the model is present in our cache map
  auto cache_i = m_3dModelMap.find( sM.m_Filename );
 
  if( cache_i == m_3dModelMap.end() )
  continue;
 
  if( const MODEL_3D* modelPtr = cache_i->second )
  {
  bool opaque = sM.m_Opacity >= 1.0;
 
  if( ( !aRenderTransparentOnly && modelPtr->HasOpaqueMeshes() && opaque ) ||
  ( aRenderTransparentOnly && ( modelPtr->HasTransparentMeshes() || !opaque ) ) )
  {
  glPushMatrix();
 
  // FIXME: don't do this over and over again unless the
  // values have changed. cache the matrix somewhere.
  glm::mat4 mtx( 1 );
  mtx = glm::translate( mtx, { sM.m_Offset.x, sM.m_Offset.y, sM.m_Offset.z } );
  mtx = glm::rotate( mtx, glm::radians( (float) -sM.m_Rotation.z ),
  { 0.0f, 0.0f, 1.0f } );
  mtx = glm::rotate( mtx, glm::radians( (float) -sM.m_Rotation.y ),
  { 0.0f, 1.0f, 0.0f } );
  mtx = glm::rotate( mtx, glm::radians( (float) -sM.m_Rotation.x ),
  { 1.0f, 0.0f, 0.0f } );
  mtx = glm::scale( mtx, { sM.m_Scale.x, sM.m_Scale.y, sM.m_Scale.z } );
  glMultMatrixf( glm::value_ptr( mtx ) );
 
  if( aRenderTransparentOnly )
  {
  modelPtr->DrawTransparent( sM.m_Opacity,
   aFootprint->IsSelected() || aIsSelected,
  m_boardAdapter.m_OpenGlSelectionColor );
  }
  else
  {
  modelPtr->DrawOpaque( aFootprint->IsSelected() || aIsSelected,
  m_boardAdapter.m_OpenGlSelectionColor );
  }
 
  if( m_boardAdapter.GetFlag( FL_RENDER_OPENGL_SHOW_MODEL_BBOX ) )
  {
  glEnable( GL_BLEND );
  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 
  glDisable( GL_LIGHTING );
 
  glLineWidth( 1 );
  modelPtr->DrawBboxes();
 
  glLineWidth( 4 );
  modelPtr->DrawBbox();
 
  glEnable( GL_LIGHTING );
  glDisable( GL_BLEND );
  }
 
  glPopMatrix();
  }
  }
  }
 
  glPopMatrix();
  }
 }

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

Referenced by render3dModelsSelected().

◆ renderSolderMaskLayer()

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

private

Definition at line 1118 of file render_3d_opengl.cpp.

 {
  wxASSERT( (aLayerID == B_Mask) || (aLayerID == F_Mask) );
 
  float nonCopperThickness = m_boardAdapter.GetNonCopperLayerThickness();
 
  if( m_board )
  {
  if( m_layers.find( aLayerID ) != m_layers.end() )
  {
  OPENGL_RENDER_LIST* pLayerDispListMask = m_layers.at( aLayerID );
 
  if( m_outerViaThroughHoles )
  m_outerViaThroughHoles->ApplyScalePosition( aZPosition, nonCopperThickness );
 
  m_board->ApplyScalePosition( aZPosition, nonCopperThickness );
 
  setLayerMaterial( aLayerID );
 
  m_board->SetItIsTransparent( true );
 
  if( aSkipRenderHoles )
  {
  m_board->DrawAllCameraCulled( m_camera.GetPos().z, aDrawMiddleSegments );
  }
  else
  {
  m_board->DrawAllCameraCulledSubtractLayer( aDrawMiddleSegments, pLayerDispListMask,
  m_outerViaThroughHoles );
  }
  }
  else
  {
  // This case there is no layer with mask, so we will render the full board as mask
  if( m_outerViaThroughHoles )
  m_outerViaThroughHoles->ApplyScalePosition( aZPosition, nonCopperThickness );
 
  m_board->ApplyScalePosition( aZPosition, nonCopperThickness );
 
  setLayerMaterial( aLayerID );
 
  m_board->SetItIsTransparent( true );
 
  if( aSkipRenderHoles )
  {
  m_board->DrawAllCameraCulled( m_camera.GetPos().z, aDrawMiddleSegments );
  }
  else
  {
  m_board->DrawAllCameraCulledSubtractLayer( aDrawMiddleSegments,
  m_outerViaThroughHoles );
  }
  }
  }
 }

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

Referenced by Redraw().

◆ setArrowMaterial()

void RENDER_3D_OPENGL::setArrowMaterial ( )

private

Definition at line 1017 of file render_3d_opengl.cpp.

 {
  glEnable( GL_COLOR_MATERIAL );
  glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
 
  const SFVEC4F ambient = SFVEC4F( 0.0f, 0.0f, 0.0f, 1.0f );
  const SFVEC4F diffuse = SFVEC4F( 0.0f, 0.0f, 0.0f, 1.0f );
  const SFVEC4F emissive = SFVEC4F( 0.0f, 0.0f, 0.0f, 1.0f );
  const SFVEC4F specular = SFVEC4F( 0.1f, 0.1f, 0.1f, 1.0f );
 
  glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.r );
  glMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, 96.0f );
 
  glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, &ambient.r );
  glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, &diffuse.r );
  glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, &emissive.r );
 }

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.

 {
  m_busyIndicatorFactory = aNewFactory;
 }

References RENDER_3D_BASE::m_busyIndicatorFactory.

◆ setCopperMaterial()

void RENDER_3D_OPENGL::setCopperMaterial ( )

private

Definition at line 498 of file render_3d_opengl.cpp.

 {
  OglSetMaterial( m_materials.m_NonPlatedCopper, 1.0f );
 }

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.

  {
  m_currentRollOverItem = aRollOverItem;
  }

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

aSize the current size of the render window

Implements RENDER_3D_BASE.

Definition at line 90 of file render_3d_opengl.cpp.

 {
  if( m_windowSize != aSize )
  {
  m_windowSize = aSize;
  glViewport( 0, 0, m_windowSize.x, m_windowSize.y );
 
  // Initialize here any screen dependent data here
  }
 }

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.

 {
  switch( aLayerID )
  {
  case F_Mask:
  case B_Mask:
  {
  const SFVEC4F layerColor = getLayerColor( aLayerID );
 
  m_materials.m_SolderMask.m_Diffuse = layerColor;
 
  // Convert Opacity to Transparency
  m_materials.m_SolderMask.m_Transparency = 1.0f - layerColor.a;
 
  if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
  {
  m_materials.m_SolderMask.m_Ambient = m_materials.m_SolderMask.m_Diffuse * 0.3f;
 
  m_materials.m_SolderMask.m_Specular =
  m_materials.m_SolderMask.m_Diffuse * m_materials.m_SolderMask.m_Diffuse;
  }
 
  OglSetMaterial( m_materials.m_SolderMask, 1.0f );
  break;
  }
 
  case B_Paste:
  case F_Paste:
  m_materials.m_Paste.m_Diffuse = getLayerColor( aLayerID );
  OglSetMaterial( m_materials.m_Paste, 1.0f );
  break;
 
  case B_SilkS:
  m_materials.m_SilkSBot.m_Diffuse = getLayerColor( aLayerID );
  OglSetMaterial( m_materials.m_SilkSBot, 1.0f );
  break;
 
  case F_SilkS:
  m_materials.m_SilkSTop.m_Diffuse = getLayerColor( aLayerID );
  OglSetMaterial( m_materials.m_SilkSTop, 1.0f );
  break;
 
  case B_Adhes:
  case F_Adhes:
  case Dwgs_User:
  case Cmts_User:
  case Eco1_User:
  case Eco2_User:
  case Edge_Cuts:
  case Margin:
  case B_CrtYd:
  case F_CrtYd:
  case B_Fab:
  case F_Fab:
  m_materials.m_Plastic.m_Diffuse = getLayerColor( aLayerID );
 
  m_materials.m_Plastic.m_Ambient = SFVEC3F( m_materials.m_Plastic.m_Diffuse.r * 0.05f,
  m_materials.m_Plastic.m_Diffuse.g * 0.05f,
  m_materials.m_Plastic.m_Diffuse.b * 0.05f );
 
  m_materials.m_Plastic.m_Specular = SFVEC3F( m_materials.m_Plastic.m_Diffuse.r * 0.7f,
  m_materials.m_Plastic.m_Diffuse.g * 0.7f,
  m_materials.m_Plastic.m_Diffuse.b * 0.7f );
 
  m_materials.m_Plastic.m_Shininess = 0.078125f * 128.0f;
  m_materials.m_Plastic.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
  OglSetMaterial( m_materials.m_Plastic, 1.0f );
  break;
 
  default:
  m_materials.m_Copper.m_Diffuse = getLayerColor( aLayerID );
  OglSetMaterial( m_materials.m_Copper, 1.0f );
  break;
  }
 }

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.

 {
  if( enabled )
  glEnable( GL_LIGHT2 );
  else
  glDisable( GL_LIGHT2 );
 }

Referenced by Redraw().

◆ setLightFront()

void RENDER_3D_OPENGL::setLightFront ( bool enabled )

private

Definition at line 102 of file render_3d_opengl.cpp.

 {
  if( enabled )
  glEnable( GL_LIGHT0 );
  else
  glDisable( GL_LIGHT0 );
 }

Referenced by Redraw().

◆ setLightTop()

void RENDER_3D_OPENGL::setLightTop ( bool enabled )

private

Definition at line 111 of file render_3d_opengl.cpp.

 {
  if( enabled )
  glEnable( GL_LIGHT1 );
  else
  glDisable( GL_LIGHT1 );
 }

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.

 {
  glEnable( GL_POLYGON_OFFSET_FILL );
  glPolygonOffset(-0.1f, -2.0f );
  setLayerMaterial( aLayer_id );
 }

References setLayerMaterial().

Referenced by Redraw().

◆ setupMaterials()

void RENDER_3D_OPENGL::setupMaterials ( )

private

Definition at line 168 of file render_3d_opengl.cpp.

 {
  m_materials = {};
 
  if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
  {
  // http://devernay.free.fr/cours/opengl/materials.html
 
  // Plated copper
  // Copper material mixed with the copper color
  m_materials.m_Copper.m_Ambient = SFVEC3F( m_boardAdapter.m_CopperColor.r * 0.1f,
  m_boardAdapter.m_CopperColor.g * 0.1f,
  m_boardAdapter.m_CopperColor.b * 0.1f);
 
  m_materials.m_Copper.m_Specular = SFVEC3F( m_boardAdapter.m_CopperColor.r * 0.75f + 0.25f,
  m_boardAdapter.m_CopperColor.g * 0.75f + 0.25f,
  m_boardAdapter.m_CopperColor.b * 0.75f + 0.25f );
 
  // This guess the material type(ex: copper vs gold) to determine the
  // shininess factor between 0.1 and 0.4
  float shininessfactor = 0.40f - mapf( fabs( m_boardAdapter.m_CopperColor.r -
  m_boardAdapter.m_CopperColor.g ),
  0.15f, 1.00f,
  0.00f, 0.30f );
 
  m_materials.m_Copper.m_Shininess = shininessfactor * 128.0f;
  m_materials.m_Copper.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
 
 
  // Non plated copper (raw copper)
  m_materials.m_NonPlatedCopper.m_Ambient = SFVEC3F( 0.191f, 0.073f, 0.022f );
  m_materials.m_NonPlatedCopper.m_Diffuse = SFVEC3F( 184.0f / 255.0f, 115.0f / 255.0f,
  50.0f / 255.0f );
  m_materials.m_NonPlatedCopper.m_Specular = SFVEC3F( 0.256f, 0.137f, 0.086f );
  m_materials.m_NonPlatedCopper.m_Shininess = 0.1f * 128.0f;
  m_materials.m_NonPlatedCopper.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
 
  // Paste material mixed with paste color
  m_materials.m_Paste.m_Ambient = SFVEC3F( m_boardAdapter.m_SolderPasteColor.r,
  m_boardAdapter.m_SolderPasteColor.g,
  m_boardAdapter.m_SolderPasteColor.b );
 
  m_materials.m_Paste.m_Specular = SFVEC3F( m_boardAdapter.m_SolderPasteColor.r *
  m_boardAdapter.m_SolderPasteColor.r,
  m_boardAdapter.m_SolderPasteColor.g *
  m_boardAdapter.m_SolderPasteColor.g,
  m_boardAdapter.m_SolderPasteColor.b *
  m_boardAdapter.m_SolderPasteColor.b );
 
  m_materials.m_Paste.m_Shininess = 0.1f * 128.0f;
  m_materials.m_Paste.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
 
  // Silk screen material mixed with silk screen color
  m_materials.m_SilkSTop.m_Ambient = SFVEC3F( m_boardAdapter.m_SilkScreenColorTop.r,
  m_boardAdapter.m_SilkScreenColorTop.g,
  m_boardAdapter.m_SilkScreenColorTop.b );
 
  m_materials.m_SilkSTop.m_Specular = SFVEC3F(
  m_boardAdapter.m_SilkScreenColorTop.r * m_boardAdapter.m_SilkScreenColorTop.r +
  0.10f,
  m_boardAdapter.m_SilkScreenColorTop.g * m_boardAdapter.m_SilkScreenColorTop.g +
  0.10f,
  m_boardAdapter.m_SilkScreenColorTop.b * m_boardAdapter.m_SilkScreenColorTop.b +
  0.10f );
 
  m_materials.m_SilkSTop.m_Shininess = 0.078125f * 128.0f;
  m_materials.m_SilkSTop.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
 
  // Silk screen material mixed with silk screen color
  m_materials.m_SilkSBot.m_Ambient = SFVEC3F( m_boardAdapter.m_SilkScreenColorBot.r,
  m_boardAdapter.m_SilkScreenColorBot.g,
  m_boardAdapter.m_SilkScreenColorBot.b );
 
  m_materials.m_SilkSBot.m_Specular = SFVEC3F(
  m_boardAdapter.m_SilkScreenColorBot.r * m_boardAdapter.m_SilkScreenColorBot.r +
  0.10f,
  m_boardAdapter.m_SilkScreenColorBot.g * m_boardAdapter.m_SilkScreenColorBot.g +
  0.10f,
  m_boardAdapter.m_SilkScreenColorBot.b * m_boardAdapter.m_SilkScreenColorBot.b +
  0.10f );
 
  m_materials.m_SilkSBot.m_Shininess = 0.078125f * 128.0f;
  m_materials.m_SilkSBot.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
 
  m_materials.m_SolderMask.m_Shininess = 0.8f * 128.0f;
  m_materials.m_SolderMask.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
 
  // Epoxy material
  m_materials.m_EpoxyBoard.m_Ambient = SFVEC3F( 117.0f / 255.0f, 97.0f / 255.0f,
  47.0f / 255.0f );
 
  m_materials.m_EpoxyBoard.m_Specular = SFVEC3F( 18.0f / 255.0f, 3.0f / 255.0f,
  20.0f / 255.0f );
 
  m_materials.m_EpoxyBoard.m_Shininess = 0.1f * 128.0f;
  m_materials.m_EpoxyBoard.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
  }
  else // Technical Mode
  {
  const SFVEC3F matAmbientColor = SFVEC3F( 0.10f );
  const SFVEC3F matSpecularColor = SFVEC3F( 0.10f );
  const float matShininess = 0.1f * 128.0f;
 
  // Copper material
  m_materials.m_Copper.m_Ambient = matAmbientColor;
  m_materials.m_Copper.m_Specular = matSpecularColor;
  m_materials.m_Copper.m_Shininess = matShininess;
  m_materials.m_Copper.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
 
  // Paste material
  m_materials.m_Paste.m_Ambient = matAmbientColor;
  m_materials.m_Paste.m_Specular = matSpecularColor;
  m_materials.m_Paste.m_Shininess = matShininess;
  m_materials.m_Paste.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
 
  // Silk screen material
  m_materials.m_SilkSTop.m_Ambient = matAmbientColor;
  m_materials.m_SilkSTop.m_Specular = matSpecularColor;
  m_materials.m_SilkSTop.m_Shininess = matShininess;
  m_materials.m_SilkSTop.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
 
  // Silk screen material
  m_materials.m_SilkSBot.m_Ambient = matAmbientColor;
  m_materials.m_SilkSBot.m_Specular = matSpecularColor;
  m_materials.m_SilkSBot.m_Shininess = matShininess;
  m_materials.m_SilkSBot.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
 
  // Solder mask material
  m_materials.m_SolderMask.m_Ambient = matAmbientColor;
  m_materials.m_SolderMask.m_Specular = matSpecularColor;
  m_materials.m_SolderMask.m_Shininess = matShininess;
  m_materials.m_SolderMask.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
 
  // Epoxy material
  m_materials.m_EpoxyBoard.m_Ambient = matAmbientColor;
  m_materials.m_EpoxyBoard.m_Specular = matSpecularColor;
  m_materials.m_EpoxyBoard.m_Shininess = matShininess;
  m_materials.m_EpoxyBoard.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
 
  // Gray material (used for example in technical vias and pad holes)
  m_materials.m_GrayMaterial.m_Ambient = SFVEC3F( 0.8f, 0.8f, 0.8f );
  m_materials.m_GrayMaterial.m_Diffuse = SFVEC3F( 0.3f, 0.3f, 0.3f );
  m_materials.m_GrayMaterial.m_Specular = SFVEC3F( 0.4f, 0.4f, 0.4f );
  m_materials.m_GrayMaterial.m_Shininess = 0.01f * 128.0f;
  m_materials.m_GrayMaterial.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
  }
 }

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.

 {
  glDisable( GL_POLYGON_OFFSET_FILL );
 }

Referenced by Redraw().

Member Data Documentation

◆ m_3dModelMap

MAP_3DMODEL RENDER_3D_OPENGL::m_3dModelMap

private

Definition at line 211 of file render_3d_opengl.h.

Referenced by freeAllLists(), load3dModels(), Load3dModelsIfNeeded(), RENDER_3D_OPENGL(), and renderFootprint().

◆ m_antiBoard

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_antiBoard

private

Definition at line 197 of file render_3d_opengl.h.

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

◆ m_antiBoardPolys

SHAPE_POLY_SET RENDER_3D_OPENGL::m_antiBoardPolys

private

The negative polygon representation of the board outline.

Definition at line 215 of file render_3d_opengl.h.

Referenced by generateViasAndPads(), and reload().

◆ m_board

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_board

private

Definition at line 195 of file render_3d_opengl.h.

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

◆ m_boardAdapter

BOARD_ADAPTER& RENDER_3D_BASE::m_boardAdapter

protectedinherited

Definition at line 105 of file render_3d_base.h.

◆ m_boardWithHoles

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_boardWithHoles

private

Definition at line 196 of file render_3d_opengl.h.

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

◆ m_camera

CAMERA& RENDER_3D_BASE::m_camera

protectedinherited

Flag if the opengl specific for this render was already initialized.

Definition at line 107 of file render_3d_base.h.

Referenced by Redraw(), RENDER_3D_RAYTRACE::Redraw(), RENDER_3D_RAYTRACE::Reload(), reload(), RENDER_3D_RAYTRACE::render(), render3dArrows(), RENDER_3D_RAYTRACE::renderBlockTracing(), RENDER_3D_RAYTRACE::renderPreview(), and renderSolderMaskLayer().

◆ 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

Definition at line 203 of file render_3d_opengl.h.

Referenced by createBoard(), generateHoles(), generateLayerList(), generateViasAndPads(), initializeOpenGL(), RENDER_3D_OPENGL(), and ~RENDER_3D_OPENGL().

◆ m_Copper

SMATERIAL RENDER_3D_OPENGL::m_Copper

Definition at line 185 of file render_3d_opengl.h.

◆ m_currentRollOverItem

BOARD_ITEM* RENDER_3D_OPENGL::m_currentRollOverItem

private

Definition at line 213 of file render_3d_opengl.h.

Referenced by render3dModelsSelected(), RENDER_3D_OPENGL(), and SetCurrentRollOverItem().

◆ m_EpoxyBoard

SMATERIAL RENDER_3D_OPENGL::m_EpoxyBoard

Definition at line 183 of file render_3d_opengl.h.

◆ m_GrayMaterial

SMATERIAL RENDER_3D_OPENGL::m_GrayMaterial

Definition at line 187 of file render_3d_opengl.h.

◆ m_grid

GLuint RENDER_3D_OPENGL::m_grid

private

oGL list that stores current grid

Definition at line 205 of file render_3d_opengl.h.

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

◆ m_innerLayerHoles

MAP_OGL_DISP_LISTS RENDER_3D_OPENGL::m_innerLayerHoles

private

Definition at line 194 of file render_3d_opengl.h.

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

◆ m_is_opengl_initialized

bool RENDER_3D_BASE::m_is_opengl_initialized

protectedinherited

Todo:: This must be reviewed in order to flag change types.

Definition at line 110 of file render_3d_base.h.

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

◆ m_lastGridType

GRID3D_TYPE RENDER_3D_OPENGL::m_lastGridType

private

Stores the last grid type.

Definition at line 206 of file render_3d_opengl.h.

Referenced by Redraw(), and RENDER_3D_OPENGL().

◆ m_layers

MAP_OGL_DISP_LISTS RENDER_3D_OPENGL::m_layers

private

Definition at line 190 of file render_3d_opengl.h.

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

◆ m_materials

struct { ... } RENDER_3D_OPENGL::m_materials

Referenced by Redraw(), renderBoardBody(), setCopperMaterial(), setLayerMaterial(), and setupMaterials().

◆ m_NonPlatedCopper

SMATERIAL RENDER_3D_OPENGL::m_NonPlatedCopper

Definition at line 184 of file render_3d_opengl.h.

◆ m_outerLayerHoles

MAP_OGL_DISP_LISTS RENDER_3D_OPENGL::m_outerLayerHoles

private

Definition at line 193 of file render_3d_opengl.h.

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

◆ m_outerThroughHoleRings

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_outerThroughHoleRings

private

Definition at line 200 of file render_3d_opengl.h.

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

◆ m_outerThroughHoles

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_outerThroughHoles

private

Definition at line 198 of file render_3d_opengl.h.

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

◆ m_outerViaThroughHoles

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_outerViaThroughHoles

private

Definition at line 199 of file render_3d_opengl.h.

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

◆ m_padHoles

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_padHoles

private

Definition at line 209 of file render_3d_opengl.h.

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

◆ m_Paste

SMATERIAL RENDER_3D_OPENGL::m_Paste

Definition at line 179 of file render_3d_opengl.h.

◆ m_Plastic

SMATERIAL RENDER_3D_OPENGL::m_Plastic

Definition at line 186 of file render_3d_opengl.h.

◆ m_platedPadsBack

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_platedPadsBack

private

Definition at line 192 of file render_3d_opengl.h.

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

◆ m_platedPadsFront

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_platedPadsFront

private

Definition at line 191 of file render_3d_opengl.h.

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

◆ m_reloadRequested

bool RENDER_3D_BASE::m_reloadRequested

protectedinherited

The window size that this camera is working.

Definition at line 113 of file render_3d_base.h.

Referenced by RENDER_3D_BASE::IsReloadRequestPending(), Redraw(), RENDER_3D_RAYTRACE::Redraw(), RENDER_3D_RAYTRACE::Reload(), reload(), RENDER_3D_BASE::ReloadRequest(), and RENDER_3D_BASE::RENDER_3D_BASE().

◆ m_SilkSBot

SMATERIAL RENDER_3D_OPENGL::m_SilkSBot

Definition at line 180 of file render_3d_opengl.h.

◆ m_SilkSTop

SMATERIAL RENDER_3D_OPENGL::m_SilkSTop

Definition at line 181 of file render_3d_opengl.h.

◆ m_SolderMask

SMATERIAL RENDER_3D_OPENGL::m_SolderMask

Definition at line 182 of file render_3d_opengl.h.

◆ m_triangles

LIST_TRIANGLES RENDER_3D_OPENGL::m_triangles

private

store pointers so can be deleted latter

Definition at line 202 of file render_3d_opengl.h.

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

◆ m_vias

OPENGL_RENDER_LIST* RENDER_3D_OPENGL::m_vias

private

Definition at line 208 of file render_3d_opengl.h.

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

◆ m_windowSize

wxSize RENDER_3D_BASE::m_windowSize

protectedinherited

Definition at line 116 of file render_3d_base.h.

Referenced by RENDER_3D_RAYTRACE::initializeBlockPositions(), Redraw(), RENDER_3D_RAYTRACE::Redraw(), render3dArrows(), RENDER_3D_BASE::RENDER_3D_BASE(), RENDER_3D_RAYTRACE::renderBlockTracing(), RENDER_3D_RAYTRACE::renderPreview(), SetCurWindowSize(), and RENDER_3D_RAYTRACE::SetCurWindowSize().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RENDER_3D_OPENGL()

◆ ~RENDER_3D_OPENGL()

Member Function Documentation

◆ addObjectTriangles() [1/5]

◆ addObjectTriangles() [2/5]

◆ addObjectTriangles() [3/5]

◆ addObjectTriangles() [4/5]

◆ addObjectTriangles() [5/5]

◆ addTopAndBottomTriangles()

◆ createBoard()

◆ CreateBusyIndicator()

◆ freeAllLists()

◆ generate3dGrid()

◆ generateCylinder()

◆ generateHoles()

◆ generateLayerList()

◆ generateRing()

◆ generateViasAndPads()

◆ getLayerColor()

◆ getLayerZPos()

◆ GetWaitForEditingTimeOut()

◆ initializeOpenGL()

◆ IsReloadRequestPending()

◆ load3dModels()

◆ Load3dModelsIfNeeded()

◆ Redraw()

◆ reload()

◆ ReloadRequest()

◆ render3dArrows()

◆ render3dModels()

◆ render3dModelsSelected()

◆ renderBoardBody()

◆ renderFootprint()

◆ renderSolderMaskLayer()

◆ setArrowMaterial()

◆ SetBusyIndicatorFactory()

◆ setCopperMaterial()

◆ SetCurrentRollOverItem()

◆ SetCurWindowSize()

◆ setLayerMaterial()

◆ setLightBottom()

◆ setLightFront()

◆ setLightTop()

◆ setPlatedCopperAndDepthOffset()

◆ setupMaterials()

◆ unsetDepthOffset()

Member Data Documentation

◆ m_3dModelMap

◆ m_antiBoard

◆ m_antiBoardPolys

◆ m_board

◆ m_boardAdapter

◆ m_boardWithHoles

◆ m_camera

◆ m_canvas

◆ m_circleTexture

◆ m_Copper

◆ m_currentRollOverItem

◆ m_EpoxyBoard

◆ m_GrayMaterial

◆ m_grid

◆ m_innerLayerHoles

◆ m_is_opengl_initialized

◆ m_lastGridType

◆ m_layers

◆ m_materials

◆ m_NonPlatedCopper

◆ m_outerLayerHoles

◆ m_outerThroughHoleRings

◆ m_outerThroughHoles

◆ m_outerViaThroughHoles

◆ m_padHoles