60 const float aaa = aTransparency * aTransparency * aTransparency;
63 float ca = 1.0f - aTransparency;
64 ca = 1.00f - 1.05f * ca * ca * ca;
66 return glm::max( glm::min( aGrayColorValue * ca + aaa, 1.0f ), 0.0f );
73 MATERIAL::SetDefaultRefractionRayCount(
75 MATERIAL::SetDefaultReflectionRayCount(
78 MATERIAL::SetDefaultRefractionRecursionCount(
79 m_boardAdapter.m_Cfg->m_Render.raytrace_recursivelevel_refractions );
80 MATERIAL::SetDefaultReflectionRecursionCount(
81 m_boardAdapter.m_Cfg->m_Render.raytrace_recursivelevel_reflections );
99 const SFVEC3F copperSpecularLinear =
105 SFVEC3F( 0.0f ), copperSpecularLinear, 0.4f * 128.0f, 0.0f, 0.0f );
112 SFVEC3F( 0.256f, 0.137f, 0.086f ), 0.15f * 128.0f, 0.0f, 0.0f );
123 0.10f * 128.0f, 0.0f, 0.0f );
131 0.10f * 128.0f, 0.0f, 0.0f );
137 SFVEC3F( 0.0f ),
SFVEC3F( 0.10f ) ), 0.078125f * 128.0f, 0.0f, 0.0f );
143 const float solderMask_gray =
153 const float minSolderMaskShininess = 0.85f * 128.0f;
154 const float maxSolderMaskShininess = 512.0f;
155 const float solderMaskShininess = minSolderMaskShininess
156 + ( maxSolderMaskShininess - minSolderMaskShininess ) * ( 1.0f - solderMask_gray );
159 const float solderMaskReflection = glm::clamp( solderMask_gray * 0.3f, 0.02f, 0.16f );
164 SFVEC3F( glm::clamp( solderMask_gray * 2.0f, 0.30f, 1.0f ) ), solderMaskShininess,
165 solderMask_transparency, solderMaskReflection );
168 m_materials.m_SolderMask.SetRefractionRayCount( 1 );
189 (
SFVEC3F( 1.0f ) - bgTop ) / 3.0f,
190 0.10f * 128.0f, 1.0f, 0.50f );
192 m_materials.m_Floor.SetReflectionRecursionCount( 1 );
197 float aZMin,
float aZMax,
const MATERIAL* aMaterial,
212 aDstContainer.
Add( objPtr );
219 aDstContainer.
Add( objPtr );
231 aDstContainer.
Add( objPtr );
240 aDstContainer.
Add( objPtr );
251 float aLayerZOffset )
253 if( aContainer2d ==
nullptr )
260 if( listObject2d.size() == 0 )
263 for(
const OBJECT_2D* object2d_A : listObject2d )
271 object2d_B =
new std::vector<const OBJECT_2D*>();
281 if( layerHolesMap.find( aLayer_id ) != layerHolesMap.end() )
289 for(
const OBJECT_2D* hole2d : intersecting )
290 object2d_B->push_back( hole2d );
300 if( !throughHoleOuter.
GetList().empty() )
306 for(
const OBJECT_2D* hole2d : intersecting )
307 object2d_B->push_back( hole2d );
315 if( !cutouts.GetList().empty() )
318 cutouts.GetIntersectingObjects( object2d_A->GetBBox(), intersecting );
320 for(
const OBJECT_2D* cutout : intersecting )
321 object2d_B->push_back( cutout );
325 if( aLayer_id ==
F_Cu )
331 else if( aLayer_id ==
B_Cu )
346 for(
const OBJECT_2D* obj : intersecting )
347 object2d_B->push_back( obj );
353 && ( ( aLayer_id ==
B_SilkS && mapLayers.find(
B_Mask ) != mapLayers.end() )
354 || ( aLayer_id ==
F_SilkS && mapLayers.find(
F_Mask ) != mapLayers.end() ) ) )
362 if( containerMaskLayer2d )
365 for(
const OBJECT_2D* obj2d : intersecting )
366 object2d_B->push_back( obj2d );
369 if( object2d_B->empty() )
417 if( !aOnlyLoadCopperAndShapes )
423 m_camera.SetBoardLookAtPos( camera_pos );
438 if( aStop.stop_requested() )
443 if( aOnlyLoadCopperAndShapes )
456 std::bitset<LAYER_3D_END> layerFlags =
m_boardAdapter.GetVisibleLayers();
458 if( !aOnlyLoadCopperAndShapes )
460 const int outlineCount =
m_boardAdapter.GetBoardPoly().OutlineCount();
462 if( outlineCount > 0 )
464 float divFactor = 0.0f;
481 for(
int ii = 0; ii < antiboardPoly.
OutlineCount(); ii++ )
492 for(
int ii = 0; ii < boardPolyCopy.
OutlineCount(); ii++ )
503 for(
const OBJECT_2D* object2d_A : listObjects )
505 std::vector<const OBJECT_2D*>* object2d_B =
new std::vector<const OBJECT_2D*>();
515 for(
const OBJECT_2D* hole : intersecting )
517 if( object2d_A->Intersects( hole->GetBBox() ) )
518 object2d_B->push_back( hole );
523 auto addCutoutsFromContainer =
526 if( !aContainer.GetList().empty() )
529 aContainer.GetIntersectingObjects( object2d_A->GetBBox(),
532 for(
const OBJECT_2D* cutout : intersecting )
534 if( object2d_A->Intersects( cutout->GetBBox() ) )
535 object2d_B->push_back( cutout );
540 addCutoutsFromContainer(
m_boardAdapter.GetFrontCounterboreCutouts() );
541 addCutoutsFromContainer(
m_boardAdapter.GetBackCounterboreCutouts() );
542 addCutoutsFromContainer(
m_boardAdapter.GetFrontCountersinkCutouts() );
543 addCutoutsFromContainer(
m_boardAdapter.GetBackCountersinkCutouts() );
548 if( layerHolesMap.find(
F_Cu ) != layerHolesMap.end() )
555 for(
const OBJECT_2D* hole2d : intersecting )
557 if( object2d_A->Intersects( hole2d->GetBBox() ) )
558 object2d_B->push_back( hole2d );
562 if( layerHolesMap.find(
B_Cu ) != layerHolesMap.end() )
569 for(
const OBJECT_2D* hole2d : intersecting )
571 if( object2d_A->Intersects( hole2d->GetBBox() ) )
572 object2d_B->push_back( hole2d );
583 for(
const OBJECT_2D* obj : intersecting )
584 object2d_B->push_back( obj );
587 if( object2d_B->empty() )
632 for(
const OBJECT_2D* hole2d : holeList )
642 if( !intersecting.empty() )
646 switch( hole2d->GetObjectType() )
650 const float radius = hole2d->GetBBox().GetExtent().x * 0.5f * 0.999f;
679 if( aOnlyLoadCopperAndShapes )
686 for(
const std::pair<const PCB_LAYER_ID, BVH_CONTAINER_2D*>& entry :
771 else if(
m_boardAdapter.m_Cfg->m_Render.differentiate_plated_copper )
773 layerColor =
SFVEC3F( 184.0f / 255.0f, 115.0f / 255.0f, 50.0f / 255.0f );
788 if( aStop.stop_requested() )
794 if(
m_boardAdapter.m_Cfg->m_Render.differentiate_plated_copper && !aOnlyLoadCopperAndShapes )
805 if( !aOnlyLoadCopperAndShapes )
817 for(
const std::pair<const PCB_LAYER_ID, BVH_CONTAINER_2D*>& entry :
845 const float zLayerMin =
m_boardAdapter.GetLayerBottomZPos( layer_id );
846 const float zLayerMax =
m_boardAdapter.GetLayerTopZPos( layer_id );
851 std::vector<const OBJECT_2D*>* object2d_B =
new std::vector<const OBJECT_2D*>();
861 for(
const OBJECT_2D* hole : intersecting )
863 if( object2d_A->Intersects( hole->GetBBox() ) )
864 object2d_B->push_back( hole );
870 if( !container2d->
GetList().empty() )
876 for(
const OBJECT_2D* obj : intersecting )
877 object2d_B->push_back( obj );
880 if( object2d_B->empty() )
890 materialLayer, layerColor );
904 object2d_A->GetBoardItem() );
921#ifdef PRINT_STATISTICS_3D_VIEWER
923 int64_t stats_startLoad3DmodelsTime = stats_endConvertTime;
928 if( aOnlyLoadCopperAndShapes )
936 if( aStop.stop_requested() )
939#ifdef PRINT_STATISTICS_3D_VIEWER
943 if( !aOnlyLoadCopperAndShapes )
952 boardBBox.
Scale( 3.0f );
958 containerBBox.
Scale( 1.3f );
963 const float minZ = glm::min( containerBBox.
Min().z, boardBBox.
Min().z );
967 +
SFVEC3F( centerBBox.x, centerBBox.y, 0.0f );
971 +
SFVEC3F( centerBBox.x, centerBBox.y, 0.0f );
987 newTriangle1->
SetColor( floorColor );
988 newTriangle2->
SetColor( floorColor );
991 const float maxZ = glm::max( containerBBox.
Max().z, boardBBox.
Max().z );
1007 newTriangle3->
SetColor( floorColor );
1008 newTriangle4->
SetColor( floorColor );
1022 return ( ( aSource.r < ( 1.0f / 255.0f ) ) && ( aSource.g < ( 1.0f / 255.0f ) )
1023 && ( aSource.b < ( 1.0f / 255.0f ) ) );
1036 if( !IsColorZero( cameraLightColor ) )
1041 if( !IsColorZero( topLightColor ) )
1048 if( !IsColorZero( bottomLightColor ) )
1052 bottomLightColor ) );
1055 for(
size_t i = 0; i <
m_boardAdapter.m_Cfg->m_Render.raytrace_lightColor.size(); ++i )
1060 if( !IsColorZero( lightColor ) )
1081 / -
m_camera.GetCameraInitPos().z );
1083 if( min_zoom > max_zoom )
1084 std::swap( min_zoom, max_zoom );
1086 float zoom_ratio = max_zoom / min_zoom;
1090 steps -=
static_cast<int>( ceil( log( zoom_ratio ) / log( 1.26f ) ) );
1091 steps = std::max( steps, 0 );
1094 float increased_zoom = pow( 1.26f, steps / 2 );
1095 max_zoom *= increased_zoom;
1096 min_zoom /= increased_zoom;
1101 min_zoom = std::min( min_zoom, 1.0f );
1107 if( aStop.stop_requested() )
1111 std::unique_ptr<ACCELERATOR_3D> accelerator =
1122 double calculation_time = (double) (
GetRunningMicroSecs() - stats_startReloadTime ) / 1e6;
1124 if( aOnlyLoadCopperAndShapes )
1126 m_activityReporter->Report( wxString::Format(
_(
"Hit-test scene ready in %.3f s" ), calculation_time ) );
1130 m_activityReporter->Report( wxString::Format(
_(
"Reload time %.3f s" ), calculation_time ) );
1138 float aInnerRadius,
float aDepth,
1139 float aSurfaceZ,
bool aIsFront )
1141 const float platingThickness =
m_boardAdapter.GetHolePlatingThickness()
1144 if( platingThickness <= 0.0f || aInnerRadius <= 0.0f || aDepth <= 0.0f )
1147 const float outerRadius = aInnerRadius + platingThickness;
1148 const float zOther = aIsFront ? ( aSurfaceZ - aDepth ) : ( aSurfaceZ + aDepth );
1149 const float zMin = std::min( aSurfaceZ, zOther );
1150 const float zMax = std::max( aSurfaceZ, zOther );
1152 RING_2D* ring =
new RING_2D( aCenter, aInnerRadius, outerRadius, aSource );
1164 float aTopInnerRadius,
1165 float aBottomInnerRadius,
1166 float aSurfaceZ,
float aDepth,
1169 const float platingThickness =
m_boardAdapter.GetHolePlatingThickness()
1172 if( platingThickness <= 0.0f || aTopInnerRadius <= 0.0f || aBottomInnerRadius <= 0.0f
1178 const float topOuterRadius = aTopInnerRadius + platingThickness;
1179 const float bottomOuterRadius = aBottomInnerRadius + platingThickness;
1181 const float zOther = aIsFront ? ( aSurfaceZ - aDepth ) : ( aSurfaceZ + aDepth );
1182 const float zTop = std::max( aSurfaceZ, zOther );
1183 const float zBot = std::min( aSurfaceZ, zOther );
1185 if( topOuterRadius <= 0.0f || bottomOuterRadius <= 0.0f )
1188 const float largestDiameter = 2.0f * std::max( aTopInnerRadius, aBottomInnerRadius );
1189 unsigned int segments = std::max( 12u,
m_boardAdapter.GetCircleSegmentCount( largestDiameter ) );
1208 auto makePoint = [&](
float radius,
float angle,
float z )
1211 aCenter.y + sinf( angle ) *
radius,
1215 const float step = 2.0f * glm::pi<float>() / (float) segments;
1217 SFVEC3F innerTopPrev = makePoint( aTopInnerRadius, 0.0f, zTop );
1218 SFVEC3F innerBotPrev = makePoint( aBottomInnerRadius, 0.0f, zBot );
1219 SFVEC3F outerTopPrev = makePoint( topOuterRadius, 0.0f, zTop );
1220 SFVEC3F outerBotPrev = makePoint( bottomOuterRadius, 0.0f, zBot );
1222 const SFVEC3F innerTopFirst = innerTopPrev;
1223 const SFVEC3F innerBotFirst = innerBotPrev;
1224 const SFVEC3F outerTopFirst = outerTopPrev;
1225 const SFVEC3F outerBotFirst = outerBotPrev;
1227 for(
unsigned int i = 1; i <= segments; ++i )
1229 const float angle = ( i == segments ) ? 0.0f : step * i;
1231 const SFVEC3F innerTopCurr = ( i == segments ) ? innerTopFirst
1232 : makePoint( aTopInnerRadius, angle, zTop );
1233 const SFVEC3F innerBotCurr = ( i == segments ) ? innerBotFirst
1234 : makePoint( aBottomInnerRadius, angle, zBot );
1235 const SFVEC3F outerTopCurr = ( i == segments ) ? outerTopFirst
1236 : makePoint( topOuterRadius, angle, zTop );
1237 const SFVEC3F outerBotCurr = ( i == segments ) ? outerBotFirst
1238 : makePoint( bottomOuterRadius, angle, zBot );
1241 addQuad( innerTopPrev, innerTopCurr, innerBotCurr, innerBotPrev );
1244 addQuad( outerTopPrev, outerBotPrev, outerBotCurr, outerTopCurr );
1247 addQuad( outerTopPrev, outerTopCurr, innerTopCurr, innerTopPrev );
1250 addQuad( outerBotPrev, innerBotPrev, innerBotCurr, outerBotCurr );
1252 innerTopPrev = innerTopCurr;
1253 innerBotPrev = innerBotCurr;
1254 outerTopPrev = outerTopCurr;
1255 outerBotPrev = outerBotCurr;
1266 const int platingThickness =
m_boardAdapter.GetHolePlatingThickness();
1267 const float platingThickness3d = platingThickness * unitScale;
1281 const float holeDiameter =
via->GetDrillValue() * unitScale;
1282 const float holeInnerRadius = holeDiameter / 2.0f;
1283 const float holeOuterRadius = holeInnerRadius + platingThickness3d;
1287 via->LayerPair( &topLayer, &bottomLayer );
1289 const float viaZTop =
m_boardAdapter.GetLayerBottomZPos( topLayer );
1290 const float viaZBot =
m_boardAdapter.GetLayerBottomZPos( bottomLayer );
1294 via->Padstack().TertiaryDrill() } )
1296 const float backdrillRadius = backdrill.size.x * 0.5f * unitScale;
1298 if( backdrillRadius > holeOuterRadius )
1300 float plugZTop, plugZBot;
1302 if( backdrill.start ==
F_Cu )
1305 float mustCutZ =
m_boardAdapter.GetLayerBottomZPos( backdrill.end );
1310 auto it = ++copperLayers.
begin();
1312 if( it == copperLayers.
end() )
1314 plugZBot = mustCutZ;
1319 plugZBot = ( mustCutZ + mustNotCutZ ) / 2;
1325 float mustCutZ =
m_boardAdapter.GetLayerTopZPos( backdrill.end );
1330 auto it = ++copperLayers.
begin();
1332 if( it == copperLayers.
end() )
1334 plugZTop = mustCutZ;
1339 plugZTop = (mustCutZ + mustNotCutZ ) / 2;
1343 if( plugZTop > plugZBot )
1358 const auto frontMode =
via->GetFrontPostMachining();
1360 if( frontMode.has_value()
1364 const float frontRadius =
via->GetFrontPostMachiningSize() * 0.5f * unitScale;
1365 const float frontDepth =
via->GetFrontPostMachiningDepth() * unitScale;
1367 if( frontRadius > holeOuterRadius && frontDepth > 0 )
1370 const float pmBottomZ = viaZTop - frontDepth;
1371 const float plugZBot = viaZBot;
1373 if( pmBottomZ > plugZBot )
1380 if( angleRad < 0.01f )
1383 float radialDiff = frontRadius - holeOuterRadius;
1384 float innerHeight = radialDiff / tanf( angleRad );
1385 float totalHeight = pmBottomZ - plugZBot;
1387 if( innerHeight > totalHeight )
1388 innerHeight = totalHeight;
1390 float zInnerTop = plugZBot + innerHeight;
1394 holeOuterRadius, frontRadius );
1400 if( zInnerTop > plugZBot )
1426 const auto backMode =
via->GetBackPostMachining();
1428 if( backMode.has_value()
1432 const float backRadius =
via->GetBackPostMachiningSize() * 0.5f * unitScale;
1433 const float backDepth =
via->GetBackPostMachiningDepth() * unitScale;
1435 if( backRadius > holeOuterRadius && backDepth > 0 )
1438 const float plugZTop = viaZTop;
1439 const float pmTopZ = viaZBot + backDepth;
1441 if( plugZTop > pmTopZ )
1448 if( angleRad < 0.01f )
1451 float radialDiff = backRadius - holeOuterRadius;
1452 float innerHeight = radialDiff / tanf( angleRad );
1453 float totalHeight = plugZTop - pmTopZ;
1455 if( innerHeight > totalHeight )
1456 innerHeight = totalHeight;
1458 float zInnerBot = plugZTop - innerHeight;
1462 backRadius, holeOuterRadius );
1468 if( zInnerBot < plugZTop )
1497 for(
const PAD*
pad : footprint->Pads() )
1502 if( !
pad->HasHole() )
1508 const SFVEC2F padCenter(
pad->GetPosition().x * unitScale,
1509 -
pad->GetPosition().y * unitScale );
1510 const float holeInnerRadius =
pad->GetDrillSize().x * 0.5f * unitScale;
1511 const float holeOuterRadius = holeInnerRadius + platingThickness3d;
1513 const float padZTop = boardZTop;
1514 const float padZBot = boardZBot;
1517 const auto frontMode =
pad->GetFrontPostMachining();
1519 if( frontMode.has_value()
1523 const float frontRadius =
pad->GetFrontPostMachiningSize() * 0.5f * unitScale;
1524 const float frontDepth =
pad->GetFrontPostMachiningDepth() * unitScale;
1526 if( frontRadius > holeOuterRadius && frontDepth > 0 )
1528 const float pmBottomZ = padZTop - frontDepth;
1529 const float plugZBot = padZBot;
1531 if( pmBottomZ > plugZBot )
1538 if( angleRad < 0.01f )
1541 float radialDiff = frontRadius - holeOuterRadius;
1542 float innerHeight = radialDiff / tanf( angleRad );
1543 float totalHeight = pmBottomZ - plugZBot;
1545 if( innerHeight > totalHeight )
1546 innerHeight = totalHeight;
1548 float zInnerTop = plugZBot + innerHeight;
1552 holeOuterRadius, frontRadius );
1558 if( zInnerTop > plugZBot )
1584 const auto backMode =
pad->GetBackPostMachining();
1586 if( backMode.has_value()
1590 const float backRadius =
pad->GetBackPostMachiningSize() * 0.5f * unitScale;
1591 const float backDepth =
pad->GetBackPostMachiningDepth() * unitScale;
1593 if( backRadius > holeOuterRadius && backDepth > 0 )
1595 const float plugZTop = padZTop;
1596 const float pmTopZ = padZBot + backDepth;
1598 if( plugZTop > pmTopZ )
1605 if( angleRad < 0.01f )
1608 float radialDiff = backRadius - holeOuterRadius;
1609 float innerHeight = radialDiff / tanf( angleRad );
1610 float totalHeight = plugZTop - pmTopZ;
1612 if( innerHeight > totalHeight )
1613 innerHeight = totalHeight;
1615 float zInnerBot = plugZTop - innerHeight;
1619 backRadius, holeOuterRadius );
1625 if( zInnerBot < plugZTop )
1662 aVia->
LayerPair( &top_layer, &bottom_layer );
1664 float frontDepth = 0.0f;
1665 float backDepth = 0.0f;
1683 ( radiusBUI +
m_boardAdapter.GetHolePlatingThickness() ) * unitScale, *aVia );
1694 const float holeInnerRadius = radiusBUI * unitScale;
1695 const float frontSurface = topZ + frontDepth;
1696 const float backSurface = botZ - backDepth;
1702 if( frontDepth > 0.0f && frontRadius > holeInnerRadius )
1719 if( backDepth > 0.0f && backRadius > holeInnerRadius )
1743 const bool hasHole = drillsize.
x && drillsize.
y;
1745 const bool isRoundHole = drillsize.
x == drillsize.
y;
1747 float holeInnerRadius = 0.0f;
1754 float frontDepth = 0.0f;
1755 float backDepth = 0.0f;
1774 int innerRadius = drillsize.
x / 2;
1775 int outerRadius = innerRadius +
m_boardAdapter.GetHolePlatingThickness();
1776 holeInnerRadius = innerRadius * unitScale;
1778 RING_2D* ring =
new RING_2D( holeCenter, innerRadius * unitScale,
1779 outerRadius * unitScale, *aPad );
1790 antiOutlineIntersectionList );
1793 if( !antiOutlineIntersectionList.empty() )
1796 holeCenter, innerRadius * unitScale, *aPad );
1799 holeCenter, outerRadius * unitScale, *aPad );
1800 std::vector<const OBJECT_2D*>* object2d_B =
new std::vector<const OBJECT_2D*>();
1801 object2d_B->push_back( innerCircle );
1810 object2d_A = itemCSG2d;
1818 if( drillsize.
x > drillsize.
y )
1820 ends_offset.
x = ( drillsize.
x - drillsize.
y ) / 2;
1821 width = drillsize.
y;
1825 ends_offset.
y = ( drillsize.
y - drillsize.
x ) / 2;
1826 width = drillsize.
x;
1836 -start.
y * unitScale ),
1838 -
end.y * unitScale ),
1839 width * unitScale, *aPad );
1843 -start.
y * unitScale ),
1845 -
end.y * unitScale ),
1847 * unitScale, *aPad );
1850 std::vector<const OBJECT_2D*>* object2d_B =
new std::vector<const OBJECT_2D*>();
1851 object2d_B->push_back( innerSeg );
1859 object2d_A = itemCSG2d;
1864 antiOutlineIntersectionList );
1870 std::vector<const OBJECT_2D*>* object2d_B =
new std::vector<const OBJECT_2D*>();
1880 for(
const OBJECT_2D* hole2d : intersecting )
1882 if( object2d_A->
Intersects( hole2d->GetBBox() ) )
1883 object2d_B->push_back( hole2d );
1887 for(
const OBJECT_2D* obj : antiOutlineIntersectionList )
1888 object2d_B->push_back( obj );
1890 if( object2d_B->empty() )
1920 if( object2d_A && isRoundHole )
1922 const float frontSurface = topZ + frontDepth;
1923 const float backSurface = botZ - backDepth;
1929 if( frontDepth > 0.0f && frontRadius > holeInnerRadius )
1947 if( backDepth > 0.0f && backRadius > holeInnerRadius )
1984 for(
PAD*
pad : footprint->Pads() )
1994 const glm::mat4& aFpMatrix,
bool aHasExtrudedBody,
1997 if( aHasExtrudedBody )
2004 float scaleZ = std::min( bboxW, bboxH ) * 0.5f;
2007 float offsetX = localCenter.
x /
pcbIUScale.IU_PER_MM;
2008 float offsetY = -localCenter.
y /
pcbIUScale.IU_PER_MM;
2013 SFVEC3F boxMin( offsetX - bboxW * 0.5f, offsetY - bboxH * 0.5f, 0.0f );
2014 SFVEC3F boxMax( offsetX + bboxW * 0.5f, offsetY + bboxH * 0.5f, scaleZ );
2018 for(
int i = 0; i < 8; ++i )
2020 SFVEC3F corner( ( i & 1 ) ? boxMax.x : boxMin.x, ( i & 2 ) ? boxMax.y : boxMin.y,
2021 ( i & 4 ) ? boxMax.z : boxMin.z );
2023 corners[i] =
SFVEC3F( aFpMatrix * glm::vec4( corner, 1.0f ) );
2026 static const int faces[6][4] = { { 4, 5, 7, 6 }, { 0, 2, 3, 1 }, { 0, 1, 5, 4 },
2027 { 3, 2, 6, 7 }, { 0, 4, 6, 2 }, { 1, 3, 7, 5 } };
2036 aDstContainer.
Add( triangle );
2039 for(
const int* face : faces )
2041 addTriangle( corners[face[0]], corners[face[2]], corners[face[1]] );
2042 addTriangle( corners[face[0]], corners[face[3]], corners[face[2]] );
2056 if(
chain.PointCount() < 3 )
2063 for(
int i = 0; i <
chain.PointCount(); i++ )
2066 SFVEC2F pt( (
float) a.
x * aBiuTo3d, (
float) ( -a.
y ) * aBiuTo3d );
2068 if( ( i == 0 ) || ( fabs( prevPt.x - pt.x ) > FLT_EPSILON ) || ( fabs( prevPt.y - pt.y ) > FLT_EPSILON ) )
2074 segNormals.push_back( sn );
2079 if( segNormals.size() >= 3 )
2081 std::vector<SFVEC2F> tmpNormals( segNormals.size() );
2082 unsigned int j = segNormals.size() - 1;
2084 for(
unsigned int i = 0; i < segNormals.size(); j = i++ )
2086 SFVEC2F slope = segNormals[j].m_Start - segNormals[i].m_Start;
2087 segNormals[i].m_Precalc_slope = slope;
2088 tmpNormals[i] = glm::normalize(
SFVEC2F( slope.y, -slope.x ) );
2091 j = segNormals.size() - 1;
2093 for(
unsigned int i = 0; i < segNormals.size(); j = i++ )
2095 const SFVEC2F& nBefore = tmpNormals[j];
2096 const SFVEC2F& nCur = tmpNormals[i];
2097 const SFVEC2F& nAfter = tmpNormals[( i + 1 ) % segNormals.size()];
2099 float dotBefore = glm::dot( nBefore, nCur );
2100 float dotAfter = glm::dot( nAfter, nCur );
2102 segNormals[i].m_Normals.m_Start =
2103 ( dotBefore < 0.7f ) ? nCur : glm::normalize( nBefore * dotBefore + nCur );
2104 segNormals[i].m_Normals.m_End = ( dotAfter < 0.7f ) ? nCur : glm::normalize( nAfter * dotAfter + nCur );
2107 SEGMENTS capSegments( segNormals.size() );
2109 for(
unsigned int i = 0; i < segNormals.size(); i++ )
2110 capSegments[i].m_Start = segNormals[i].m_Start;
2112 j = capSegments.size() - 1;
2114 for(
unsigned int i = 0; i < capSegments.size(); j = i++ )
2116 capSegments[i].m_inv_JY_minus_IY = 1.0f / ( capSegments[j].m_Start.y - capSegments[i].m_Start.y );
2117 capSegments[i].m_JX_minus_IX = capSegments[j].m_Start.x - capSegments[i].m_Start.x;
2121 outersAndHoles.
m_Outers.push_back( capSegments );
2123 aObjContainer.
Add(
new POLYGON_2D( segNormals, outersAndHoles, aBoardItem ) );
2129 size_t prevSize = aObjContainer.
GetList().size();
2131 added += aObjContainer.
GetList().size() - prevSize;
2157 float standoff3d = body->
m_standoff * biuTo3d;
2165 zBot = boardSurfaceZ + standoff3d + zOffset3d;
2166 zTop = zBot + bodyThickness;
2170 zTop = boardSurfaceZ - standoff3d - zOffset3d;
2171 zBot = zTop - bodyThickness;
2185 size_t prevCount = objList.size();
2196 auto it = objList.begin();
2197 std::advance( it, prevCount );
2199 for( ; it != objList.end(); ++it )
2206 aDstContainer.
Add( layerItem );
2210 if( standoff3d > 0.0f )
2217 float oppositeSurfaceZ =
m_boardAdapter.GetFootprintZPos( !isBack );
2218 float protrusion = 1.0f *
pcbIUScale.IU_PER_MM * biuTo3d;
2219 float pinZBot, pinZTop;
2223 pinZBot = oppositeSurfaceZ - protrusion + zOffset3d;
2224 pinZTop = boardSurfaceZ + standoff3d + zOffset3d;
2228 pinZTop = oppositeSurfaceZ + protrusion - zOffset3d;
2229 pinZBot = boardSurfaceZ - standoff3d - zOffset3d;
2232 auto addPinObjects =
2241 size_t prevPinCount = objList.size();
2245 auto pinIt = objList.begin();
2246 std::advance( pinIt, prevPinCount );
2248 for( ; pinIt != objList.end(); ++pinIt )
2255 aDstContainer.
Add( layerItem );
2261 addPinObjects( pinPoly, &
m_materials.m_Copper, metalColor, 0.0f );
2262 addPinObjects( pegPoly, bodyMaterial, objColor, 1.0f - (
float) c.
a );
2271 std::stop_token aStop )
2287 if( aStop.stop_requested() )
2290 bool hasModels = !fp->Models().empty();
2293 bool hasExtrudedBody =
false;
2295 if( fp->HasBody() && fp->GetBody()->GetExtruded()->m_show &&
m_boardAdapter.IsFootprintShown( fp ) )
2300 const glm::mat4 fpMatrix =
m_boardAdapter.GetFootprintMatrix( *fp );
2305 const wxString footprintBasePath =
m_boardAdapter.GetFootprintLibraryPath( fp );
2307 bool placeholderAdded =
false;
2311 if( !
model.m_Show ||
model.m_Filename.empty() )
2315 std::vector<const EMBEDDED_FILES*> embeddedFilesStack;
2316 embeddedFilesStack.push_back( fp->GetEmbeddedFiles() );
2317 embeddedFilesStack.push_back(
m_boardAdapter.GetBoard()->GetEmbeddedFiles() );
2320 std::move( embeddedFilesStack ) );
2330 addModels( aDstContainer, modelPtr, modelMatrix, (
float)
model.m_Opacity,
2331 aSkipMaterialInformation, fp );
2333 else if(
m_boardAdapter.ShowMissingModels() && !placeholderAdded )
2336 placeholderAdded =
true;
2370 for(
unsigned int imat = 0; imat < a3DModel->
m_MaterialsSize; ++imat )
2378 float reflectionFactor = 0.0f;
2380 if( ( material.
m_Shininess - 0.35f ) > FLT_EPSILON )
2382 reflectionFactor = glm::clamp(
2383 glm::sqrt( ( material.
m_Shininess - 0.35f ) ) * 0.40f - 0.05f, 0.0f,
2394 if(
m_boardAdapter.m_Cfg->m_Render.raytrace_procedural_textures )
2449 return materialVector;
2454 const glm::mat4& aModelMatrix,
float aFPOpacity,
2455 bool aSkipMaterialInformation,
BOARD_ITEM* aBoardItem )
2458 wxASSERT( a3DModel !=
nullptr );
2460 if( a3DModel ==
nullptr )
2464 wxASSERT( a3DModel->
m_Meshes !=
nullptr );
2468 if( aFPOpacity > 1.0f )
2471 if( aFPOpacity < 0.0f )
2479 if( !aSkipMaterialInformation )
2484 const glm::mat3 normalMatrix = glm::transpose( glm::inverse( glm::mat3( aModelMatrix ) ) );
2486 for(
unsigned int mesh_i = 0; mesh_i < a3DModel->
m_MeshesSize; ++mesh_i )
2503 float fpTransparency;
2506 if( !aSkipMaterialInformation )
2515 for(
unsigned int faceIdx = 0; faceIdx < mesh.
m_FaceIdxSize; faceIdx += 3 )
2517 const unsigned int idx0 = mesh.
m_FaceIdx[faceIdx + 0];
2518 const unsigned int idx1 = mesh.
m_FaceIdx[faceIdx + 1];
2519 const unsigned int idx2 = mesh.
m_FaceIdx[faceIdx + 2];
2536 const SFVEC3F vt0 =
SFVEC3F( aModelMatrix * glm::vec4( v0, 1.0f ) );
2540 const SFVEC3F nt0 = glm::normalize(
SFVEC3F( normalMatrix * n0 ) );
2541 const SFVEC3F nt1 = glm::normalize(
SFVEC3F( normalMatrix * n1 ) );
2542 const SFVEC3F nt2 = glm::normalize(
SFVEC3F( normalMatrix * n2 ) );
2548 aDstContainer.
Add( newTriangle );
2550 if( !aSkipMaterialInformation )
@ NORMAL
Use all material properties from model file.
@ CAD_MODE
Use a gray shading based on diffuse material.
Defines math related functions.
float NextFloatDown(float v)
float NextFloatUp(float v)
glm::mat4 CalcModelMatrix(const SFVEC3F &aOffset, const SFVEC3F &aRotation, const SFVEC3F &aScale)
Build the model-to-footprint transform used by rendering and picking.
Defines math related functions.
float RGBtoGray(const SFVEC3F &aColor)
SFVEC3F MaterialDiffuseToColorCAD(const SFVEC3F &aDiffuseColor)
SFVEC3F SphericalToCartesian(float aInclination, float aAzimuth)
https://en.wikipedia.org/wiki/Spherical_coordinate_system
bool GetExtrusionPinOutlines(const FOOTPRINT *aFootprint, SHAPE_POLY_SET &aPinPoly, SHAPE_POLY_SET &aPegPoly)
Get the hole outline polygons for extruded pin rendering.
void ApplyExtrusionTransform(SHAPE_POLY_SET &aOutline, const EXTRUDED_3D_BODY *aBody, const VECTOR2I &aFpPos)
Apply 2D extrusion transforms (rotation, scale, offset) to an outline.
EXTRUSION_MATERIAL_PROPS GetMaterialProps(EXTRUSION_MATERIAL aMaterial, const SFVEC3F &aDiffuse)
bool GetExtrusionOutline(const FOOTPRINT *aFootprint, SHAPE_POLY_SET &aOutline, PCB_LAYER_ID aLayerOverride)
Get the extrusion outline polygon for a footprint in board coordinates.
BOX2I CalcPlaceholderLocalBox(const FOOTPRINT *aFootprint)
Calculate a local space bounding box for a placeholder 3D model.
constexpr EDA_IU_SCALE pcbIUScale
std::map< PCB_LAYER_ID, BVH_CONTAINER_2D * > MAP_CONTAINER_2D_BASE
A type that stores a container of 2d objects for each layer id.
#define RANGE_SCALE_3D
This defines the range that all coord will have to be rendered.
This BVH implementation is based on the source code implementation from the book "Physically Based Re...
bool IsTriangleInRange(const unsigned int *aFaceIdx, unsigned int aTriangleIdx, unsigned int aVertexCount)
Test whether the three face indices of a triangle all reference valid vertices.
Blinn Phong based material https://en.wikipedia.org/wiki/Blinn%E2%80%93Phong_shading_model.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Information pertinent to a Pcbnew printed circuit board.
constexpr size_type GetWidth() const
constexpr const Vec GetCenter() const
constexpr size_type GetHeight() const
void GetIntersectingObjects(const BBOX_2D &aBBox, CONST_LIST_OBJECT2D &aOutList) const override
Get a list of objects that intersects a bounding box.
static const float DEFAULT_MAX_ZOOM
void Add(OBJECT_2D *aObject)
const LIST_OBJECT2D & GetList() const
void Add(OBJECT_3D *aObject)
Procedural generation of the copper normals.
void SetColor(SFVEC3F aObjColor)
A light source based only on a directional vector.
static KIGFX::COLOR4D GetDefaultColor(EXTRUSION_MATERIAL aMaterial)
EXTRUSION_MATERIAL m_material
A color representation with 4 components: red, green, blue, alpha.
static const COLOR4D UNSPECIFIED
For legacy support; used as a value to indicate color hasn't been set yet.
Make solid geometry for objects on layers.
void SetColor(SFVEC3F aObjColor)
LAYER_RANGE_ITERATOR end() const
LAYER_RANGE_ITERATOR begin() const
A base light class to derive to implement other light classes.
Base material class that can be used to derive other material implementations.
void SetGenerator(const MATERIAL_GENERATOR *aGenerator)
float GetTransparency() const
static OBJECT_2D_STATS & Instance()
virtual bool Intersects(const BBOX_2D &aBBox) const =0
a.Intersects(b) ⇔ !a.Disjoint(b) ⇔ !(a ∩ b = ∅)
const BBOX_2D & GetBBox() const
const BOARD_ITEM & GetBoardItem() const
OBJECT_2D_TYPE GetObjectType() const
static OBJECT_3D_STATS & Instance()
void SetMaterial(const MATERIAL *aMaterial)
void SetModelTransparency(float aModelTransparency)
void SetBoardItem(BOARD_ITEM *aBoardItem)
POST_MACHINING_PROPS & FrontPostMachining()
POST_MACHINING_PROPS & BackPostMachining()
int GetBackPostMachiningSize() const
VECTOR2I GetPosition() const override
VECTOR2I GetDrillSize() const
int GetFrontPostMachiningSize() const
int GetFrontPostMachiningDepth() const
std::optional< PAD_DRILL_POST_MACHINING_MODE > GetFrontPostMachining() const
EDA_ANGLE GetOrientation() const
Return the rotation angle of the pad.
std::optional< PAD_DRILL_POST_MACHINING_MODE > GetBackPostMachining() const
int GetBackPostMachiningDepth() const
const EXTRUDED_3D_BODY * GetExtruded() const
const VECTOR2I & GetStart() const
int GetFrontPostMachiningSize() const
const PADSTACK & Padstack() const
std::optional< PAD_DRILL_POST_MACHINING_MODE > GetFrontPostMachining() const
int GetBackPostMachiningSize() const
int GetDrillValue() const
Calculate the drill value for vias (m_drill if > 0, or default drill value for the board).
std::optional< PAD_DRILL_POST_MACHINING_MODE > GetBackPostMachining() const
void LayerPair(PCB_LAYER_ID *top_layer, PCB_LAYER_ID *bottom_layer) const
Return the 2 layers used by the via (the via actually uses all layers between these 2 layers)
Procedural generation of the plastic normals.
Procedural generation of the shiny plastic normals.
Point light source based on http://ogldev.atspace.co.uk/www/tutorial20/tutorial20....
Represent a sub polygon block.
std::shared_ptr< REPORTER > m_warningReporter
std::shared_ptr< REPORTER > m_activityReporter
BOARD_ADAPTER & m_boardAdapter
Settings reference in use for this render.
SILK_SCREEN_NORMAL m_silkScreenMaterial
struct RENDER_3D_RAYTRACE_BASE::@013206213056006125230376122042346155134272177300 m_materials
std::mutex m_hitTestMutex
Serializes hover BVH use.
void addCountersinkPlating(const SFVEC2F &aCenter, float aTopInnerRadius, float aBottomInnerRadius, float aSurfaceZ, float aDepth, bool aIsFront)
BOARD_NORMAL m_boardMaterial
CONTAINER_3D m_objectContainer
std::vector< std::unique_ptr< BLINN_PHONG_MATERIAL > > m_extrusionMaterials
COPPER_NORMAL m_copperMaterial
void insertHole(const PCB_VIA *aVia)
BRUSHED_METAL_NORMAL m_brushedMetalMaterial
static constexpr float MIN_DISTANCE_IU
PLATED_COPPER_NORMAL m_platedCopperMaterial
PLASTIC_NORMAL m_plasticMaterial
void createItemsFromContainer(const BVH_CONTAINER_2D *aContainer2d, PCB_LAYER_ID aLayer_id, const MATERIAL *aMaterialLayer, const SFVEC3F &aLayerColor, float aLayerZOffset)
DIRECTIONAL_LIGHT * m_cameraLight
PLASTIC_SHINE_NORMAL m_shinyPlasticMaterial
unsigned int m_convertedDummyBlockCount
bool addExtrudedBodyToRaytracer(CONTAINER_3D &aDstContainer, const FOOTPRINT *aFootprint)
void backfillPostMachine()
void addCounterborePlating(const BOARD_ITEM &aSource, const SFVEC2F &aCenter, float aInnerRadius, float aDepth, float aSurfaceZ, bool aIsFront)
CONTAINER_2D * m_outlineBoard2dObjects
void load3DModels(CONTAINER_3D &aDstContainer, bool aSkipMaterialInformation, std::stop_token aStop={})
BVH_CONTAINER_2D * m_antioutlineBoard2dObjects
CONTAINER_2D m_containerWithObjectsToDelete
Store the list of created objects special for RT that will be clear in the end.
std::unique_ptr< ACCELERATOR_3D > m_accelerator
void addPlaceholderToRaytracer(CONTAINER_3D &aDstContainer, const FOOTPRINT *aFootprint, const glm::mat4 &aFpMatrix, bool aHasExtrudedBody=false, float aOpacity=1.0f)
MODEL_MATERIALS * getModelMaterial(const S3DMODEL *a3DModel)
SOLDER_MASK_NORMAL m_solderMaskMaterial
void addModels(CONTAINER_3D &aDstContainer, const S3DMODEL *a3DModel, const glm::mat4 &aModelMatrix, float aFPOpacity, bool aSkipMaterialInformation, BOARD_ITEM *aBoardItem)
std::list< LIGHT * > m_lights
MAP_MODEL_MATERIALS m_modelMaterialMap
Stores materials of the 3D models.
void createObject(CONTAINER_3D &aDstContainer, const OBJECT_2D *aObject2D, float aZMin, float aZMax, const MATERIAL *aMaterial, const SFVEC3F &aObjColor)
Create one or more 3D objects form a 2D object and Z positions.
unsigned int m_converted2dRoundSegmentCount
void Reload(bool aOnlyLoadCopperAndShapes, std::stop_token aStop={})
void SetColor(SFVEC3F aObjColor)
Cache for storing the 3D shapes.
S3DMODEL * GetModel(const wxString &aModelFileName, const wxString &aBasePath, std::vector< const EMBEDDED_FILES * > aEmbeddedFilesStack)
Attempt to load the scene data for a model and to translate it into an S3D_MODEL structure for displa...
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
Represent a set of closed polygons.
void Simplify()
Simplify the polyset (merges overlapping polys, eliminates degeneracy/self-intersections)
int OutlineCount() const
Return the number of outlines in the set.
void Fracture(bool aSimplify=true)
Convert a set of polygons with holes to a single outline with "slits"/"fractures" connecting the oute...
void BooleanSubtract(const SHAPE_POLY_SET &b)
Perform boolean polyset difference.
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
Procedural generation of the solder mask.
void SetColor(const SFVEC3F &aColor)
A vertical truncated cone with different radii at top and bottom.
void SetColor(SFVEC3F aObjColor)
A plane that is parallel to XY plane.
void SetColor(SFVEC3F aObjColor)
std::list< OBJECT_2D * > LIST_OBJECT2D
std::list< const OBJECT_2D * > CONST_LIST_OBJECT2D
Declaration of the eda_3d_viewer class.
A truncated cone for raytracing, used for countersink visualization.
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:
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
PAD_DRILL_POST_MACHINING_MODE
@ NPTH
like PAD_PTH, but not plated mechanical use only, no connection allowed
static wxColor copperColor(220, 180, 30)
void ConvertPolygonToBlocks(const SHAPE_POLY_SET &aMainPath, CONTAINER_2D_BASE &aDstContainer, float aBiuTo3dUnitsScale, float aDivFactor, const BOARD_ITEM &aBoardItem, int aPolyIndex)
Use a polygon in the format of the ClipperLib::Path and process it and create multiple 2d objects (PO...
std::vector< SEGMENT_WITH_NORMALS > SEGMENTS_WIDTH_NORMALS
List used to test ray2d intersections.
std::vector< POLYSEGMENT > SEGMENTS
int64_t GetRunningMicroSecs()
An alternate way to calculate an elapsed time (in microsecondes) to class PROF_COUNTER.
void buildBoardBoundingBoxPoly(const BOARD *aBoard, SHAPE_POLY_SET &aOutline)
Get the complete bounding box of the board (including all items).
static size_t addOutlineToRaytracerObjects(CONTAINER_2D &aObjContainer, const SHAPE_POLY_SET &aOutline, float aBiuTo3d, const BOARD_ITEM &aBoardItem)
static float TransparencyControl(float aGrayColorValue, float aTransparency)
Perform an interpolation step to easy control the transparency based on the gray color value and tran...
SFVEC3F ConvertSRGBToLinear(const SFVEC3F &aSRGBcolor)
std::vector< BLINN_PHONG_MATERIAL > MODEL_MATERIALS
Vector of materials.
const SFVEC2F & Min() const
const SFVEC2F & Max() const
Manage a bounding box defined by two SFVEC3F min max points.
SFVEC3F GetCenter() const
Return the center point of the bounding box.
const SFVEC3F & Min() const
Return the minimum vertex pointer.
const SFVEC3F & Max() const
Return the maximum vertex pointer.
bool IsInitialized() const
Check if this bounding box is already initialized.
void Scale(float aScale)
Scales a bounding box by its center.
bool clip_silk_on_via_annuli
bool subtract_mask_from_silk
Handle a subset of a polygon.
std::vector< SEGMENTS > m_Outers
The properties of a padstack drill.
std::optional< PAD_DRILL_POST_MACHINING_MODE > mode
Store the a model based on meshes and materials.
SMATERIAL * m_Materials
The materials list of this model.
unsigned int m_MeshesSize
Number of meshes in the array.
SMESH * m_Meshes
The meshes list of this model.
unsigned int m_MaterialsSize
Number of materials in the material array.
float m_Transparency
1.0 is completely transparent, 0.0 completely opaque
SFVEC3F m_Diffuse
Default diffuse color if m_Color is NULL.
Per-vertex normal/color/texcoors structure.
unsigned int * m_FaceIdx
Triangle Face Indexes.
SFVEC3F * m_Normals
Vertex normals array.
unsigned int m_MaterialIdx
Material Index to be used in this mesh (must be < m_MaterialsSize )
unsigned int m_VertexSize
Number of vertex in the arrays.
unsigned int m_FaceIdxSize
Number of elements of the m_FaceIdx array.
SFVEC3F * m_Color
Vertex color array, can be NULL.
SFVEC3F * m_Positions
Vertex position array.
const SHAPE_LINE_CHAIN chain
void ConvertPolygonToTriangles(const SHAPE_POLY_SET &aPolyList, CONTAINER_2D_BASE &aDstContainer, float aBiuTo3dUnitsScale, const BOARD_ITEM &aBoardItem)
Implement a triangle ray intersection based on article http://www.flipcode.com/archives/Raytracing_To...
void RotatePoint(int *pX, int *pY, const EDA_ANGLE &aAngle)
Calculate the new point of coord coord pX, pY, for a rotation center 0, 0.
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
VECTOR2< int32_t > VECTOR2I