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)

OPENGL_RENDER_LIST *	generateEmptyLayerList (PCB_LAYER_ID aLayerId)

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

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

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

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

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

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

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

void	renderBoardBody (bool aSkipRenderHoles)

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

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

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

void	generateViasAndPads ()

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

void	render3dModels (bool aRenderTopOrBot, bool aRenderTransparentOnly)

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

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

void	setLightFront (bool enabled)

void	setLightTop (bool enabled)

void	setLightBottom (bool enabled)

void	render3dArrows ()

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

void	setupMaterials ()

void	setCopperMaterial ()

void	setPlatedCopperAndDepthOffset (PCB_LAYER_ID aLayer_id)

void	unsetDepthOffset ()

void	setLayerMaterial (PCB_LAYER_ID aLayerID)

SFVEC4F	getLayerColor (PCB_LAYER_ID aLayerID)

bool	initializeOpenGL ()

OPENGL_RENDER_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

std::map< wxString, MODEL_3D * >	m_3dModelMap

std::map< std::vector< double >, glm::mat4 >	m_3dModelMatrixMap

BOARD_ITEM *	m_currentRollOverItem

SHAPE_POLY_SET	m_antiBoardPolys
	The negative polygon representation of the board outline. More...

BUSY_INDICATOR::FACTORY	m_busyIndicatorFactory
	< Factory that returns a suitable busy indicator for the context. More...

Detailed Description

Object to render the board using openGL.

Definition at line 52 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 FILLED_CIRCLE_2D *	aFilledCircle,
		TRIANGLE_DISPLAY_LIST *	aDstLayer,
		float	aZtop,
		float	aZbot
	)

private

Definition at line 38 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() [2/5]

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

private

Definition at line 68 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(), v1, v2, and v3.

◆ addObjectTriangles() [3/5]

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

private

Definition at line 116 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() [4/5]

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

private

Definition at line 162 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 ) );
}

◆ addObjectTriangles() [5/5]

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

private

Definition at line 150 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(), v1, v2, and v3.

◆ 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 691 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, v1, v2, VECTOR2< T >::x, VECTOR3< T >::x, VECTOR2< T >::y, and VECTOR3< 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 394 of file opengl/create_scene.cpp.

