37#include <glm/geometric.hpp>
50#define UNITS3D_TO_UNITSPCB ( pcbIUScale.IU_PER_MM )
56 wxLogTrace(
m_logTrace, wxT(
"RENDER_3D_OPENGL::RENDER_3D_OPENGL" ) );
92 wxLogTrace(
m_logTrace, wxT(
"RENDER_3D_OPENGL::RENDER_3D_OPENGL" ) );
113 int fbWidth, fbHeight;
114 glGetIntegerv( GL_VIEWPORT, viewport );
127 glEnable( GL_LIGHT0 );
129 glDisable( GL_LIGHT0 );
136 glEnable( GL_LIGHT1 );
138 glDisable( GL_LIGHT1 );
145 glEnable( GL_LIGHT2 );
147 glDisable( GL_LIGHT2 );
204 m_materials.m_Copper.m_Shininess = shininessfactor * 128.0f;
213 m_materials.m_NonPlatedCopper.m_Shininess = 0.1f * 128.0f;
241 m_materials.m_SilkSTop.m_Shininess = 0.078125f * 128.0f;
254 m_materials.m_SilkSBot.m_Shininess = 0.078125f * 128.0f;
257 m_materials.m_SolderMask.m_Shininess = 0.8f * 128.0f;
267 m_materials.m_EpoxyBoard.m_Shininess = 0.1f * 128.0f;
297 m_materials.m_SolderMask.m_Transparency = 1.0f - layerColor.a;
357 m_materials.m_Plastic.m_Shininess = 0.078125f * 128.0f;
380 m_materials.m_Plastic.m_Shininess = 0.078125f * 128.0f;
398 const GLfloat ambient[] = { 0.084f, 0.084f, 0.084f, 1.0f };
399 const GLfloat diffuse0[] = { 0.3f, 0.3f, 0.3f, 1.0f };
400 const GLfloat specular0[] = { 0.5f, 0.5f, 0.5f, 1.0f };
402 glLightfv( GL_LIGHT0, GL_AMBIENT, ambient );
403 glLightfv( GL_LIGHT0, GL_DIFFUSE, diffuse0 );
404 glLightfv( GL_LIGHT0, GL_SPECULAR, specular0 );
406 const GLfloat diffuse12[] = { 0.7f, 0.7f, 0.7f, 1.0f };
407 const GLfloat specular12[] = { 0.7f, 0.7f, 0.7f, 1.0f };
410 GLfloat position[4] = { 0.0f, 0.0f, 1.0f, 0.0f };
414 glm::pi<float>() * 0.25f );
416 position[0] = vectorLight.x;
417 position[1] = vectorLight.y;
418 position[2] = vectorLight.z;
420 glLightfv( GL_LIGHT1, GL_AMBIENT, ambient );
421 glLightfv( GL_LIGHT1, GL_DIFFUSE, diffuse12 );
422 glLightfv( GL_LIGHT1, GL_SPECULAR, specular12 );
423 glLightfv( GL_LIGHT1, GL_POSITION, position );
426 position[2] = -position[2];
428 glLightfv( GL_LIGHT2, GL_AMBIENT, ambient );
429 glLightfv( GL_LIGHT2, GL_DIFFUSE, diffuse12 );
430 glLightfv( GL_LIGHT2, GL_SPECULAR, specular12 );
431 glLightfv( GL_LIGHT2, GL_POSITION, position );
433 const GLfloat lmodel_ambient[] = { 0.0f, 0.0f, 0.0f, 1.0f };
435 glLightModelfv( GL_LIGHT_MODEL_AMBIENT, lmodel_ambient );
437 glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE );
449 glEnable( GL_POLYGON_OFFSET_FILL );
450 glPolygonOffset( -0.1f, -2.0f );
457 glDisable( GL_POLYGON_OFFSET_FILL );
472 if( aSkipRenderHoles )
490 return SFVEC4F( aInput.r * aInput.a, aInput.g * aInput.a, aInput.b * aInput.a, aInput.a );
510 if( aStatusReporter )
511 aStatusReporter->
Report(
_(
"Loading..." ) );
518 reload( aStatusReporter, aWarningReporter );
539 glDepthFunc( GL_LESS );
540 glEnable( GL_CULL_FACE );
541 glFrontFace( GL_CCW );
542 glEnable( GL_NORMALIZE );
546 glDisable( GL_MULTISAMPLE );
548 glEnable( GL_MULTISAMPLE );
551 glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
552 glClearDepth( 1.0f );
553 glClearStencil( 0x00 );
554 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
562 glEnable( GL_DEPTH_TEST );
565 glMatrixMode( GL_PROJECTION );
566 glLoadMatrixf( glm::value_ptr(
m_camera.GetProjectionMatrix() ) );
567 glMatrixMode( GL_MODELVIEW );
569 glLoadMatrixf( glm::value_ptr(
m_camera.GetViewMatrix() ) );
576 glEnable( GL_LIGHTING );
585 if( cameraPos.z > 0.0f )
586 zpos = glm::max( cameraPos.z, 0.5f ) + cameraPos.z * cameraPos.z;
588 zpos = glm::min( cameraPos.z,-0.5f ) - cameraPos.z * cameraPos.z;
591 const GLfloat headlight_pos[] = { cameraPos.x, cameraPos.y, zpos, 1.0f };
593 glLightfv( GL_LIGHT0, GL_POSITION, headlight_pos );
599 bool showThickness = !skipThickness;
601 std::bitset<LAYER_3D_END> layerFlags =
m_boardAdapter.GetVisibleLayers();
612 for( MAP_OGL_DISP_LISTS::const_iterator ii =
m_layers.begin(); ii !=
m_layers.end(); ++ii )
626 const double opacity_min = 0.8;
651 if( !skipRenderHoles )
697 if( !skipRenderHoles )
706 anti_board =
nullptr;
713 if( throughHolesOuter )
722 pLayerDispList->
DrawCulled( showThickness, solder_mask, throughHolesOuter, anti_board );
728 glm::mat4 cameraViewMatrix;
730 glGetFloatv( GL_MODELVIEW_MATRIX, glm::value_ptr( cameraViewMatrix ) );
745 glEnable( GL_POLYGON_OFFSET_FILL );
746 glPolygonOffset( 0.0f, -2.0f );
753 showThickness, skipRenderHoles );
759 showThickness, skipRenderHoles );
767 showThickness, skipRenderHoles );
773 showThickness, skipRenderHoles );
777 glDisable( GL_POLYGON_OFFSET_FILL );
778 glPolygonOffset( 0.0f, 0.0f );
784 glDepthMask( GL_FALSE );
785 glEnable( GL_BLEND );
786 glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
789 glEnable( GL_TEXTURE_2D );
790 glActiveTexture( GL_TEXTURE0 );
795 glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE );
796 glTexEnvf( GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE );
797 glTexEnvf( GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE );
799 glTexEnvi( GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PRIMARY_COLOR );
800 glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR );
802 glTexEnvi( GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PREVIOUS );
803 glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR );
805 glTexEnvi( GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PRIMARY_COLOR );
806 glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA );
807 glTexEnvi( GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_CONSTANT );
808 glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA );
812 glDisable( GL_BLEND );
815 glDepthMask( GL_TRUE );
820 glDisable( GL_LIGHTING );
825 glEnable( GL_LIGHTING );
842 glEnable( GL_LINE_SMOOTH );
843 glShadeModel( GL_SMOOTH );
846 glPixelStorei( GL_UNPACK_ALIGNMENT, 4 );
867 delete circleImageBlured;
868 circleImageBlured =
nullptr;
871 circleImage =
nullptr;
885 glEnable( GL_COLOR_MATERIAL );
886 glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
893 glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, &specular.r );
894 glMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, 96.0f );
896 glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, &ambient.r );
897 glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, &diffuse.r );
898 glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, &emissive.r );
904#define DELETE_AND_FREE( ptr ) \
910#define DELETE_AND_FREE_MAP( map ) \
912 for( auto& [ layer, ptr ] : map ) \
919 glDeleteLists(
m_grid, 1 );
958 bool aShowThickness,
bool aSkipRenderHoles )
960 wxASSERT( (aLayerID ==
B_Mask) || (aLayerID ==
F_Mask) );
973 m_board->SetItIsTransparent(
true );
974 m_board->DrawCulled( aShowThickness, solder_mask, via_holes );
991 bool aGetBot,
bool aRenderTransparentOnly,
992 bool aRenderSelectedOnly )
994 wxASSERT( ( aGetTop ==
true ) || ( aGetBot ==
true ) );
1004 bool highlight =
false;
1008 if( fp->IsSelected() )
1014 if( aRenderSelectedOnly != highlight )
1018 if( !fp->Models().empty() )
1022 const bool isFlipped = fp->IsFlipped();
1024 if( aGetTop == !isFlipped || aGetBot == isFlipped )
1035 bool aRenderTransparentOnly,
bool aIsSelected )
1037 if( !aFootprint->
Models().empty() )
1043 glm::mat4 fpMatrix( 1.0f );
1052 SFVEC3F( 0.0f, 0.0f, 1.0f ) );
1057 fpMatrix = glm::rotate( fpMatrix, glm::pi<float>(),
SFVEC3F( 0.0f, 1.0f, 0.0f ) );
1058 fpMatrix = glm::rotate( fpMatrix, glm::pi<float>(),
SFVEC3F( 0.0f, 0.0f, 1.0f ) );
1063 fpMatrix = glm::scale( fpMatrix,
SFVEC3F( modelunit_to_3d_units_factor ) );
1068 if( !sM.m_Show || sM.m_Filename.empty() )
1077 if(
const MODEL_3D* modelPtr = cache_i->second )
1079 bool opaque = sM.m_Opacity >= 1.0;
1081 if( ( !aRenderTransparentOnly && modelPtr->HasOpaqueMeshes() && opaque ) ||
1082 ( aRenderTransparentOnly && ( modelPtr->HasTransparentMeshes() || !opaque ) ) )
1084 glm::mat4 modelworldMatrix = fpMatrix;
1086 const SFVEC3F offset =
SFVEC3F( sM.m_Offset.x, sM.m_Offset.y, sM.m_Offset.z );
1087 const SFVEC3F rotation =
SFVEC3F( sM.m_Rotation.x, sM.m_Rotation.y,
1091 std::vector<float> key = { offset.x, offset.y, offset.z,
1092 rotation.x, rotation.y, rotation.z,
1099 modelworldMatrix *= it->second;
1103 glm::mat4 mtx( 1.0f );
1104 mtx = glm::translate( mtx, offset );
1105 mtx = glm::rotate( mtx, glm::radians( -rotation.z ), { 0.0f, 0.0f, 1.0f } );
1106 mtx = glm::rotate( mtx, glm::radians( -rotation.y ), { 0.0f, 1.0f, 0.0f } );
1107 mtx = glm::rotate( mtx, glm::radians( -rotation.x ), { 1.0f, 0.0f, 0.0f } );
1108 mtx = glm::scale( mtx,
scale );
1111 modelworldMatrix *= mtx;
1114 aDstRenderList.emplace_back( modelworldMatrix, modelPtr,
1115 aRenderTransparentOnly ? sM.m_Opacity : 1.0f,
1116 aRenderTransparentOnly,
1133 std::list<MODELTORENDER> renderList;
1141 if( !renderList.empty() )
1146 renderModel( aCameraViewMatrix, mtr, selColor,
nullptr );
1155 if( !renderList.empty() )
1160 renderModel( aCameraViewMatrix, mtr, selColor,
nullptr );
1175 std::list<MODELTORENDER> renderListModels;
1186 if( renderListModels.empty() )
1189 std::vector<std::pair<const MODELTORENDER *, float>> transparentModelList;
1191 transparentModelList.reserve( renderListModels.size() );
1198 const BBOX_3D& bBox = mtr.m_model->GetBBox();
1200 const SFVEC3F bBoxWorld = mtr.m_modelWorldMat * glm::vec4( bBoxCenter, 1.0f );
1202 const float distanceToCamera = glm::length( cameraPos - bBoxWorld );
1204 transparentModelList.emplace_back( &mtr, distanceToCamera );
1208 std::sort( transparentModelList.begin(), transparentModelList.end(),
1209 [&]( std::pair<const MODELTORENDER *, float>& a,
1210 std::pair<const MODELTORENDER *, float>& b )
1212 if( a.second != b.second )
1213 return a.second > b.second;
1215 return a.first > b.first;
1221 bool isUsingColorInformation = !( transparentModelList.begin()->first->m_isSelected &&
1226 for(
const std::pair<const MODELTORENDER *, float>& mtr : transparentModelList )
1231 if( !isUsingColorInformation && !mtr.first->m_isSelected )
1233 isUsingColorInformation =
true;
1235 glEnableClientState( GL_COLOR_ARRAY );
1236 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
1237 glEnable( GL_COLOR_MATERIAL );
1239 else if( isUsingColorInformation && mtr.first->m_isSelected )
1241 isUsingColorInformation =
false;
1243 glDisableClientState( GL_COLOR_ARRAY );
1244 glDisableClientState( GL_TEXTURE_COORD_ARRAY );
1245 glDisable( GL_COLOR_MATERIAL );
1251 renderModel( aCameraViewMatrix, *mtr.first, selColor, &cameraPos );
1266 const glm::mat4 modelviewMatrix = aCameraViewMatrix * aModelToRender.
m_modelWorldMat;
1268 glLoadMatrixf( glm::value_ptr( modelviewMatrix ) );
1276 const bool wasBlendEnabled = glIsEnabled( GL_BLEND );
1278 if( !wasBlendEnabled )
1280 glEnable( GL_BLEND );
1281 glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
1284 glDisable( GL_LIGHTING );
1292 glEnable( GL_LIGHTING );
1294 if( !wasBlendEnabled )
1295 glDisable( GL_BLEND );
1303 glDeleteLists(
m_grid, 1 );
1310 m_grid = glGenLists( 1 );
1312 if( !glIsList(
m_grid ) )
1315 glNewList(
m_grid, GL_COMPILE );
1317 glEnable( GL_BLEND );
1318 glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
1320 const double zpos = 0.0;
1328 const GLfloat transparency = 0.35f;
1330 double griSizeMM = 0.0;
1343 glNormal3f( 0.0, 0.0, 1.0 );
1348 brd_center_pos.
y = -brd_center_pos.
y;
1350 const int xsize = std::max( brd_size.
x,
pcbIUScale.mmToIU( 100 ) ) * 1.2;
1351 const int ysize = std::max( brd_size.
y,
pcbIUScale.mmToIU( 100 ) ) * 1.2;
1354 double xmin = ( brd_center_pos.
x - xsize / 2 ) *
scale;
1355 double xmax = ( brd_center_pos.
x + xsize / 2 ) *
scale;
1356 double ymin = ( brd_center_pos.
y - ysize / 2 ) *
scale;
1357 double ymax = ( brd_center_pos.
y + ysize / 2 ) *
scale;
1365 for(
int ii = 0; ; ii++ )
1368 glColor4f( gridColor.r, gridColor.g, gridColor.b, transparency );
1370 glColor4f( gridColor_marker.r, gridColor_marker.g, gridColor_marker.b,
1375 if(
delta <= xsize / 2 )
1377 glBegin( GL_LINES );
1378 glVertex3f( (brd_center_pos.
x +
delta) *
scale, -ymin, zpos );
1379 glVertex3f( (brd_center_pos.
x +
delta) *
scale, -ymax, zpos );
1384 glBegin( GL_LINES );
1385 glVertex3f( (brd_center_pos.
x -
delta) *
scale, -ymin, zpos );
1386 glVertex3f( (brd_center_pos.
x -
delta) *
scale, -ymax, zpos );
1391 if(
delta <= ysize / 2 )
1393 glBegin( GL_LINES );
1394 glVertex3f( xmin, -( brd_center_pos.
y +
delta ) *
scale, zpos );
1395 glVertex3f( xmax, -( brd_center_pos.
y +
delta ) *
scale, zpos );
1400 glBegin( GL_LINES );
1401 glVertex3f( xmin, -( brd_center_pos.
y -
delta ) *
scale, zpos );
1402 glVertex3f( xmax, -( brd_center_pos.
y -
delta ) *
scale, zpos );
1407 if( (
delta > ysize / 2 ) && (
delta > xsize / 2 ) )
1412 glNormal3f( 0.0, -1.0, 0.0 );
1415 double posy = -brd_center_pos.
y *
scale;
1417 for(
int ii = 0; ; ii++ )
1420 glColor4f( gridColor.r, gridColor.g, gridColor.b, transparency );
1422 glColor4f( gridColor_marker.r, gridColor_marker.g, gridColor_marker.b,
1427 glBegin( GL_LINES );
1430 glVertex3f( xmax, posy, zmin );
1431 glVertex3f( xmax, posy, zmax );
1436 glBegin( GL_LINES );
1438 glVertex3f( xmin, posy, zmin );
1439 glVertex3f( xmin, posy, zmax );
1443 if(
delta > xsize / 2.0f )
1448 for(
int ii = 0; ; ii++ )
1451 glColor4f( gridColor.r, gridColor.g, gridColor.b, transparency );
1453 glColor4f( gridColor_marker.r, gridColor_marker.g, gridColor_marker.b, transparency );
1460 glBegin( GL_LINES );
1461 glVertex3f( xmin, posy,
delta );
1462 glVertex3f( xmax, posy,
delta );
1466 if(
delta <= -zmin && ( ii != 0 ) )
1469 glBegin( GL_LINES );
1470 glVertex3f( xmin, posy, -
delta );
1471 glVertex3f( xmax, posy, -
delta );
1479 glDisable( GL_BLEND );
Defines math related functions.
float mapf(float x, float in_min, float in_max, float out_min, float out_max)
SFVEC3F SphericalToCartesian(float aInclination, float aAzimuth)
https://en.wikipedia.org/wiki/Spherical_coordinate_system
constexpr EDA_IU_SCALE pcbIUScale
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Helper class to handle information needed to display 3D board.
A class used to derive camera objects from.
Implement a canvas based on a wxGLCanvas.
auto RunWithoutCtxLock(Func &&aFunction, Args &&... args)
Run the given function first releasing the GL context lock, then restoring it.
Manage an 8-bit channel image.
void CircleFilled(int aCx, int aCy, int aRadius, unsigned char aValue)
void EfxFilter_SkipCenter(IMAGE *aInImg, IMAGE_FILTER aFilterType, unsigned int aRadius)
Apply a filter to the input image and store it in the image class.
unsigned int GetHeight() const
unsigned int GetWidth() const
A color representation with 4 components: red, green, blue, alpha.
static const LSET & PhysicalLayersMask()
Return a mask holding all layers which are physically realized.
void DrawBbox() const
Draw main bounding box of the model.
static void EndDrawMulti()
Cleanup render states after drawing multiple models.
void Draw(bool aTransparent, float aOpacity, bool aUseSelectedMaterial, const SFVEC3F &aSelectionColor, const glm::mat4 *aModelWorldMatrix, const SFVEC3F *aCameraWorldPos) const
Render the model into the current context.
static void BeginDrawMulti(bool aUseColorInformation)
Set some basic render states before drawing multiple models.
void DrawBboxes() const
Draw individual bounding boxes of each mesh.
Store the OpenGL display lists to related with a layer.
void ApplyScalePosition(float aZposition, float aZscale)
void SetItIsTransparent(bool aSetTransparent)
void DrawCulled(bool aDrawMiddle, const OPENGL_RENDER_LIST *aSubtractList=nullptr, const OPENGL_RENDER_LIST *bSubtractList=nullptr, const OPENGL_RENDER_LIST *cSubtractList=nullptr, const OPENGL_RENDER_LIST *dSubtractList=nullptr) const
Draw all layers if they are visible by the camera if camera position is above the layer.
void DrawAll(bool aDrawMiddle=true) const
Call to draw all the display lists.
GL_CONTEXT_MANAGER * GetGLContextManager()
std::unique_ptr< BUSY_INDICATOR > CreateBusyIndicator() const
Return a created busy indicator, if a factory has been set, else a null pointer.
RENDER_3D_BASE(BOARD_ADAPTER &aBoardAdapter, CAMERA &aCamera)
bool m_canvasInitialized
Flag if the canvas specific for this render was already initialized.
wxSize m_windowSize
The window size that this camera is working.
BOARD_ADAPTER & m_boardAdapter
Settings reference in use for this render.
OPENGL_RENDER_LIST * m_board
OPENGL_RENDER_LIST * m_outerThroughHoleRings
OPENGL_RENDER_LIST * m_offboardPadsFront
SPHERES_GIZMO::GizmoSphereSelection getSelectedGizmoSphere() const
GRID3D_TYPE m_lastGridType
Stores the last grid type.
std::tuple< int, int, int, int > getGizmoViewport() const
OPENGL_RENDER_LIST * m_microviaHoles
void renderOpaqueModels(const glm::mat4 &aCameraViewMatrix)
void generate3dGrid(GRID3D_TYPE aGridType)
Create a 3D grid to an OpenGL display list.
void setLightFront(bool enabled)
bool Redraw(bool aIsMoving, REPORTER *aStatusReporter, REPORTER *aWarningReporter) override
Redraw the view.
MAP_OGL_DISP_LISTS m_layers
MAP_OGL_DISP_LISTS m_innerLayerHoles
OPENGL_RENDER_LIST * m_boardWithHoles
RENDER_3D_OPENGL(EDA_3D_CANVAS *aCanvas, BOARD_ADAPTER &aAdapter, CAMERA &aCamera)
MAP_OGL_DISP_LISTS m_outerLayerHoles
OPENGL_RENDER_LIST * m_offboardPadsBack
BOARD_ITEM * m_currentRollOverItem
void renderBoardBody(bool aSkipRenderHoles)
std::map< std::vector< float >, glm::mat4 > m_3dModelMatrixMap
std::map< wxString, MODEL_3D * > m_3dModelMap
OPENGL_RENDER_LIST * m_viaBackCover
OPENGL_RENDER_LIST * m_viaFrontCover
LIST_TRIANGLES m_triangles
store pointers so can be deleted latter
OPENGL_RENDER_LIST * m_outerViaThroughHoles
OPENGL_RENDER_LIST * m_outerThroughHoles
void setLayerMaterial(PCB_LAYER_ID aLayerID)
OPENGL_RENDER_LIST * m_platedPadsFront
void resetSelectedGizmoSphere()
struct RENDER_3D_OPENGL::@136145154067207014164113243162246125147361200233 m_materials
void renderModel(const glm::mat4 &aCameraViewMatrix, const MODELTORENDER &aModelToRender, const SFVEC3F &aSelColor, const SFVEC3F *aCameraWorldPos)
int GetWaitForEditingTimeOut() override
Give the interface the time (in ms) that it should wait for editing or movements before (this works f...
void renderSolderMaskLayer(PCB_LAYER_ID aLayerID, float aZPos, bool aShowThickness, bool aSkipRenderHoles)
void renderTransparentModels(const glm::mat4 &aCameraViewMatrix)
void get3dModelsSelected(std::list< MODELTORENDER > &aDstRenderList, bool aGetTop, bool aGetBot, bool aRenderTransparentOnly, bool aRenderSelectedOnly)
void setPlatedCopperAndDepthOffset(PCB_LAYER_ID aLayer_id)
OPENGL_RENDER_LIST * m_antiBoard
void SetCurWindowSize(const wxSize &aSize) override
Before each render, the canvas will tell the render what is the size of its windows,...
OPENGL_RENDER_LIST * m_padHoles
SPHERES_GIZMO * m_spheres_gizmo
GLuint m_grid
oGL list that stores current grid
OPENGL_RENDER_LIST * m_platedPadsBack
void get3dModelsFromFootprint(std::list< MODELTORENDER > &aDstRenderList, const FOOTPRINT *aFootprint, bool aRenderTransparentOnly, bool aIsSelected)
void handleGizmoMouseInput(int mouseX, int mouseY)
void setLightBottom(bool enabled)
void setGizmoViewport(int x, int y, int width, int height)
void setLightTop(bool enabled)
A pure virtual class used to derive REPORTER objects from.
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)
Report a string with a given severity.
Renders a set of colored spheres in 3D space that act as a directional orientation gizmo.
GizmoSphereSelection
Enum to indicate which sphere (direction) is selected.
Store arrays of triangles to be used to create display lists.
#define DELETE_AND_FREE_MAP(map)
#define DELETE_AND_FREE(ptr)
#define UNITS3D_TO_UNITSPCB
Implements a model viewer canvas.
static const wxChar * m_logTrace
Trace mask used to enable or disable the trace output of this class.
int MapPCBLayerTo3DLayer(PCB_LAYER_ID aLayer)
@ LAYER_3D_SOLDERMASK_TOP
@ LAYER_3D_SOLDERMASK_BOTTOM
bool IsCopperLayer(int aLayerId)
Test whether a layer is a copper layer.
PCB_LAYER_ID
A quick note on layer IDs:
void OglResetTextureState()
Reset to default state the texture settings.
void OglSetMaterial(const SMATERIAL &aMaterial, float aOpacity, bool aUseSelectedMaterial, SFVEC3F aSelectionColor)
Set OpenGL materials.
GLuint OglLoadTexture(const IMAGE &aImage)
Generate a new OpenGL texture.
void OglDrawBackground(const SFVEC4F &aTopColor, const SFVEC4F &aBotColor)
Define generic OpenGL functions that are common to any OpenGL target.
PGM_BASE & Pgm()
The global program "get" accessor.
static SFVEC4F premultiplyAlpha(const SFVEC4F &aInput)
#define SIZE_OF_CIRCLE_TEXTURE
Manage a bounding box defined by two SFVEC3F min max points.
SFVEC3F GetCenter() const
Return the center point of the bounding box.
bool opengl_thickness_disableOnMove
KIGFX::COLOR4D opengl_selection_color
bool clip_silk_on_via_annuli
bool subtract_mask_from_silk
bool opengl_microvias_disableOnMove
bool highlight_on_rollover
bool DifferentiatePlatedCopper()
return true if platted copper aeras and non platted copper areas must be drawn using a different colo...
bool opengl_holes_disableOnMove
bool opengl_AA_disableOnMove
glm::mat4 m_modelWorldMat
VECTOR2< int32_t > VECTOR2I