{
 OPENGL_RENDER_LIST* dispLists = nullptr;
 CONTAINER_2D boardContainer;
 
 ConvertPolygonToTriangles( aBoardPoly, 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(), TRIANGLE_2D::GetP1(), TRIANGLE_2D::GetP2(), TRIANGLE_2D::GetP3(), RENDER_3D_BASE::m_boardAdapter, m_circleTexture, SHAPE_POLY_SET::OutlineCount(), TRIANGLE, v1, v2, and v3.

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 display 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 1018 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( const std::pair<const PCB_LAYER_ID, OPENGL_RENDER_LIST*> entry : m_outerLayerHoles )
 delete entry.second;
 
 m_outerLayerHoles.clear();
 
 for( const std::pair<const PCB_LAYER_ID, OPENGL_RENDER_LIST*> entry : m_innerLayerHoles )
 delete entry.second;
 
 m_innerLayerHoles.clear();
 
 for( LIST_TRIANGLES::const_iterator ii = m_triangles.begin(); ii != m_triangles.end(); ++ii )
 delete *ii;
 
 m_triangles.clear();
 
 for( const std::pair<const wxString, MODEL_3D*>& entry : m_3dModelMap )
 delete entry.second;
 
 m_3dModelMap.clear();
 
 m_3dModelMatrixMap.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_3dModelMatrixMap, 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 1310 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 VECTOR2I brd_size = m_boardAdapter.GetBoardSize();
 VECTOR2I brd_center_pos = m_boardAdapter.GetBoardPos();
 
 brd_center_pos.y = -brd_center_pos.y;
 
 const int xsize = std::max( brd_size.x, pcbIUScale.mmToIU( 100 ) ) * 1.2;
 const int ysize = std::max( brd_size.y, pcbIUScale.mmToIU( 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 = pcbIUScale.mmToIU( -50 ) * scale;
 double zmax = pcbIUScale.mmToIU( 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 * pcbIUScale.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 * pcbIUScale.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 * pcbIUScale.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, EDA_IU_SCALE::IU_PER_MM, KiROUND(), LIGHTBLUE, RENDER_3D_BASE::m_boardAdapter, m_grid, EDA_IU_SCALE::mmToIU(), NONE, pcbIUScale, scale, VECTOR2< T >::x, and VECTOR2< T >::y.

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 719 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().

◆ generateEmptyLayerList()

OPENGL_RENDER_LIST * RENDER_3D_OPENGL::generateEmptyLayerList ( PCB_LAYER_ID aLayerId )

private

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

{
 float layer_z_bot = 0.0f;
 float layer_z_top = 0.0f;
 
 getLayerZPos( aLayerId, layer_z_top, layer_z_bot );
 
 TRIANGLE_DISPLAY_LIST* layerTriangles = new TRIANGLE_DISPLAY_LIST( 1 );
 
 // store in a list so it will be latter deleted
 m_triangles.push_back( layerTriangles );
 
 return new OPENGL_RENDER_LIST( *layerTriangles, m_circleTexture, layer_z_bot, layer_z_top );
}

References getLayerZPos(), m_circleTexture, and m_triangles.

Referenced by reload().

◆ generateHoles()

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

private

Definition at line 247 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( wxT( "RENDER_3D_OPENGL::generateHoles: Object type 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 303 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( wxT( "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 82 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 753 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 )
 {
 float averageDiameter = m_boardAdapter.GetAverageViaHoleDiameter();
 unsigned int averageSegCount = m_boardAdapter.GetCircleSegmentCount( averageDiameter );
 unsigned int trianglesEstimate = averageSegCount * 8 * m_boardAdapter.GetViaCount();
 
 TRIANGLE_DISPLAY_LIST* layerTriangleVIA = new TRIANGLE_DISPLAY_LIST( trianglesEstimate );
 
 // 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 VECTOR2I drillsize = pad->GetDrillSize();
 const bool hasHole = drillsize.x && drillsize.y;
 
 if( !hasHole )
 continue;
 
 pad->TransformHoleToPolygon( tht_outer_holes_poly, platingThickness,
 ARC_HIGH_DEF, ERROR_INSIDE );
 pad->TransformHoleToPolygon( 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.m_Cfg->m_Render.realistic )
 tht_outer_holes_poly.BooleanSubtract( m_antiBoardPolys, SHAPE_POLY_SET::PM_FAST );
 
 CONTAINER_2D holesContainer;
 
 ConvertPolygonToTriangles( tht_outer_holes_poly, holesContainer,
 m_boardAdapter.BiuTo3dUnits(), *m_boardAdapter.GetBoard() );
 
 const LIST_OBJECT2D& holes2D = holesContainer.GetList();
 
 if( holes2D.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( holes2D.size() );
 
 // Convert the list of objects(triangles) to triangle layer structure
 for( const OBJECT_2D* itemOnLayer : holes2D )
 {
 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(), ARC_HIGH_DEF, B_Cu, BOARD_ADAPTER::BiuTo3dUnits(), SHAPE_POLY_SET::BooleanSubtract(), ConvertPolygonToTriangles(), dummy, ERROR_INSIDE, F_Cu, BOARD::Footprints(), generateCylinder(), BOARD_ADAPTER::GetAverageViaHoleDiameter(), BOARD_ADAPTER::GetBoard(), BOARD_ADAPTER::GetCircleSegmentCount(), BOARD_ADAPTER::GetHoleCount(), BOARD_ADAPTER::GetHolePlatingThickness(), getLayerZPos(), CONTAINER_2D_BASE::GetList(), OBJECT_2D::GetObjectType(), TRIANGLE_2D::GetP1(), TRIANGLE_2D::GetP2(), TRIANGLE_2D::GetP3(), BOARD_ADAPTER::GetViaCount(), m_antiBoardPolys, RENDER_3D_BASE::m_boardAdapter, BOARD_ADAPTER::m_Cfg, m_circleTexture, m_padHoles, EDA_3D_VIEWER_SETTINGS::m_Render, m_vias, NPTH, SHAPE_POLY_SET::OutlineCount(), pad, PCB_VIA_T, SHAPE_POLY_SET::PM_FAST, EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::realistic, SHAPE_POLY_SET::RemoveAllContours(), BOARD::Tracks(), TRIANGLE, v1, v2, v3, via, VECTOR2< T >::x, and VECTOR2< T >::y.

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.m_Cfg->m_Render.realistic )
 {
 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, BOARD_ADAPTER::GetLayerColor(), RENDER_3D_BASE::m_boardAdapter, BOARD_ADAPTER::m_Cfg, BOARD_ADAPTER::m_CopperColor, EDA_3D_VIEWER_SETTINGS::m_Render, BOARD_ADAPTER::m_SilkScreenColorBot, BOARD_ADAPTER::m_SilkScreenColorTop, BOARD_ADAPTER::m_SolderMaskColorBot, BOARD_ADAPTER::m_SolderMaskColorTop, BOARD_ADAPTER::m_SolderPasteColor, Margin, and EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::realistic.

Referenced by setLayerMaterial().

◆ getLayerZPos()

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

private

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

{
 aOutZbot = m_boardAdapter.GetLayerBottomZPos( aLayer );
 aOutZtop = m_boardAdapter.GetLayerTopZPos( aLayer );
 
 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 generateEmptyLayerList(), generateLayerList(), generateViasAndPads(), and reload().

◆ GetWaitForEditingTimeOut()

int RENDER_3D_OPENGL::GetWaitForEditingTimeOut ( )

overridevirtual

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

Returns: a value in milliseconds

Implements RENDER_3D_BASE.

Definition at line 84 of file render_3d_opengl.cpp.

{
 return 50; // ms
}

◆ initializeOpenGL()

bool RENDER_3D_OPENGL::initializeOpenGL ( )

private

Definition at line 956 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 910 of file opengl/create_scene.cpp.

{
 if( !m_boardAdapter.GetBoard() )
 return;
 
 if( !m_boardAdapter.m_Cfg->m_Render.show_footprints_normal
 && !m_boardAdapter.m_Cfg->m_Render.show_footprints_insert
 && !m_boardAdapter.m_Cfg->m_Render.show_footprints_virtual )
 {
 return;
 }
 
 // Go for all footprints
 for( const FOOTPRINT* footprint : m_boardAdapter.GetBoard()->Footprints() )
 {
 wxString libraryName = footprint->GetFPID().GetLibNickname();
 wxString footprintBasePath = wxEmptyString;
 
 if( m_boardAdapter.GetBoard()->GetProject() )
 {
 try
 {
 // FindRow() can throw an exception
 const FP_LIB_TABLE_ROW* fpRow =
 m_boardAdapter.GetBoard()->GetProject()->PcbFootprintLibs()->FindRow(
 libraryName, false );
 
 if( fpRow )
 footprintBasePath = fpRow->GetFullURI( true );
 }
 catch( ... )
 {
 // Do nothing if the libraryName is not found in lib table
 }
 }
 
 for( const FP_3DMODEL& fp_model : footprint->Models() )
 {
 if( fp_model.m_Show && !fp_model.m_Filename.empty() )
 {
 if( aStatusReporter )
 {
 // Display the short filename of the 3D fp_model loaded:
 // (the full name is usually too long to be displayed)
 wxFileName fn( fp_model.m_Filename );
 aStatusReporter->Report( wxString::Format( _( "Loading %s..." ),
 fn.GetFullName() ) );
 }
 
 // Check if the fp_model is not present in our cache map
 // (Not already loaded in memory)
 if( m_3dModelMap.find( fp_model.m_Filename ) == m_3dModelMap.end() )
 {
 // It is not present, try get it from cache
 const S3DMODEL* modelPtr =
 m_boardAdapter.Get3dCacheManager()->GetModel( fp_model.m_Filename, footprintBasePath );
 
 // only add it if the return is not NULL
 if( modelPtr )
 {
 MATERIAL_MODE materialMode = m_boardAdapter.m_Cfg->m_Render.material_mode;
 MODEL_3D* model = new MODEL_3D( *modelPtr, materialMode );
 
 m_3dModelMap[ fp_model.m_Filename ] = model;
 }
 }
 }
 }
 }
}

References _, FP_LIB_TABLE::FindRow(), BOARD::Footprints(), Format(), BOARD_ADAPTER::Get3dCacheManager(), BOARD_ADAPTER::GetBoard(), LIB_TABLE_ROW::GetFullURI(), S3D_CACHE::GetModel(), BOARD::GetProject(), m_3dModelMap, RENDER_3D_BASE::m_boardAdapter, BOARD_ADAPTER::m_Cfg, EDA_3D_VIEWER_SETTINGS::m_Render, EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::material_mode, PROJECT::PcbFootprintLibs(), REPORTER::Report(), EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::show_footprints_insert, EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::show_footprints_normal, and EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::show_footprints_virtual.

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 892 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 = static_cast<GRID3D_TYPE>( m_boardAdapter.m_Cfg->m_Render.grid_type );
 generate3dGrid( m_lastGridType );
 }
 else
 {
 // Check if grid was changed
 if( m_boardAdapter.m_Cfg->m_Render.grid_type != m_lastGridType )
 {
 // and generate a new one
 m_lastGridType = static_cast<GRID3D_TYPE>( m_boardAdapter.m_Cfg->m_Render.grid_type );
 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( aIsMoving && m_boardAdapter.m_Cfg->m_Render.opengl_AA_disableOnMove )
 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 );
 }
 
 bool skipThickness = aIsMoving && m_boardAdapter.m_Cfg->m_Render.opengl_thickness_disableOnMove;
 bool skipRenderHoles = aIsMoving && m_boardAdapter.m_Cfg->m_Render.opengl_holes_disableOnMove;
 bool skipRenderVias = aIsMoving && m_boardAdapter.m_Cfg->m_Render.opengl_vias_disableOnMove;
 
 bool drawMiddleSegments = !skipThickness;
 
 if( m_boardAdapter.m_Cfg->m_Render.realistic )
 {
 // 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.m_Cfg->m_Render.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.m_Cfg->m_Render.renderPlatedPadsAsPlated
 && m_boardAdapter.m_Cfg->m_Render.realistic )
 {
 setCopperMaterial();
 }
 else
 {
 setLayerMaterial( layer_id );
 }
 
 if( skipRenderHoles )
 {
 pLayerDispList->DrawAllCameraCulled( m_camera.GetPos().z, drawMiddleSegments );
 
 // Draw plated pads
 if( layer_id == F_Cu && m_platedPadsFront )
 {
 setPlatedCopperAndDepthOffset( layer_id );
 m_platedPadsFront->DrawAllCameraCulled( m_camera.GetPos().z,
 drawMiddleSegments );
 }
 else if( layer_id == B_Cu && m_platedPadsBack )
 {
 setPlatedCopperAndDepthOffset( layer_id );
 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 plated pads
 if( layer_id == F_Cu && m_platedPadsFront )
 {
 setPlatedCopperAndDepthOffset( layer_id );
 m_platedPadsFront->DrawAllCameraCulledSubtractLayer(
 drawMiddleSegments,
 m_outerThroughHoles,
 viasHolesLayer,
 m_antiBoard );
 }
 else if( layer_id == B_Cu && m_platedPadsBack )
 {
 setPlatedCopperAndDepthOffset( layer_id );
 m_platedPadsBack->DrawAllCameraCulledSubtractLayer(
 drawMiddleSegments,
 m_outerThroughHoles,
 viasHolesLayer,
 m_antiBoard );
 }
 
 unsetDepthOffset();
 }
 }
 else
 {
 pLayerDispList->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
 m_outerThroughHoles,
 m_antiBoard );
 
 if( layer_id == F_Cu && m_platedPadsFront )
 {
 setPlatedCopperAndDepthOffset( layer_id );
 m_platedPadsFront->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
 m_outerThroughHoles,
 m_antiBoard );
 }
 else if( layer_id == B_Cu && m_platedPadsBack )
 {
 setPlatedCopperAndDepthOffset( layer_id );
 m_platedPadsBack->DrawAllCameraCulledSubtractLayer( drawMiddleSegments,
 m_outerThroughHoles,
 m_antiBoard );
 }
 
 unsetDepthOffset();
 }
 }
 }
 else
 {
 setLayerMaterial( layer_id );
 
 OPENGL_RENDER_LIST* throughHolesOuter =
 m_boardAdapter.m_Cfg->m_Render.clip_silk_on_via_annulus
 && m_boardAdapter.m_Cfg->m_Render.realistic
 && ( 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.m_Cfg->m_Render.subtract_mask_from_silk
 && m_boardAdapter.m_Cfg->m_Render.realistic
 && ( ( 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.m_Cfg->m_Render.show_board_body )
 renderBoardBody( skipRenderHoles );
 
 // Display transparent mask layers
 if( m_boardAdapter.m_Cfg->m_Render.show_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 );
 glBindTexture( GL_TEXTURE_2D, m_circleTexture ); // Uses an existent texture so the glTexEnv operations will work
 
 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_SRC_ALPHA );
 
 render3dModels( false, true );
 render3dModels( true, true );
 
 glDisable( GL_BLEND );
 OglResetTextureState();
 
 glDepthMask( GL_TRUE );
 
 // Render Grid
 if( m_boardAdapter.m_Cfg->m_Render.grid_type != GRID3D_TYPE::NONE )
 {
 glDisable( GL_LIGHTING );
 
 if( glIsList( m_grid ) )
 glCallList( m_grid );
 
 glEnable( GL_LIGHTING );
 }
 
 // Render 3D arrows
 if( m_boardAdapter.m_Cfg->m_Render.show_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;
}

◆ reload()

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

private

Definition at line 448 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.m_Cfg->m_Render.realistic )
 {
 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().CloneDropTriangulation();
 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().CloneDropTriangulation();
 
 if( m_boardAdapter.m_Cfg->m_Render.realistic )
 {
 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.m_Cfg->m_Render.clip_silk_on_via_annulus &&
 m_boardAdapter.m_Cfg->m_Render.realistic )
 {
 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 std::pair<const PCB_LAYER_ID, SHAPE_POLY_SET*>& 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 std::pair<const PCB_LAYER_ID, SHAPE_POLY_SET*>& 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 std::pair<const PCB_LAYER_ID, BVH_CONTAINER_2D*>& 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* polyList = 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.m_Cfg->m_Render.realistic )
 {
 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.m_Cfg->m_Render.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 );
 }
 }
 }
 
 polyList = &polyListSubtracted;
 }
 
 OPENGL_RENDER_LIST* oglList = generateLayerList( container2d, polyList, layer_id,
 &m_boardAdapter.GetThroughHoleIds() );
 
 if( oglList != nullptr )
 m_layers[layer_id] = oglList;
 
 }
 
 if( m_boardAdapter.m_Cfg->m_Render.renderPlatedPadsAsPlated
 && m_boardAdapter.m_Cfg->m_Render.realistic )
 {
 const SHAPE_POLY_SET* frontPlatedPadPolys = m_boardAdapter.GetFrontPlatedPadPolys();
 const SHAPE_POLY_SET* backPlatedPadPolys = m_boardAdapter.GetBackPlatedPadPolys();
 
 if( frontPlatedPadPolys )
 {
 SHAPE_POLY_SET polySubtracted = frontPlatedPadPolys->CloneDropTriangulation();
 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 );
 
 // An entry for F_Cu must exist in m_layers or we'll never look at m_platedPadsFront
 if( m_layers.count( F_Cu ) == 0 )
 m_layers[F_Cu] = generateEmptyLayerList( F_Cu );
 }
 
 if( backPlatedPadPolys )
 {
 SHAPE_POLY_SET polySubtracted = backPlatedPadPolys->CloneDropTriangulation();
 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 );
 
 // An entry for B_Cu must exist in m_layers or we'll never look at m_platedPadsBack
 if( m_layers.count( B_Cu ) == 0 )
 m_layers[B_Cu] = generateEmptyLayerList( B_Cu );
 }
 }
 
 // Load 3D models
 if( aStatusReporter )
 aStatusReporter->Report( _( "Loading 3D models..." ) );
 
 load3dModels( aStatusReporter );
 
 if( aStatusReporter )
 {
 // Calculation time in seconds
 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; }

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 1188 of file render_3d_opengl.cpp.

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

References RENDER_3D_BASE::m_boardAdapter, BOARD_ADAPTER::m_IsBoardView, and render3dModelsSelected().

Referenced by Redraw().

◆ render3dModelsSelected()

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

private

Definition at line 1146 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.m_IsBoardView )
 {
 if( fp->IsSelected() )
 highlight = true;
 
 if( m_boardAdapter.m_Cfg->m_Render.opengl_highlight_on_rollover
 && 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(), BOARD::Footprints(), BOARD_ADAPTER::GetBoard(), BOARD_ADAPTER::IsFootprintShown(), RENDER_3D_BASE::m_boardAdapter, BOARD_ADAPTER::m_Cfg, m_currentRollOverItem, BOARD_ADAPTER::m_IsBoardView, EDA_3D_VIEWER_SETTINGS::m_Render, EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::opengl_highlight_on_rollover, 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.GetBoardBodyThickness() / 2.0f,
 m_boardAdapter.GetBoardBodyThickness() );
 
 ogl_disp_list->SetItIsTransparent( true );
 
 ogl_disp_list->DrawAll();
 }
}

References OPENGL_RENDER_LIST::ApplyScalePosition(), OPENGL_RENDER_LIST::DrawAll(), BOARD_ADAPTER::GetBoardBodyThickness(), 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 1197 of file render_3d_opengl.cpp.

{
 if( !aFootprint->Models().empty() )
 {
 const double zpos = m_boardAdapter.GetFootprintZPos( aFootprint->IsFlipped() );
 SFVEC3F selColor = m_boardAdapter.GetColor( m_boardAdapter.m_Cfg->m_Render.opengl_selection_color );
 
 
 glPushMatrix();
 
 VECTOR2I pos = aFootprint->GetPosition();
 
 glTranslatef( pos.x * m_boardAdapter.BiuTo3dUnits(), -pos.y * m_boardAdapter.BiuTo3dUnits(),
 zpos );
 
 if( !aFootprint->GetOrientation().IsZero() )
 glRotated( aFootprint->GetOrientation().AsDegrees(), 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();
 
 std::vector<double> key = { sM.m_Offset.x, sM.m_Offset.y, sM.m_Offset.z,
 sM.m_Rotation.x, sM.m_Rotation.y, sM.m_Rotation.z,
 sM.m_Scale.x, sM.m_Scale.y, sM.m_Scale.z };
 
 auto it = m_3dModelMatrixMap.find( key );
 
 if( it != m_3dModelMatrixMap.end() )
 {
 glMultMatrixf( glm::value_ptr( it->second ) );
 }
 else
 {
 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 } );
 m_3dModelMatrixMap[ key ] = mtx;
 
 glMultMatrixf( glm::value_ptr( mtx ) );
 }
 
 
 if( aRenderTransparentOnly )
 {
 modelPtr->DrawTransparent( sM.m_Opacity,
 aFootprint->IsSelected() || aIsSelected,
 selColor );
 }
 else
 {
 modelPtr->DrawOpaque( aFootprint->IsSelected() || aIsSelected, selColor );
 }
 
 if( m_boardAdapter.m_Cfg->m_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 EDA_ANGLE::AsDegrees(), BOARD_ADAPTER::BiuTo3dUnits(), BOARD_ADAPTER::GetColor(), BOARD_ADAPTER::GetFootprintZPos(), FOOTPRINT::GetOrientation(), FOOTPRINT::GetPosition(), FOOTPRINT::IsFlipped(), EDA_ITEM::IsSelected(), EDA_ANGLE::IsZero(), m_3dModelMap, m_3dModelMatrixMap, RENDER_3D_BASE::m_boardAdapter, BOARD_ADAPTER::m_Cfg, EDA_3D_VIEWER_SETTINGS::m_Render, FOOTPRINT::Models(), EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::opengl_selection_color, EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::opengl_show_model_bbox, scale, UNITS3D_TO_UNITSPCB, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by render3dModelsSelected().

◆ renderSolderMaskLayer()

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

private

Definition at line 1088 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 999 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 64 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.m_Cfg->m_Render.realistic )
 {
 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, getLayerColor(), RENDER_3D_BASE::m_boardAdapter, BOARD_ADAPTER::m_Cfg, m_materials, EDA_3D_VIEWER_SETTINGS::m_Render, Margin, OglSetMaterial(), and EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::realistic.

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.m_Cfg->m_Render.realistic )
 {
 // 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 RENDER_3D_BASE::m_boardAdapter, BOARD_ADAPTER::m_Cfg, BOARD_ADAPTER::m_CopperColor, m_materials, EDA_3D_VIEWER_SETTINGS::m_Render, BOARD_ADAPTER::m_SilkScreenColorBot, BOARD_ADAPTER::m_SilkScreenColorTop, BOARD_ADAPTER::m_SolderPasteColor, mapf(), and EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::realistic.

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

std::map< wxString, MODEL_3D* > RENDER_3D_OPENGL::m_3dModelMap

private

Definition at line 212 of file render_3d_opengl.h.

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

◆ m_3dModelMatrixMap

std::map< std::vector<double>, glm::mat4 > RENDER_3D_OPENGL::m_3dModelMatrixMap

private

Definition at line 213 of file render_3d_opengl.h.

Referenced by freeAllLists(), 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 217 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_busyIndicatorFactory

BUSY_INDICATOR::FACTORY RENDER_3D_BASE::m_busyIndicatorFactory

privateinherited

< Factory that returns a suitable busy indicator for the context.

Definition at line 128 of file render_3d_base.h.

Referenced by RENDER_3D_BASE::CreateBusyIndicator(), and RENDER_3D_BASE::SetBusyIndicatorFactory().

◆ 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(), reload(), RENDER_3D_RAYTRACE::Reload(), RENDER_3D_RAYTRACE::render(), render3dArrows(), RENDER_3D_RAYTRACE::renderBlockTracing(), 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(), generateEmptyLayerList(), generateHoles(), generateLayerList(), generateViasAndPads(), initializeOpenGL(), Redraw(), 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 215 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 initializeOpenGL(), RENDER_3D_RAYTRACE::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().

◆

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(), reload(), RENDER_3D_RAYTRACE::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(), generateEmptyLayerList(), 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(), 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()

◆ generateEmptyLayerList()

◆ 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_3dModelMatrixMap

◆ m_antiBoard

◆ m_antiBoardPolys

◆ m_board

◆ m_boardAdapter

◆ m_boardWithHoles

◆ m_busyIndicatorFactory

◆ 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_NonPlatedCopper

◆ m_outerLayerHoles

◆ m_outerThroughHoleRings