haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Flatten a layer of indirection out of 3D config settings.

This commit is contained in:
Jeff Young 2021-08-30 21:30:18 +01:00
parent d28714167c
commit 68d2630d08
16 changed files with 479 additions and 922 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
3d-viewer/3d_canvas/board_adapter.cpp
View File

@ -67,6 +67,9 @@ const wxChar *BOARD_ADAPTER::m_logTrace = wxT( "KI_TRACE_EDA_CINFO3D_VISU" );
BOARD_ADAPTER::BOARD_ADAPTER() : BOARD_ADAPTER::BOARD_ADAPTER() :
m_Cfg( nullptr ),
m_IsBoardView( true ),
m_MousewheelPanning( true ),
m_board( nullptr ), m_board( nullptr ),
m_3dModelManager( nullptr ), m_3dModelManager( nullptr ),
m_colors( nullptr ), m_colors( nullptr ),
@ -75,16 +78,9 @@ BOARD_ADAPTER::BOARD_ADAPTER() :
{ {
wxLogTrace( m_logTrace, wxT( "BOARD_ADAPTER::BOARD_ADAPTER" ) ); wxLogTrace( m_logTrace, wxT( "BOARD_ADAPTER::BOARD_ADAPTER" ) );
m_gridType = GRID3D_TYPE::NONE;
m_antiAliasingMode = ANTIALIASING_MODE::AA_8X;
m_drawFlags.resize( FL_LAST, false );
if( PgmOrNull() ) if( PgmOrNull() )
m_colors = Pgm().GetSettingsManager().GetColorSettings(); m_colors = Pgm().GetSettingsManager().GetColorSettings();
m_renderEngine = RENDER_ENGINE::OPENGL;
m_materialMode = MATERIAL_MODE::NORMAL;
m_boardPos = wxPoint(); m_boardPos = wxPoint();
m_boardSize = wxSize(); m_boardSize = wxSize();
m_boardCenter = SFVEC3F( 0.0f ); m_boardCenter = SFVEC3F( 0.0f );
@ -109,27 +105,6 @@ BOARD_ADAPTER::BOARD_ADAPTER() :
m_averageHoleDiameter = 0.0f; m_averageHoleDiameter = 0.0f;
m_averageTrackWidth = 0.0f; m_averageTrackWidth = 0.0f;
SetFlag( FL_USE_REALISTIC_MODE, true );
SetFlag( FL_FP_ATTRIBUTES_NORMAL, true );
SetFlag( FL_SHOW_BOARD_BODY, true );
SetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS, false );
SetFlag( FL_FP_ATTRIBUTES_NORMAL, true );
SetFlag( FL_FP_ATTRIBUTES_NORMAL_INSERT, true );
SetFlag( FL_FP_ATTRIBUTES_VIRTUAL, true );
SetFlag( FL_ZONE, true );
SetFlag( FL_SILKSCREEN, true );
SetFlag( FL_SOLDERMASK, true );
SetFlag( FL_SUBTRACT_MASK_FROM_SILK, false );
SetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS, true );
SetFlag( FL_RENDER_OPENGL_AA_DISABLE_ON_MOVE, false );
SetFlag( FL_RENDER_OPENGL_THICKNESS_DISABLE_ON_MOVE, false );
SetFlag( FL_RENDER_OPENGL_VIAS_DISABLE_ON_MOVE, false );
SetFlag( FL_RENDER_OPENGL_HOLES_DISABLE_ON_MOVE, false );
SetFlag( FL_USE_SELECTION, true );
SetFlag( FL_HIGHLIGHT_ROLLOVER_ITEM, true );
m_BgColorBot = SFVEC4F( 0.4, 0.4, 0.5, 1.0 ); m_BgColorBot = SFVEC4F( 0.4, 0.4, 0.5, 1.0 );
m_BgColorTop = SFVEC4F( 0.8, 0.8, 0.9, 1.0 ); m_BgColorTop = SFVEC4F( 0.8, 0.8, 0.9, 1.0 );
m_BoardBodyColor = SFVEC4F( 0.4, 0.4, 0.5, 0.9 ); m_BoardBodyColor = SFVEC4F( 0.4, 0.4, 0.5, 0.9 );
@ -146,18 +121,6 @@ BOARD_ADAPTER::BOARD_ADAPTER() :
m_frontPlatedPadPolys = nullptr; m_frontPlatedPadPolys = nullptr;
m_backPlatedPadPolys = nullptr; m_backPlatedPadPolys = nullptr;
// Avoid raytracing options not initialized:
m_RtShadowSampleCount = 0;
m_RtReflectionSampleCount = 0;
m_RtRefractionSampleCount = 0;
m_RtSpreadShadows = 0.0;
m_RtSpreadReflections = 0.0;
m_RtSpreadRefractions = 0.0;
m_RtRecursiveReflectionCount = 0;
m_RtRecursiveRefractionCount = 0;
if( !g_ColorsLoaded ) if( !g_ColorsLoaded )
{ {
#define ADD_COLOR( list, r, g, b, a, name ) \ #define ADD_COLOR( list, r, g, b, a, name ) \
@ -242,50 +205,37 @@ bool BOARD_ADAPTER::Is3dLayerEnabled( PCB_LAYER_ID aLayer ) const
{ {
case B_Adhes: case B_Adhes:
case F_Adhes: case F_Adhes:
return GetFlag( FL_ADHESIVE ); return m_Cfg->m_Render.show_adhesive;
case B_Paste: case B_Paste:
case F_Paste: case F_Paste:
return GetFlag( FL_SOLDERPASTE ); return m_Cfg->m_Render.show_solderpaste;
case B_SilkS: case B_SilkS:
case F_SilkS: case F_SilkS:
return GetFlag( FL_SILKSCREEN ); return m_Cfg->m_Render.show_silkscreen;
case B_Mask: case B_Mask:
case F_Mask: case F_Mask:
return GetFlag( FL_SOLDERMASK ); return m_Cfg->m_Render.show_soldermask;
case Dwgs_User: case Dwgs_User:
case Cmts_User: case Cmts_User:
if( GetFlag( FL_USE_REALISTIC_MODE ) ) return !m_Cfg->m_Render.realistic && m_Cfg->m_Render.show_comments;
return false;
return GetFlag( FL_COMMENTS );
case Eco1_User: case Eco1_User:
case Eco2_User: case Eco2_User:
if( GetFlag( FL_USE_REALISTIC_MODE ) ) return !m_Cfg->m_Render.realistic && m_Cfg->m_Render.show_eco;
return false;
return GetFlag( FL_ECO );
case Edge_Cuts: case Edge_Cuts:
if( GetFlag( FL_SHOW_BOARD_BODY ) || GetFlag( FL_USE_REALISTIC_MODE ) ) return !m_Cfg->m_Render.realistic && !m_Cfg->m_Render.show_board_body;
return false;
return true;
case Margin: case Margin:
if( GetFlag( FL_USE_REALISTIC_MODE ) ) return !m_Cfg->m_Render.realistic;
return false;
return true;
case B_Cu: case B_Cu:
case F_Cu: case F_Cu:
return m_board ? m_board->IsLayerVisible( aLayer ) || GetFlag( FL_USE_REALISTIC_MODE ) return !m_board || m_board->IsLayerVisible( aLayer ) || m_Cfg->m_Render.realistic;
: true;
default: default:
// the layer is an internal copper layer, used the visibility // the layer is an internal copper layer, used the visibility
@ -294,30 +244,14 @@ bool BOARD_ADAPTER::Is3dLayerEnabled( PCB_LAYER_ID aLayer ) const
} }
bool BOARD_ADAPTER::GetFlag( DISPLAY3D_FLG aFlag ) const
{
wxASSERT( aFlag < FL_LAST );
return m_drawFlags[aFlag];
}
void BOARD_ADAPTER::SetFlag( DISPLAY3D_FLG aFlag, bool aState )
{
wxASSERT( aFlag < FL_LAST );
m_drawFlags[aFlag] = aState;
}
bool BOARD_ADAPTER::IsFootprintShown( FOOTPRINT_ATTR_T aFPAttributes ) const bool BOARD_ADAPTER::IsFootprintShown( FOOTPRINT_ATTR_T aFPAttributes ) const
{ {
if( aFPAttributes & FP_SMD ) if( aFPAttributes & FP_SMD )
return GetFlag( FL_FP_ATTRIBUTES_NORMAL_INSERT ); return m_Cfg->m_Render.show_footprints_insert;
else if( aFPAttributes & FP_THROUGH_HOLE ) else if( aFPAttributes & FP_THROUGH_HOLE )
return GetFlag( FL_FP_ATTRIBUTES_NORMAL ); return m_Cfg->m_Render.show_footprints_normal;
else else
return GetFlag( FL_FP_ATTRIBUTES_VIRTUAL ); return m_Cfg->m_Render.show_footprints_virtual;
} }
@ -361,30 +295,24 @@ void BOARD_ADAPTER::InitSettings( REPORTER* aStatusReporter, REPORTER* aWarningR
wxString msg; wxString msg;
const bool succeedToGetBoardPolygon = createBoardPolygon( &msg ); const bool haveOutline = createBoardPolygon( &msg );
if( aWarningReporter ) if( aWarningReporter )
{ {
if( !succeedToGetBoardPolygon ) if( !haveOutline )
aWarningReporter->Report( msg, RPT_SEVERITY_WARNING ); aWarningReporter->Report( msg, RPT_SEVERITY_WARNING );
else else
aWarningReporter->Report( wxEmptyString ); aWarningReporter->Report( wxEmptyString );
} }
// Calculates the board bounding box (board outlines + items)
// to ensure any item, even outside the board outlines can be seen
bool boardEdgesOnly = true;
if( ( m_board && m_board->IsFootprintHolder() ) || !GetFlag( FL_USE_REALISTIC_MODE )
|| !succeedToGetBoardPolygon )
{
boardEdgesOnly = false;
}
EDA_RECT bbbox; EDA_RECT bbbox;
if( m_board ) if( m_board )
bbbox = m_board->ComputeBoundingBox( boardEdgesOnly ); {
bbbox = m_board->ComputeBoundingBox( !m_board->IsFootprintHolder()
&& m_Cfg->m_Render.realistic
&& haveOutline );
}
// Gives a non null size to avoid issues in zoom / scale calculations // Gives a non null size to avoid issues in zoom / scale calculations
if( ( bbbox.GetWidth() == 0 ) && ( bbbox.GetHeight() == 0 ) ) if( ( bbbox.GetWidth() == 0 ) && ( bbbox.GetHeight() == 0 ) )
@ -720,14 +648,14 @@ float BOARD_ADAPTER::GetFootprintZPos( bool aIsFlipped ) const
{ {
if( aIsFlipped ) if( aIsFlipped )
{ {
if( GetFlag( FL_SOLDERPASTE ) ) if( m_Cfg->m_Render.show_solderpaste )
return m_layerZcoordBottom[B_SilkS]; return m_layerZcoordBottom[B_SilkS];
else else
return m_layerZcoordBottom[B_Paste]; return m_layerZcoordBottom[B_Paste];
} }
else else
{ {
if( GetFlag( FL_SOLDERPASTE ) ) if( m_Cfg->m_Render.show_solderpaste )
return m_layerZcoordTop[F_SilkS]; return m_layerZcoordTop[F_SilkS];
else else
return m_layerZcoordTop[F_Paste]; return m_layerZcoordTop[F_Paste];
@ -755,3 +683,16 @@ SFVEC4F BOARD_ADAPTER::GetColor( const COLOR4D& aColor ) const
{ {
return SFVEC4F( aColor.r, aColor.g, aColor.b, aColor.a ); return SFVEC4F( aColor.r, aColor.g, aColor.b, aColor.a );
} }
SFVEC2F BOARD_ADAPTER::GetSphericalCoord( int i ) const
{
SFVEC2F sphericalCoord =
SFVEC2F( ( m_Cfg->m_Render.raytrace_lightElevation[i] + 90.0f ) / 180.0f,
m_Cfg->m_Render.raytrace_lightAzimuth[i] / 180.0f );
sphericalCoord.x = glm::clamp( sphericalCoord.x, 0.0f, 1.0f );
sphericalCoord.y = glm::clamp( sphericalCoord.y, 0.0f, 2.0f );
return sphericalCoord;
}

252
3d-viewer/3d_canvas/board_adapter.h
View File

@ -34,6 +34,7 @@
#include "../3d_enums.h" #include "../3d_enums.h"
#include "../3d_cache/3d_cache.h" #include "../3d_cache/3d_cache.h"
#include "../common_ogl/ogl_attr_list.h" #include "../common_ogl/ogl_attr_list.h"
#include "../3d_viewer/eda_3d_viewer_settings.h"
#include <layer_ids.h> #include <layer_ids.h>
#include <pad.h> #include <pad.h>
@ -51,10 +52,10 @@
class COLOR_SETTINGS; class COLOR_SETTINGS;
/// A type that stores a container of 2d objects for each layer id /// A type that stores a container of 2d objects for each layer id
typedef std::map< PCB_LAYER_ID, BVH_CONTAINER_2D *> MAP_CONTAINER_2D_BASE; typedef std::map<PCB_LAYER_ID, BVH_CONTAINER_2D*> MAP_CONTAINER_2D_BASE;
/// A type that stores polysets for each layer id /// A type that stores polysets for each layer id
typedef std::map< PCB_LAYER_ID, SHAPE_POLY_SET *> MAP_POLY; typedef std::map<PCB_LAYER_ID, SHAPE_POLY_SET*> MAP_POLY;
/// This defines the range that all coord will have to be rendered. /// This defines the range that all coord will have to be rendered.
/// It will use this value to convert to a normalized value between /// It will use this value to convert to a normalized value between
@ -90,22 +91,6 @@ public:
return m_3dModelManager; return m_3dModelManager;
} }
/**
* Get a configuration status of a flag.
*
* @param aFlag the flag to get the status.
* @return true if flag is set, false if not.
*/
bool GetFlag( DISPLAY3D_FLG aFlag ) const ;
/**
* Set the status of a flag.
*
* @param aFlag the flag to set the status
* @param aState status to set.
*/
void SetFlag( DISPLAY3D_FLG aFlag, bool aState );
/** /**
* Check if a layer is enabled. * Check if a layer is enabled.
* *
@ -247,72 +232,6 @@ public:
*/ */
float GetFootprintZPos( bool aIsFlipped ) const ; float GetFootprintZPos( bool aIsFlipped ) const ;
/**
* Get the current grid.
*
* @return space type of the grid.
*/
GRID3D_TYPE GetGridType() const noexcept
{
return m_gridType;
}
/**
* Set the current grid.
*
* @param aGridType the type space of the grid.
*/
void SetGridType( GRID3D_TYPE aGridType ) noexcept
{
m_gridType = aGridType;
}
/**
* Get the current antialiasing mode value.
*
* @return antialiasing mode value
*/
ANTIALIASING_MODE GetAntiAliasingMode() const { return m_antiAliasingMode; }
/**
* Set the current antialiasing mode value.
*
* @param aAAmode antialiasing mode value.
*/
void SetAntiAliasingMode( ANTIALIASING_MODE aAAmode ) { m_antiAliasingMode = aAAmode; }
/**
* @param aRenderEngine the render engine mode selected.
*/
void SetRenderEngine( RENDER_ENGINE aRenderEngine ) noexcept
{
m_renderEngine = aRenderEngine;
}
/**
* @return render engine on use.
*/
RENDER_ENGINE GetRenderEngine() const noexcept
{
return m_renderEngine;
}
/**
* @param aMaterialMode the render material mode.
*/
void SetMaterialMode( MATERIAL_MODE aMaterialMode ) noexcept
{
m_materialMode = aMaterialMode;
}
/**
* @return material rendering mode.
*/
MATERIAL_MODE GetMaterialMode() const noexcept
{
return m_materialMode;
}
/** /**
* Get the current polygon of the epoxy board. * Get the current polygon of the epoxy board.
* *
@ -345,6 +264,8 @@ public:
*/ */
SFVEC4F GetColor( const COLOR4D& aColor ) const; SFVEC4F GetColor( const COLOR4D& aColor ) const;
SFVEC2F GetSphericalCoord( int i ) const;
/** /**
* Get the top z position. * Get the top z position.
* *
@ -464,8 +385,6 @@ public:
/** /**
* Get number of vias in this board. * Get number of vias in this board.
*
* @return number of vias.
*/ */
unsigned int GetViaCount() const noexcept unsigned int GetViaCount() const noexcept
{ {
@ -474,8 +393,6 @@ public:
/** /**
* Get number of holes in this board. * Get number of holes in this board.
*
* @return number of holes.
*/ */
unsigned int GetHoleCount() const noexcept unsigned int GetHoleCount() const noexcept
{ {
@ -624,6 +541,10 @@ public:
static KIGFX::COLOR4D g_DefaultBoardBody; static KIGFX::COLOR4D g_DefaultBoardBody;
public: public:
EDA_3D_VIEWER_SETTINGS* m_Cfg;
bool m_IsBoardView;
bool m_MousewheelPanning;
SFVEC4F m_BgColorBot; ///< background bottom color SFVEC4F m_BgColorBot; ///< background bottom color
SFVEC4F m_BgColorTop; ///< background top color SFVEC4F m_BgColorTop; ///< background top color
SFVEC4F m_BoardBodyColor; ///< in realistic mode: FR4 board color SFVEC4F m_BoardBodyColor; ///< in realistic mode: FR4 board color
@ -634,142 +555,71 @@ public:
SFVEC4F m_SilkScreenColorTop; ///< in realistic mode: SilkScreen color ( top ) SFVEC4F m_SilkScreenColorTop; ///< in realistic mode: SilkScreen color ( top )
SFVEC4F m_CopperColor; ///< in realistic mode: copper color SFVEC4F m_CopperColor; ///< in realistic mode: copper color
SFVEC3F m_OpenGlSelectionColor;
// Raytracing light colors
SFVEC3F m_RtCameraLightColor;
SFVEC3F m_RtLightColorTop;
SFVEC3F m_RtLightColorBottom;
std::vector<SFVEC3F> m_RtLightColor;
std::vector<SFVEC2F> m_RtLightSphericalCoords;
// Raytracing options
int m_RtShadowSampleCount;
int m_RtReflectionSampleCount;
int m_RtRefractionSampleCount;
int m_RtRecursiveReflectionCount;
int m_RtRecursiveRefractionCount;
float m_RtSpreadShadows;
float m_RtSpreadReflections;
float m_RtSpreadRefractions;
private: private:
BOARD* m_board; BOARD* m_board;
S3D_CACHE* m_3dModelManager; S3D_CACHE* m_3dModelManager;
COLOR_SETTINGS* m_colors; COLOR_SETTINGS* m_colors;
std::vector< bool > m_drawFlags; wxPoint m_boardPos; ///< Board center position in board internal units.
GRID3D_TYPE m_gridType; wxSize m_boardSize; ///< Board size in board internal units.
RENDER_ENGINE m_renderEngine; SFVEC3F m_boardCenter; ///< 3D center position of the board in 3D units.
MATERIAL_MODE m_materialMode; BBOX_3D m_boardBoundingBox; ///< 3D bounding box of the board in 3D units.
ANTIALIASING_MODE m_antiAliasingMode;
///< Amalgamated polygon contours for various types of items
wxPoint m_boardPos; ///< Board center position in board internal units.
wxSize m_boardSize; ///< Board size in board internal units.
SFVEC3F m_boardCenter; ///< 3D center position of the board in 3D units.
BBOX_3D m_boardBoundingBox; ///< 3D bounding box of the board in 3D units.
///< Polygon contours for each layer.
MAP_POLY m_layers_poly; MAP_POLY m_layers_poly;
SHAPE_POLY_SET* m_frontPlatedPadPolys; SHAPE_POLY_SET* m_frontPlatedPadPolys;
SHAPE_POLY_SET* m_backPlatedPadPolys; SHAPE_POLY_SET* m_backPlatedPadPolys;
///< Polygon contours for hole outer diameters for each layer. MAP_POLY m_layerHoleOdPolys; ///< Hole outer diameters (per layer)
MAP_POLY m_layerHoleOdPolys; MAP_POLY m_layerHoleIdPolys; ///< Hole inner diameters (per layer)
///< Polygon contours for hole inner diameters for each layer. SHAPE_POLY_SET m_nonPlatedThroughHoleOdPolys; ///< NPTH outer diameters
MAP_POLY m_layerHoleIdPolys; SHAPE_POLY_SET m_throughHoleOdPolys; ///< PTH outer diameters
SHAPE_POLY_SET m_throughHoleViaOdPolys; ///< Via hole outer diameters
SHAPE_POLY_SET m_throughHoleAnnularRingPolys; ///< Via annular ring outer diameters
///< Polygon contours for non plated through hole outer diameters. SHAPE_POLY_SET m_board_poly; ///< Board outline polygon.
SHAPE_POLY_SET m_nonPlatedThroughHoleOdPolys;
///< Polygon contours for through hole outer diameters.
SHAPE_POLY_SET m_throughHoleOdPolys;
///< Polygon contours for through holes via outer diameters.
SHAPE_POLY_SET m_throughHoleViaOdPolys;
///< Polygon contours for through hole via annular rings.
SHAPE_POLY_SET m_throughHoleAnnularRingPolys;
SHAPE_POLY_SET m_board_poly; ///< Board outline polygon.
MAP_CONTAINER_2D_BASE m_layerMap; ///< 2D elements for each layer.
MAP_CONTAINER_2D_BASE m_layerMap; ///< 2D elements for each layer.
MAP_CONTAINER_2D_BASE m_layerHoleMap; ///< Holes for each layer.
BVH_CONTAINER_2D* m_platedPadsFront; BVH_CONTAINER_2D* m_platedPadsFront;
BVH_CONTAINER_2D* m_platedPadsBack; BVH_CONTAINER_2D* m_platedPadsBack;
///< The holes per each layer. BVH_CONTAINER_2D m_throughHoleOds; ///< List of PTH outer diameters
MAP_CONTAINER_2D_BASE m_layerHoleMap; BVH_CONTAINER_2D m_throughHoleIds; ///< List of PTH inner diameters
BVH_CONTAINER_2D m_throughHoleAnnularRings; ///< List of via annular rings
BVH_CONTAINER_2D m_throughHoleViaOds; ///< List of via hole outer diameters
BVH_CONTAINER_2D m_throughHoleViaIds; ///< List of via hole inner diameters
///< List of through holes with the radius of the hole inflated with the copper thickness. unsigned int m_copperLayersCount;
BVH_CONTAINER_2D m_throughHoleOds;
///< List of plated through hole annular rings. double m_biuTo3Dunits; ///< Scale factor to convert board internal units to
BVH_CONTAINER_2D m_throughHoleAnnularRings; ///< 3D units normalized between -1.0 and 1.0.
///< List of through hole inner diameters. std::array<float, PCB_LAYER_ID_COUNT> m_layerZcoordTop; ///< Top (End) Z position of each
BVH_CONTAINER_2D m_throughHoleIds; ///< layer in 3D units.
///< List of through hole vias with the radius of the hole inflated with the copper thickness. std::array<float, PCB_LAYER_ID_COUNT> m_layerZcoordBottom; ///< Bottom (Start) Z position of
BVH_CONTAINER_2D m_throughHoleViaOds; ///< each layer in 3D units.
///< List of through hole via inner diameters. float m_copperThickness3DU;
BVH_CONTAINER_2D m_throughHoleViaIds; float m_epoxyThickness3DU;
float m_nonCopperLayerThickness3DU;
float m_solderPasteLayerThickness3DU;
///< Number of copper layers actually used by the board. unsigned int m_trackCount;
unsigned int m_copperLayersCount; float m_averageTrackWidth;
unsigned int m_viaCount;
///< Scale factor to convert board internal units to 3D units normalized between -1.0 and 1.0. float m_averageViaHoleDiameter;
double m_biuTo3Dunits; unsigned int m_holeCount;
float m_averageHoleDiameter;
///< Top (End) Z position of each layer in 3D units.
std::array<float, PCB_LAYER_ID_COUNT> m_layerZcoordTop;
///< Bottom (Start) Z position of each layer in 3D units.
std::array<float, PCB_LAYER_ID_COUNT> m_layerZcoordBottom;
///< Copper thickness in 3D units.
float m_copperThickness3DU;
///< Epoxy thickness in 3D units.
float m_epoxyThickness3DU;
///< Non copper layers thickness in 3D units.
float m_nonCopperLayerThickness3DU;
///< solder paste layers thickness in 3D units.
float m_solderPasteLayerThickness3DU;
///< Number of tracks in the board.
unsigned int m_trackCount;
///< Track average width.
float m_averageTrackWidth;
///< Number of through hole vias in the board.
unsigned int m_viaCount;
///< Computed average diameter of the via holes in 3D units.
float m_averageViaHoleDiameter;
///< Number of holes in the board.
unsigned int m_holeCount;
///< Computed average diameter of the holes in 3D units.
float m_averageHoleDiameter;
/** /**
* Trace mask used to enable or disable the trace output of this class. * Trace mask used to enable or disable debug output for this class. Output can be turned
* The debug output can be turned on by setting the WXTRACE environment variable to * on by setting the WXTRACE environment variable to "KI_TRACE_EDA_CINFO3D_VISU". See the
* "KI_TRACE_EDA_CINFO3D_VISU". See the wxWidgets documentation on wxLogTrace for * wxWidgets documentation on wxLogTrace for more information.
* more information.
*/ */
static const wxChar* m_logTrace; static const wxChar* m_logTrace;

75
3d-viewer/3d_canvas/create_layer_items.cpp
View File

@ -32,11 +32,7 @@
*/ */
#include "board_adapter.h" #include "board_adapter.h"
#include "../3d_rendering/raytracing/shapes2D/ring_2d.h"
#include "../3d_rendering/raytracing/shapes2D/filled_circle_2d.h" #include "../3d_rendering/raytracing/shapes2D/filled_circle_2d.h"
#include "../3d_rendering/raytracing/shapes3D/cylinder_3d.h"
#include <board.h>
#include <board_design_settings.h> #include <board_design_settings.h>
#include <footprint.h> #include <footprint.h>
#include <pad.h> #include <pad.h>
@ -205,14 +201,15 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
BVH_CONTAINER_2D *layerContainer = new BVH_CONTAINER_2D; BVH_CONTAINER_2D *layerContainer = new BVH_CONTAINER_2D;
m_layerMap[curr_layer_id] = layerContainer; m_layerMap[curr_layer_id] = layerContainer;
if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS ) && m_renderEngine == RENDER_ENGINE::OPENGL ) if( m_Cfg->m_Render.opengl_copper_thickness
&& m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
{ {
SHAPE_POLY_SET* layerPoly = new SHAPE_POLY_SET; SHAPE_POLY_SET* layerPoly = new SHAPE_POLY_SET;
m_layers_poly[curr_layer_id] = layerPoly; m_layers_poly[curr_layer_id] = layerPoly;
} }
} }
if( GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) && GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_Cfg->m_Render.renderPlatedPadsAsPlated && m_Cfg->m_Render.realistic )
{ {
m_frontPlatedPadPolys = new SHAPE_POLY_SET; m_frontPlatedPadPolys = new SHAPE_POLY_SET;
m_backPlatedPadPolys = new SHAPE_POLY_SET; m_backPlatedPadPolys = new SHAPE_POLY_SET;
@ -316,16 +313,15 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
hole_inner_radius + thickness, hole_inner_radius + thickness,
*track ) ); *track ) );
if( GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) && if( m_Cfg->m_Render.clip_silk_on_via_annulus && m_Cfg->m_Render.realistic )
GetFlag( FL_USE_REALISTIC_MODE ) )
{ {
m_throughHoleAnnularRings.Add( new FILLED_CIRCLE_2D( via_center, m_throughHoleAnnularRings.Add( new FILLED_CIRCLE_2D( via_center,
ring_radius, ring_radius,
*track ) ); *track ) );
} }
m_throughHoleIds.Add( new FILLED_CIRCLE_2D( via_center, hole_inner_radius, m_throughHoleIds.Add( new FILLED_CIRCLE_2D( via_center, hole_inner_radius,
*track ) ); *track ) );
} }
} }
} }
@ -406,11 +402,11 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
TransformCircleToPolygon( m_throughHoleViaOdPolys, via->GetStart(), TransformCircleToPolygon( m_throughHoleViaOdPolys, via->GetStart(),
hole_outer_radius, ARC_HIGH_DEF, ERROR_INSIDE ); hole_outer_radius, ARC_HIGH_DEF, ERROR_INSIDE );
if( GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) && GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_Cfg->m_Render.clip_silk_on_via_annulus && m_Cfg->m_Render.realistic )
{ {
TransformCircleToPolygon( m_throughHoleAnnularRingPolys, TransformCircleToPolygon( m_throughHoleAnnularRingPolys, via->GetStart(),
via->GetStart(), hole_outer_ring_radius, hole_outer_ring_radius, ARC_HIGH_DEF,
ARC_HIGH_DEF, ERROR_INSIDE ); ERROR_INSIDE );
} }
} }
} }
@ -418,7 +414,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
} }
// Creates vertical outline contours of the tracks and add it to the poly of the layer // Creates vertical outline contours of the tracks and add it to the poly of the layer
if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS ) && m_renderEngine == RENDER_ENGINE::OPENGL ) if( m_Cfg->m_Render.opengl_copper_thickness && m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
{ {
for( PCB_LAYER_ID curr_layer_id : layer_id ) for( PCB_LAYER_ID curr_layer_id : layer_id )
{ {
@ -469,10 +465,8 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
m_throughHoleOds.Add( createPadWithDrill( pad, inflate ) ); m_throughHoleOds.Add( createPadWithDrill( pad, inflate ) );
if( GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) && GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_Cfg->m_Render.clip_silk_on_via_annulus && m_Cfg->m_Render.realistic )
{
m_throughHoleAnnularRings.Add( createPadWithDrill( pad, inflate ) ); m_throughHoleAnnularRings.Add( createPadWithDrill( pad, inflate ) );
}
m_throughHoleIds.Add( createPadWithDrill( pad, 0 ) ); m_throughHoleIds.Add( createPadWithDrill( pad, 0 ) );
} }
@ -496,7 +490,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
if( pad->GetAttribute () != PAD_ATTRIB::NPTH ) if( pad->GetAttribute () != PAD_ATTRIB::NPTH )
{ {
if( GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) && GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_Cfg->m_Render.clip_silk_on_via_annulus && m_Cfg->m_Render.realistic )
{ {
pad->TransformHoleWithClearanceToPolygon( m_throughHoleAnnularRingPolys, pad->TransformHoleWithClearanceToPolygon( m_throughHoleAnnularRingPolys,
inflate, ARC_HIGH_DEF, ERROR_INSIDE ); inflate, ARC_HIGH_DEF, ERROR_INSIDE );
@ -508,7 +502,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
else else
{ {
// If not plated, no copper. // If not plated, no copper.
if( GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) && GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_Cfg->m_Render.clip_silk_on_via_annulus && m_Cfg->m_Render.realistic )
{ {
pad->TransformHoleWithClearanceToPolygon( m_throughHoleAnnularRingPolys, 0, pad->TransformHoleWithClearanceToPolygon( m_throughHoleAnnularRingPolys, 0,
ARC_HIGH_DEF, ERROR_INSIDE ); ARC_HIGH_DEF, ERROR_INSIDE );
@ -520,8 +514,8 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
} }
} }
const bool renderPlatedPadsAsPlated = GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) && const bool renderPlatedPadsAsPlated = m_Cfg->m_Render.renderPlatedPadsAsPlated
GetFlag( FL_USE_REALISTIC_MODE ); && m_Cfg->m_Render.realistic;
// Add footprints PADs objects to containers // Add footprints PADs objects to containers
for( PCB_LAYER_ID curr_layer_id : layer_id ) for( PCB_LAYER_ID curr_layer_id : layer_id )
@ -533,10 +527,10 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
// ADD PADS // ADD PADS
for( FOOTPRINT* footprint : m_board->Footprints() ) for( FOOTPRINT* footprint : m_board->Footprints() )
{ {
// Note: NPTH pads are not drawn on copper layers when the pad // Note: NPTH pads are not drawn on copper layers when the pad has the same shape
// has same shape as its hole // as its hole
addPadsWithClearance( footprint, layerContainer, curr_layer_id, 0, addPadsWithClearance( footprint, layerContainer, curr_layer_id, 0, true,
true, renderPlatedPadsAsPlated, false ); renderPlatedPadsAsPlated, false );
// Micro-wave footprints may have items on copper layers // Micro-wave footprints may have items on copper layers
addFootprintShapesWithClearance( footprint, layerContainer, curr_layer_id, 0 ); addFootprintShapesWithClearance( footprint, layerContainer, curr_layer_id, 0 );
@ -558,7 +552,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
} }
// Add footprints PADs poly contours (vertical outlines) // Add footprints PADs poly contours (vertical outlines)
if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS ) && m_renderEngine == RENDER_ENGINE::OPENGL ) if( m_Cfg->m_Render.opengl_copper_thickness && m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
{ {
for( PCB_LAYER_ID curr_layer_id : layer_id ) for( PCB_LAYER_ID curr_layer_id : layer_id )
{ {
@ -639,7 +633,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
} }
// Add graphic item on copper layers to poly contours (vertical outlines) // Add graphic item on copper layers to poly contours (vertical outlines)
if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS ) && m_renderEngine == RENDER_ENGINE::OPENGL ) if( m_Cfg->m_Render.opengl_copper_thickness && m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
{ {
for( PCB_LAYER_ID cur_layer_id : layer_id ) for( PCB_LAYER_ID cur_layer_id : layer_id )
{ {
@ -678,7 +672,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
} }
} }
if( GetFlag( FL_ZONE ) ) if( m_Cfg->m_Render.show_zones )
{ {
if( aStatusReporter ) if( aStatusReporter )
aStatusReporter->Report( _( "Create zones" ) ); aStatusReporter->Report( _( "Create zones" ) );
@ -725,9 +719,9 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
addSolidAreasShapes( zone, layerContainer->second, layer ); addSolidAreasShapes( zone, layerContainer->second, layer );
} }
if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS ) if( m_Cfg->m_Render.opengl_copper_thickness
&& m_renderEngine == RENDER_ENGINE::OPENGL && m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL
&& layerPolyContainer != m_layers_poly.end() ) && layerPolyContainer != m_layers_poly.end() )
{ {
auto mut_it = layer_lock.find( layer ); auto mut_it = layer_lock.find( layer );
@ -752,9 +746,9 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
if( aStatusReporter ) if( aStatusReporter )
aStatusReporter->Report( _( "Simplifying copper layers polygons" ) ); aStatusReporter->Report( _( "Simplifying copper layers polygons" ) );
if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS ) && m_renderEngine == RENDER_ENGINE::OPENGL ) if( m_Cfg->m_Render.opengl_copper_thickness && m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
{ {
if( GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) && GetFlag( FL_USE_REALISTIC_MODE ) ) if( renderPlatedPadsAsPlated )
{ {
if( m_frontPlatedPadPolys && ( m_layers_poly.find( F_Cu ) != m_layers_poly.end() ) ) if( m_frontPlatedPadPolys && ( m_layers_poly.find( F_Cu ) != m_layers_poly.end() ) )
{ {
@ -782,7 +776,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
std::vector< PCB_LAYER_ID > &selected_layer_id = layer_id; std::vector< PCB_LAYER_ID > &selected_layer_id = layer_id;
std::vector< PCB_LAYER_ID > layer_id_without_F_and_B; std::vector< PCB_LAYER_ID > layer_id_without_F_and_B;
if( GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) && GetFlag( FL_USE_REALISTIC_MODE ) ) if( renderPlatedPadsAsPlated )
{ {
layer_id_without_F_and_B.clear(); layer_id_without_F_and_B.clear();
layer_id_without_F_and_B.reserve( layer_id.size() ); layer_id_without_F_and_B.reserve( layer_id.size() );
@ -799,9 +793,10 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
if( selected_layer_id.size() > 0 ) if( selected_layer_id.size() > 0 )
{ {
if( aStatusReporter ) if( aStatusReporter )
aStatusReporter->Report( wxString::Format( {
_( "Simplifying %d copper layers" ), aStatusReporter->Report( wxString::Format( _( "Simplifying %d copper layers" ),
(int)selected_layer_id.size() ) ); (int) selected_layer_id.size() ) );
}
std::atomic<size_t> nextItem( 0 ); std::atomic<size_t> nextItem( 0 );
std::atomic<size_t> threadsFinished( 0 ); std::atomic<size_t> threadsFinished( 0 );
@ -1025,7 +1020,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
// Draw non copper zones // Draw non copper zones
if( GetFlag( FL_ZONE ) ) if( m_Cfg->m_Render.show_zones )
{ {
for( ZONE* zone : m_board->Zones() ) for( ZONE* zone : m_board->Zones() )
{ {

29
3d-viewer/3d_canvas/eda_3d_canvas.cpp
View File

@ -432,11 +432,11 @@ void EDA_3D_CANVAS::DoRePaint()
{ {
m_3d_render = m_3d_render_opengl; m_3d_render = m_3d_render_opengl;
m_render_raytracing_was_requested = false; m_render_raytracing_was_requested = false;
m_boardAdapter.SetRenderEngine( RENDER_ENGINE::OPENGL ); m_boardAdapter.m_Cfg->m_Render.engine = RENDER_ENGINE::OPENGL;
} }
// Check if a raytacing was requested and need to switch to raytracing mode // Check if a raytacing was requested and need to switch to raytracing mode
if( m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::OPENGL ) if( m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
{ {
const bool was_camera_changed = m_camera.ParametersChanged(); const bool was_camera_changed = m_camera.ParametersChanged();
@ -485,7 +485,7 @@ void EDA_3D_CANVAS::DoRePaint()
bool reloadRaytracingForCalculations = false; bool reloadRaytracingForCalculations = false;
if( m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::OPENGL if( m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL
&& m_3d_render_opengl->IsReloadRequestPending() ) && m_3d_render_opengl->IsReloadRequestPending() )
{ {
reloadRaytracingForCalculations = true; reloadRaytracingForCalculations = true;
@ -593,11 +593,10 @@ void EDA_3D_CANVAS::OnMouseWheel( wxMouseEvent& event )
float delta_move = m_delta_move_step_factor * m_camera.GetZoom(); float delta_move = m_delta_move_step_factor * m_camera.GetZoom();
if( m_boardAdapter.GetFlag( FL_MOUSEWHEEL_PANNING ) ) if( m_boardAdapter.m_MousewheelPanning )
delta_move *= 0.01f * event.GetWheelRotation(); delta_move *= 0.01f * event.GetWheelRotation();
else else if( event.GetWheelRotation() < 0 )
if( event.GetWheelRotation() < 0 ) delta_move = -delta_move;
delta_move = -delta_move;
// mousewheel_panning enabled: // mousewheel_panning enabled:
// wheel -> pan; // wheel -> pan;
@ -608,7 +607,7 @@ void EDA_3D_CANVAS::OnMouseWheel( wxMouseEvent& event )
// wheel + ctrl -> horizontal scrolling; // wheel + ctrl -> horizontal scrolling;
// wheel -> zooming. // wheel -> zooming.
if( m_boardAdapter.GetFlag( FL_MOUSEWHEEL_PANNING ) && !event.ControlDown() ) if( m_boardAdapter.m_MousewheelPanning && !event.ControlDown() )
{ {
if( event.GetWheelAxis() == wxMOUSE_WHEEL_HORIZONTAL || event.ShiftDown() ) if( event.GetWheelAxis() == wxMOUSE_WHEEL_HORIZONTAL || event.ShiftDown() )
m_camera.Pan( SFVEC3F( -delta_move, 0.0f, 0.0f ) ); m_camera.Pan( SFVEC3F( -delta_move, 0.0f, 0.0f ) );
@ -617,12 +616,12 @@ void EDA_3D_CANVAS::OnMouseWheel( wxMouseEvent& event )
mouseActivity = true; mouseActivity = true;
} }
else if( event.ShiftDown() && !m_boardAdapter.GetFlag( FL_MOUSEWHEEL_PANNING ) ) else if( event.ShiftDown() && !m_boardAdapter.m_MousewheelPanning )
{ {
m_camera.Pan( SFVEC3F( 0.0f, -delta_move, 0.0f ) ); m_camera.Pan( SFVEC3F( 0.0f, -delta_move, 0.0f ) );
mouseActivity = true; mouseActivity = true;
} }
else if( event.ControlDown() && !m_boardAdapter.GetFlag( FL_MOUSEWHEEL_PANNING ) ) else if( event.ControlDown() && !m_boardAdapter.m_MousewheelPanning )
{ {
m_camera.Pan( SFVEC3F( delta_move, 0.0f, 0.0f ) ); m_camera.Pan( SFVEC3F( delta_move, 0.0f, 0.0f ) );
mouseActivity = true; mouseActivity = true;
@ -699,7 +698,7 @@ void EDA_3D_CANVAS::OnMouseMove( wxMouseEvent& event )
m_camera.SetCurMousePosition( nativePosition ); m_camera.SetCurMousePosition( nativePosition );
if( !event.Dragging() && m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::OPENGL ) if( !event.Dragging() && m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
{ {
STATUSBAR_REPORTER reporter( m_parentStatusBar, STATUSBAR_REPORTER reporter( m_parentStatusBar,
static_cast<int>( EDA_3D_VIEWER_STATUSBAR::HOVERED_ITEM ) ); static_cast<int>( EDA_3D_VIEWER_STATUSBAR::HOVERED_ITEM ) );
@ -777,7 +776,8 @@ void EDA_3D_CANVAS::OnMouseMove( wxMouseEvent& event )
} }
else else
{ {
if( m_currentRollOverItem && m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::OPENGL ) if( m_currentRollOverItem
&& m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
{ {
m_3d_render_opengl->SetCurrentRollOverItem( nullptr ); m_3d_render_opengl->SetCurrentRollOverItem( nullptr );
Request_refresh(); Request_refresh();
@ -1111,7 +1111,10 @@ bool EDA_3D_CANVAS::SetView3D( int aKeycode )
void EDA_3D_CANVAS::RenderEngineChanged() void EDA_3D_CANVAS::RenderEngineChanged()
{ {
switch( m_boardAdapter.GetRenderEngine() ) SETTINGS_MANAGER& mgr = Pgm().GetSettingsManager();
EDA_3D_VIEWER_SETTINGS* cfg = mgr.GetAppSettings<EDA_3D_VIEWER_SETTINGS>();
switch( cfg->m_Render.engine )
{ {
case RENDER_ENGINE::OPENGL: m_3d_render = m_3d_render_opengl; break; case RENDER_ENGINE::OPENGL: m_3d_render = m_3d_render_opengl; break;
case RENDER_ENGINE::RAYTRACING: m_3d_render = m_3d_render_raytracing; break; case RENDER_ENGINE::RAYTRACING: m_3d_render = m_3d_render_raytracing; break;

52
3d-viewer/3d_enums.h
View File

@ -30,52 +30,6 @@
#ifndef _3D_ENUMS_H_ #ifndef _3D_ENUMS_H_
#define _3D_ENUMS_H_ #define _3D_ENUMS_H_
/// Flags used in rendering options
enum DISPLAY3D_FLG
{
FL_AXIS = 0,
FL_ZONE,
FL_ADHESIVE,
FL_SILKSCREEN,
FL_SOLDERMASK,
FL_SOLDERPASTE,
FL_COMMENTS,
FL_ECO,
FL_FP_ATTRIBUTES_NORMAL,
FL_FP_ATTRIBUTES_NORMAL_INSERT,
FL_FP_ATTRIBUTES_VIRTUAL,
FL_USE_SELECTION,
FL_HIGHLIGHT_ROLLOVER_ITEM,
FL_SHOW_BOARD_BODY,
FL_MOUSEWHEEL_PANNING,
FL_USE_REALISTIC_MODE,
FL_SUBTRACT_MASK_FROM_SILK,
FL_CLIP_SILK_ON_VIA_ANNULUS,
FL_RENDER_PLATED_PADS_AS_PLATED,
// OpenGL options
FL_RENDER_OPENGL_SHOW_MODEL_BBOX,
FL_RENDER_OPENGL_COPPER_THICKNESS,
FL_RENDER_OPENGL_AA_DISABLE_ON_MOVE,
FL_RENDER_OPENGL_THICKNESS_DISABLE_ON_MOVE,
FL_RENDER_OPENGL_VIAS_DISABLE_ON_MOVE,
FL_RENDER_OPENGL_HOLES_DISABLE_ON_MOVE,
// Raytracing options
FL_RENDER_RAYTRACING_SHADOWS,
FL_RENDER_RAYTRACING_BACKFLOOR,
FL_RENDER_RAYTRACING_REFRACTIONS,
FL_RENDER_RAYTRACING_REFLECTIONS,
FL_RENDER_RAYTRACING_POST_PROCESSING,
FL_RENDER_RAYTRACING_ANTI_ALIASING,
FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES,
FL_LAST
};
/// Rotation direction for the 3d canvas /// Rotation direction for the 3d canvas
enum class ROTATION_DIR enum class ROTATION_DIR
{ {
@ -96,7 +50,7 @@ enum class CAMERA_TYPE
/// Grid types /// Grid types
enum class GRID3D_TYPE enum GRID3D_TYPE
{ {
NONE, NONE,
GRID_1MM, GRID_1MM,
@ -107,7 +61,7 @@ enum class GRID3D_TYPE
/// Render engine mode /// Render engine mode
enum class RENDER_ENGINE enum RENDER_ENGINE
{ {
OPENGL, OPENGL,
RAYTRACING, RAYTRACING,
@ -115,7 +69,7 @@ enum class RENDER_ENGINE
/// Render 3d model shape materials mode /// Render 3d model shape materials mode
enum class MATERIAL_MODE enum MATERIAL_MODE
{ {
NORMAL, ///< Use all material properties from model file NORMAL, ///< Use all material properties from model file
DIFFUSE_ONLY, ///< Use only diffuse material properties DIFFUSE_ONLY, ///< Use only diffuse material properties

84
3d-viewer/3d_rendering/opengl/create_scene.cpp
View File

@ -451,7 +451,7 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
// Create Board // Create Board
m_board = createBoard( m_boardAdapter.GetBoardPoly(), &m_boardAdapter.GetThroughHoleIds() ); m_board = createBoard( m_boardAdapter.GetBoardPoly(), &m_boardAdapter.GetThroughHoleIds() );
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.m_Cfg->m_Render.realistic )
{ {
m_antiBoardPolys.RemoveAllContours(); m_antiBoardPolys.RemoveAllContours();
m_antiBoardPolys.NewOutline(); m_antiBoardPolys.NewOutline();
@ -483,7 +483,7 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
SHAPE_POLY_SET outerPolyTHT = m_boardAdapter.GetThroughHoleOdPolys(); SHAPE_POLY_SET outerPolyTHT = m_boardAdapter.GetThroughHoleOdPolys();
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.m_Cfg->m_Render.realistic )
outerPolyTHT.BooleanIntersection( m_boardAdapter.GetBoardPoly(), outerPolyTHT.BooleanIntersection( m_boardAdapter.GetBoardPoly(),
SHAPE_POLY_SET::PM_STRICTLY_SIMPLE ); SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
@ -495,8 +495,8 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
m_boardAdapter.GetThroughHoleViaOds().GetList(), m_boardAdapter.GetThroughHoleViaOds().GetList(),
m_boardAdapter.GetThroughHoleViaOdPolys(), 1.0f, 0.0f, false ); m_boardAdapter.GetThroughHoleViaOdPolys(), 1.0f, 0.0f, false );
if( m_boardAdapter.GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) && if( m_boardAdapter.m_Cfg->m_Render.clip_silk_on_via_annulus &&
m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) m_boardAdapter.m_Cfg->m_Render.realistic )
{ {
m_outerThroughHoleRings = generateHoles( m_outerThroughHoleRings = generateHoles(
m_boardAdapter.GetThroughHoleAnnularRings().GetList(), m_boardAdapter.GetThroughHoleAnnularRings().GetList(),
@ -557,8 +557,10 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
continue; continue;
if( aStatusReporter ) if( aStatusReporter )
aStatusReporter->Report( wxString::Format( {
_( "Load OpenGL layer %d" ), (int)layer_id ) ); aStatusReporter->Report( wxString::Format( _( "Load OpenGL layer %d" ),
(int) layer_id ) );
}
const BVH_CONTAINER_2D* container2d = ii.second; const BVH_CONTAINER_2D* container2d = ii.second;
@ -571,12 +573,12 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
{ {
polyListSubtracted = *map_poly.at( layer_id );; polyListSubtracted = *map_poly.at( layer_id );;
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.m_Cfg->m_Render.realistic )
{ {
polyListSubtracted.BooleanIntersection( m_boardAdapter.GetBoardPoly(), polyListSubtracted.BooleanIntersection( m_boardAdapter.GetBoardPoly(),
SHAPE_POLY_SET::PM_FAST ); SHAPE_POLY_SET::PM_FAST );
if( ( layer_id != B_Mask ) && ( layer_id != F_Mask ) ) if( layer_id != B_Mask && layer_id != F_Mask )
{ {
polyListSubtracted.BooleanSubtract( m_boardAdapter.GetThroughHoleOdPolys(), polyListSubtracted.BooleanSubtract( m_boardAdapter.GetThroughHoleOdPolys(),
SHAPE_POLY_SET::PM_FAST ); SHAPE_POLY_SET::PM_FAST );
@ -585,7 +587,7 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
SHAPE_POLY_SET::PM_FAST ); SHAPE_POLY_SET::PM_FAST );
} }
if( m_boardAdapter.GetFlag( FL_SUBTRACT_MASK_FROM_SILK ) ) if( m_boardAdapter.m_Cfg->m_Render.subtract_mask_from_silk )
{ {
if( layer_id == B_SilkS && map_poly.find( B_Mask ) != map_poly.end() ) if( layer_id == B_SilkS && map_poly.find( B_Mask ) != map_poly.end() )
{ {
@ -611,8 +613,8 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
} }
if( m_boardAdapter.GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) && if( m_boardAdapter.m_Cfg->m_Render.renderPlatedPadsAsPlated
m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) && m_boardAdapter.m_Cfg->m_Render.realistic )
{ {
if( m_boardAdapter.GetFrontPlatedPadPolys() ) if( m_boardAdapter.GetFrontPlatedPadPolys() )
{ {
@ -652,8 +654,7 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
if( aStatusReporter ) if( aStatusReporter )
{ {
// Calculation time in seconds // Calculation time in seconds
const double calculation_time = (double)( GetRunningMicroSecs() - double calculation_time = (double)( GetRunningMicroSecs() - stats_startReloadTime) / 1e6;
stats_startReloadTime) / 1e6;
aStatusReporter->Report( wxString::Format( _( "Reload time %.3f s" ), calculation_time ) ); aStatusReporter->Report( wxString::Format( _( "Reload time %.3f s" ), calculation_time ) );
} }
@ -674,10 +675,10 @@ void RENDER_3D_OPENGL::addTopAndBottomTriangles( TRIANGLE_DISPLAY_LIST* aDst, co
} }
void RENDER_3D_OPENGL::getLayerZPos( PCB_LAYER_ID aLayerID, float& aOutZtop, float& aOutZbot ) const void RENDER_3D_OPENGL::getLayerZPos( PCB_LAYER_ID aLayer, float& aOutZtop, float& aOutZbot ) const
{ {
aOutZbot = m_boardAdapter.GetLayerBottomZPos( aLayerID ); aOutZbot = m_boardAdapter.GetLayerBottomZPos( aLayer );
aOutZtop = m_boardAdapter.GetLayerTopZPos( aLayerID ); aOutZtop = m_boardAdapter.GetLayerTopZPos( aLayer );
if( aOutZtop < aOutZbot ) if( aOutZtop < aOutZbot )
{ {
@ -732,13 +733,11 @@ void RENDER_3D_OPENGL::generateViasAndPads()
if( m_boardAdapter.GetViaCount() > 0 ) if( m_boardAdapter.GetViaCount() > 0 )
{ {
const unsigned int reserve_nr_triangles_estimation = float averageDiameter = m_boardAdapter.GetAverageViaHoleDiameter();
m_boardAdapter.GetCircleSegmentCount( unsigned int averageSegCount = m_boardAdapter.GetCircleSegmentCount( averageDiameter );
m_boardAdapter.GetAverageViaHoleDiameter() ) * 8 * unsigned int trianglesEstimate = averageSegCount * 8 * m_boardAdapter.GetViaCount();
m_boardAdapter.GetViaCount();
TRIANGLE_DISPLAY_LIST* layerTriangleVIA = TRIANGLE_DISPLAY_LIST* layerTriangleVIA = new TRIANGLE_DISPLAY_LIST( trianglesEstimate );
new TRIANGLE_DISPLAY_LIST( reserve_nr_triangles_estimation );
// Insert plated vertical holes inside the board // Insert plated vertical holes inside the board
@ -811,29 +810,27 @@ void RENDER_3D_OPENGL::generateViasAndPads()
// Subtract the holes // Subtract the holes
tht_outer_holes_poly.BooleanSubtract( tht_inner_holes_poly, SHAPE_POLY_SET::PM_FAST ); tht_outer_holes_poly.BooleanSubtract( tht_inner_holes_poly, SHAPE_POLY_SET::PM_FAST );
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.m_Cfg->m_Render.realistic )
tht_outer_holes_poly.BooleanSubtract( m_antiBoardPolys, SHAPE_POLY_SET::PM_FAST ); tht_outer_holes_poly.BooleanSubtract( m_antiBoardPolys, SHAPE_POLY_SET::PM_FAST );
CONTAINER_2D holesContainer; CONTAINER_2D holesContainer;
ConvertPolygonToTriangles( tht_outer_holes_poly, holesContainer, ConvertPolygonToTriangles( tht_outer_holes_poly, holesContainer,
m_boardAdapter.BiuTo3dUnits(), m_boardAdapter.BiuTo3dUnits(), *m_boardAdapter.GetBoard() );
(const BOARD_ITEM &)*m_boardAdapter.GetBoard() );
const LIST_OBJECT2D& listHolesObject2d = holesContainer.GetList(); const LIST_OBJECT2D& holes2D = holesContainer.GetList();
if( listHolesObject2d.size() > 0 ) if( holes2D.size() > 0 )
{ {
float layer_z_top, layer_z_bot, dummy; float layer_z_top, layer_z_bot, dummy;
getLayerZPos( F_Cu, layer_z_top, dummy ); getLayerZPos( F_Cu, layer_z_top, dummy );
getLayerZPos( B_Cu, dummy, layer_z_bot ); getLayerZPos( B_Cu, dummy, layer_z_bot );
TRIANGLE_DISPLAY_LIST* layerTriangles = TRIANGLE_DISPLAY_LIST* layerTriangles = new TRIANGLE_DISPLAY_LIST( holes2D.size() );
new TRIANGLE_DISPLAY_LIST( listHolesObject2d.size() );
// Convert the list of objects(triangles) to triangle layer structure // Convert the list of objects(triangles) to triangle layer structure
for( const OBJECT_2D* itemOnLayer : listHolesObject2d ) for( const OBJECT_2D* itemOnLayer : holes2D )
{ {
const OBJECT_2D* object2d_A = itemOnLayer; const OBJECT_2D* object2d_A = itemOnLayer;
@ -889,9 +886,9 @@ void RENDER_3D_OPENGL::load3dModels( REPORTER* aStatusReporter )
if( !m_boardAdapter.GetBoard() ) if( !m_boardAdapter.GetBoard() )
return; return;
if( !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_NORMAL ) if( !m_boardAdapter.m_Cfg->m_Render.show_footprints_normal
&& !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_NORMAL_INSERT ) && !m_boardAdapter.m_Cfg->m_Render.show_footprints_insert
&& !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_VIRTUAL ) ) && !m_boardAdapter.m_Cfg->m_Render.show_footprints_virtual )
{ {
return; return;
} }
@ -899,35 +896,34 @@ void RENDER_3D_OPENGL::load3dModels( REPORTER* aStatusReporter )
// Go for all footprints // Go for all footprints
for( const FOOTPRINT* footprint : m_boardAdapter.GetBoard()->Footprints() ) for( const FOOTPRINT* footprint : m_boardAdapter.GetBoard()->Footprints() )
{ {
for( const FP_3DMODEL& model : footprint->Models() ) for( const FP_3DMODEL& fp_model : footprint->Models() )
{ {
if( model.m_Show && !model.m_Filename.empty() ) if( fp_model.m_Show && !fp_model.m_Filename.empty() )
{ {
if( aStatusReporter ) if( aStatusReporter )
{ {
// Display the short filename of the 3D model loaded: // Display the short filename of the 3D fp_model loaded:
// (the full name is usually too long to be displayed) // (the full name is usually too long to be displayed)
wxFileName fn( model.m_Filename ); wxFileName fn( fp_model.m_Filename );
aStatusReporter->Report( wxString::Format( _( "Loading %s..." ), aStatusReporter->Report( wxString::Format( _( "Loading %s..." ),
fn.GetFullName() ) ); fn.GetFullName() ) );
} }
// Check if the model is not present in our cache map // Check if the fp_model is not present in our cache map
// (Not already loaded in memory) // (Not already loaded in memory)
if( m_3dModelMap.find( model.m_Filename ) == m_3dModelMap.end() ) if( m_3dModelMap.find( fp_model.m_Filename ) == m_3dModelMap.end() )
{ {
// It is not present, try get it from cache // It is not present, try get it from cache
const S3DMODEL* modelPtr = const S3DMODEL* modelPtr =
m_boardAdapter.Get3dCacheManager()->GetModel( model.m_Filename ); m_boardAdapter.Get3dCacheManager()->GetModel( fp_model.m_Filename );
// only add it if the return is not NULL // only add it if the return is not NULL
if( modelPtr ) if( modelPtr )
{ {
MATERIAL_MODE materialMode = m_boardAdapter.GetMaterialMode(); int materialMode = m_boardAdapter.m_Cfg->m_Render.material_mode;
MODEL_3D* ogl_model = new MODEL_3D( *modelPtr, materialMode ); MODEL_3D* model = new MODEL_3D( *modelPtr, (MATERIAL_MODE) materialMode );
if( ogl_model ) m_3dModelMap[ fp_model.m_Filename ] = model;
m_3dModelMap[ model.m_Filename ] = ogl_model;
} }
} }
} }

108
3d-viewer/3d_rendering/opengl/render_3d_opengl.cpp
View File

@ -169,7 +169,7 @@ void RENDER_3D_OPENGL::setupMaterials()
{ {
m_materials = {}; m_materials = {};
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.m_Cfg->m_Render.realistic )
{ {
// http://devernay.free.fr/cours/opengl/materials.html // http://devernay.free.fr/cours/opengl/materials.html
@ -328,7 +328,7 @@ void RENDER_3D_OPENGL::setLayerMaterial( PCB_LAYER_ID aLayerID )
// Convert Opacity to Transparency // Convert Opacity to Transparency
m_materials.m_SolderMask.m_Transparency = 1.0f - layerColor.a; m_materials.m_SolderMask.m_Transparency = 1.0f - layerColor.a;
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) 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_Ambient = m_materials.m_SolderMask.m_Diffuse * 0.3f;
@ -395,7 +395,7 @@ SFVEC4F RENDER_3D_OPENGL::getLayerColor( PCB_LAYER_ID aLayerID )
{ {
SFVEC4F layerColor = m_boardAdapter.GetLayerColor( aLayerID ); SFVEC4F layerColor = m_boardAdapter.GetLayerColor( aLayerID );
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.m_Cfg->m_Render.realistic )
{ {
switch( aLayerID ) switch( aLayerID )
{ {
@ -563,16 +563,16 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
reload( aStatusReporter, aWarningReporter ); reload( aStatusReporter, aWarningReporter );
// generate a new 3D grid as the size of the board may had changed // generate a new 3D grid as the size of the board may had changed
m_lastGridType = m_boardAdapter.GetGridType(); m_lastGridType = static_cast<GRID3D_TYPE>( m_boardAdapter.m_Cfg->m_Render.grid_type );
generate3dGrid( m_lastGridType ); generate3dGrid( m_lastGridType );
} }
else else
{ {
// Check if grid was changed // Check if grid was changed
if( m_boardAdapter.GetGridType() != m_lastGridType ) if( m_boardAdapter.m_Cfg->m_Render.grid_type != m_lastGridType )
{ {
// and generate a new one // and generate a new one
m_lastGridType = m_boardAdapter.GetGridType(); m_lastGridType = static_cast<GRID3D_TYPE>( m_boardAdapter.m_Cfg->m_Render.grid_type );
generate3dGrid( m_lastGridType ); generate3dGrid( m_lastGridType );
} }
} }
@ -586,7 +586,7 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
glEnable( GL_NORMALIZE ); // This allow OpenGL to normalize the normals after transformations glEnable( GL_NORMALIZE ); // This allow OpenGL to normalize the normals after transformations
glViewport( 0, 0, m_windowSize.x, m_windowSize.y ); glViewport( 0, 0, m_windowSize.x, m_windowSize.y );
if( m_boardAdapter.GetFlag( FL_RENDER_OPENGL_AA_DISABLE_ON_MOVE ) && aIsMoving ) if( aIsMoving && m_boardAdapter.m_Cfg->m_Render.opengl_AA_disableOnMove )
glDisable( GL_MULTISAMPLE ); glDisable( GL_MULTISAMPLE );
else else
glEnable( GL_MULTISAMPLE ); glEnable( GL_MULTISAMPLE );
@ -627,13 +627,9 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
float zpos; float zpos;
if( cameraPos.z > 0.0f ) if( cameraPos.z > 0.0f )
{
zpos = glm::max( cameraPos.z, 0.5f ) + cameraPos.z * cameraPos.z; zpos = glm::max( cameraPos.z, 0.5f ) + cameraPos.z * cameraPos.z;
}
else else
{
zpos = glm::min( cameraPos.z,-0.5f ) - cameraPos.z * cameraPos.z; zpos = glm::min( cameraPos.z,-0.5f ) - cameraPos.z * cameraPos.z;
}
// This is a point light. // This is a point light.
const GLfloat headlight_pos[] = { cameraPos.x, cameraPos.y, zpos, 1.0f }; const GLfloat headlight_pos[] = { cameraPos.x, cameraPos.y, zpos, 1.0f };
@ -641,16 +637,13 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
glLightfv( GL_LIGHT0, GL_POSITION, headlight_pos ); glLightfv( GL_LIGHT0, GL_POSITION, headlight_pos );
} }
const bool drawMiddleSegments = !( aIsMoving && bool skipThickness = aIsMoving && m_boardAdapter.m_Cfg->m_Render.opengl_thickness_disableOnMove;
m_boardAdapter.GetFlag( FL_RENDER_OPENGL_THICKNESS_DISABLE_ON_MOVE ) ); bool skipRenderHoles = aIsMoving && m_boardAdapter.m_Cfg->m_Render.opengl_holes_disableOnMove;
bool skipRenderVias = aIsMoving && m_boardAdapter.m_Cfg->m_Render.opengl_vias_disableOnMove;
const bool skipRenderHoles = aIsMoving && bool drawMiddleSegments = !skipThickness;
m_boardAdapter.GetFlag( FL_RENDER_OPENGL_HOLES_DISABLE_ON_MOVE );
const bool skipRenderVias = aIsMoving && if( m_boardAdapter.m_Cfg->m_Render.realistic )
m_boardAdapter.GetFlag( FL_RENDER_OPENGL_VIAS_DISABLE_ON_MOVE );
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
{ {
// Draw vias and pad holes with copper material // Draw vias and pad holes with copper material
setLayerMaterial( B_Cu ); setLayerMaterial( B_Cu );
@ -680,8 +673,8 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
// So avoid creating them is they are not very visible // So avoid creating them is they are not very visible
const double opacity_min = 0.8; const double opacity_min = 0.8;
if( m_boardAdapter.GetFlag( FL_SHOW_BOARD_BODY ) && if( m_boardAdapter.m_Cfg->m_Render.show_board_body
( m_boardAdapter.m_BoardBodyColor.a > opacity_min ) ) && m_boardAdapter.m_BoardBodyColor.a > opacity_min )
{ {
if( ( layer_id > F_Cu ) && ( layer_id < B_Cu ) ) if( ( layer_id > F_Cu ) && ( layer_id < B_Cu ) )
continue; continue;
@ -693,21 +686,26 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
if( ( layer_id >= F_Cu ) && ( layer_id <= B_Cu ) ) if( ( layer_id >= F_Cu ) && ( layer_id <= B_Cu ) )
{ {
if( !m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) || if( m_boardAdapter.m_Cfg->m_Render.renderPlatedPadsAsPlated
!( m_boardAdapter.GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) && && m_boardAdapter.m_Cfg->m_Render.realistic )
m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) ) {
setLayerMaterial( layer_id );
else
setCopperMaterial(); setCopperMaterial();
}
else
{
setLayerMaterial( layer_id );
}
if( skipRenderHoles ) if( skipRenderHoles )
{ {
pLayerDispList->DrawAllCameraCulled( m_camera.GetPos().z, drawMiddleSegments ); pLayerDispList->DrawAllCameraCulled( m_camera.GetPos().z, drawMiddleSegments );
// Draw copper plated pads // Draw copper plated pads
if( ( ( layer_id == F_Cu ) || ( layer_id == B_Cu ) ) && if( ( layer_id == F_Cu || layer_id == B_Cu )
( m_platedPadsFront || m_platedPadsBack ) ) && ( m_platedPadsFront || m_platedPadsBack ) )
{
setPlatedCopperAndDepthOffset( layer_id ); setPlatedCopperAndDepthOffset( layer_id );
}
if( layer_id == F_Cu && m_platedPadsFront ) if( layer_id == F_Cu && m_platedPadsFront )
{ {
@ -814,33 +812,32 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
setLayerMaterial( layer_id ); setLayerMaterial( layer_id );
OPENGL_RENDER_LIST* throughHolesOuter = OPENGL_RENDER_LIST* throughHolesOuter =
m_boardAdapter.GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) m_boardAdapter.m_Cfg->m_Render.clip_silk_on_via_annulus
&& m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) && m_boardAdapter.m_Cfg->m_Render.realistic
&& ( layer_id == B_SilkS || layer_id == F_SilkS ) && ( layer_id == B_SilkS || layer_id == F_SilkS ) ? m_outerThroughHoleRings
? m_outerThroughHoleRings : m_outerThroughHoles;
: m_outerThroughHoles;
if( throughHolesOuter ) if( throughHolesOuter )
{ {
throughHolesOuter->ApplyScalePosition( throughHolesOuter->ApplyScalePosition( pLayerDispList->GetZBot(),
pLayerDispList->GetZBot(), pLayerDispList->GetZTop()
pLayerDispList->GetZTop() - pLayerDispList->GetZBot() ); - pLayerDispList->GetZBot() );
} }
OPENGL_RENDER_LIST* anti_board = m_antiBoard; OPENGL_RENDER_LIST* anti_board = m_antiBoard;
if( anti_board ) if( anti_board )
{ {
anti_board->ApplyScalePosition( anti_board->ApplyScalePosition( pLayerDispList->GetZBot(),
pLayerDispList->GetZBot(), pLayerDispList->GetZTop()
pLayerDispList->GetZTop() - pLayerDispList->GetZBot() ); - pLayerDispList->GetZBot() );
} }
if( !skipRenderHoles if( !skipRenderHoles
&& m_boardAdapter.GetFlag( FL_SUBTRACT_MASK_FROM_SILK ) && m_boardAdapter.m_Cfg->m_Render.subtract_mask_from_silk
&& m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) && m_boardAdapter.m_Cfg->m_Render.realistic
&& ( ( layer_id == B_SilkS && m_layers.find( B_Mask ) != m_layers.end() ) && ( ( layer_id == B_SilkS && m_layers.find( B_Mask ) != m_layers.end() )
|| ( layer_id == F_SilkS && m_layers.find( F_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 PCB_LAYER_ID layerMask_id = (layer_id == B_SilkS) ? B_Mask : F_Mask;
@ -880,13 +877,11 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
render3dModels( true, false ); render3dModels( true, false );
// Display board body // Display board body
if( m_boardAdapter.GetFlag( FL_SHOW_BOARD_BODY ) ) if( m_boardAdapter.m_Cfg->m_Render.show_board_body )
{
renderBoardBody( skipRenderHoles ); renderBoardBody( skipRenderHoles );
}
// Display transparent mask layers // Display transparent mask layers
if( m_boardAdapter.GetFlag( FL_SOLDERMASK ) ) if( m_boardAdapter.m_Cfg->m_Render.show_soldermask )
{ {
// add a depth buffer offset, it will help to hide some artifacts // add a depth buffer offset, it will help to hide some artifacts
// on silkscreen where the SolderMask is removed // on silkscreen where the SolderMask is removed
@ -949,7 +944,7 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
glDepthMask( GL_TRUE ); glDepthMask( GL_TRUE );
// Render Grid // Render Grid
if( m_boardAdapter.GetGridType() != GRID3D_TYPE::NONE ) if( m_boardAdapter.m_Cfg->m_Render.grid_type != GRID3D_TYPE::NONE )
{ {
glDisable( GL_LIGHTING ); glDisable( GL_LIGHTING );
@ -960,7 +955,7 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
} }
// Render 3D arrows // Render 3D arrows
if( m_boardAdapter.GetFlag( FL_AXIS ) ) if( m_boardAdapter.m_Cfg->m_Render.show_axis )
render3dArrows(); render3dArrows();
// Return back to the original viewport (this is important if we want // Return back to the original viewport (this is important if we want
@ -1186,12 +1181,12 @@ void RENDER_3D_OPENGL::render3dModelsSelected( bool aRenderTopOrBot, bool aRende
{ {
bool highlight = false; bool highlight = false;
if( m_boardAdapter.GetFlag( FL_USE_SELECTION ) ) if( m_boardAdapter.m_IsBoardView )
{ {
if( fp->IsSelected() ) if( fp->IsSelected() )
highlight = true; highlight = true;
if( m_boardAdapter.GetFlag( FL_HIGHLIGHT_ROLLOVER_ITEM ) && fp == m_currentRollOverItem ) if( m_boardAdapter.m_Cfg->m_Render.opengl_highlight_on_rollover )
highlight = true; highlight = true;
if( aRenderSelectedOnly != highlight ) if( aRenderSelectedOnly != highlight )
@ -1214,7 +1209,7 @@ void RENDER_3D_OPENGL::render3dModelsSelected( bool aRenderTopOrBot, bool aRende
void RENDER_3D_OPENGL::render3dModels( bool aRenderTopOrBot, bool aRenderTransparentOnly ) void RENDER_3D_OPENGL::render3dModels( bool aRenderTopOrBot, bool aRenderTransparentOnly )
{ {
if( m_boardAdapter.GetFlag( FL_USE_SELECTION ) ) if( m_boardAdapter.m_IsBoardView )
render3dModelsSelected( aRenderTopOrBot, aRenderTransparentOnly, true ); render3dModelsSelected( aRenderTopOrBot, aRenderTransparentOnly, true );
render3dModelsSelected( aRenderTopOrBot, aRenderTransparentOnly, false ); render3dModelsSelected( aRenderTopOrBot, aRenderTransparentOnly, false );
@ -1227,6 +1222,8 @@ void RENDER_3D_OPENGL::renderFootprint( const FOOTPRINT* aFootprint, bool aRende
if( !aFootprint->Models().empty() ) if( !aFootprint->Models().empty() )
{ {
const double zpos = m_boardAdapter.GetFootprintZPos( aFootprint->IsFlipped() ); const double zpos = m_boardAdapter.GetFootprintZPos( aFootprint->IsFlipped() );
SFVEC3F selColor = m_boardAdapter.GetColor( m_boardAdapter.m_Cfg->m_Render.opengl_selection_color );
glPushMatrix(); glPushMatrix();
@ -1287,15 +1284,14 @@ void RENDER_3D_OPENGL::renderFootprint( const FOOTPRINT* aFootprint, bool aRende
{ {
modelPtr->DrawTransparent( sM.m_Opacity, modelPtr->DrawTransparent( sM.m_Opacity,
aFootprint->IsSelected() || aIsSelected, aFootprint->IsSelected() || aIsSelected,
m_boardAdapter.m_OpenGlSelectionColor ); selColor );
} }
else else
{ {
modelPtr->DrawOpaque( aFootprint->IsSelected() || aIsSelected, modelPtr->DrawOpaque( aFootprint->IsSelected() || aIsSelected, selColor );
m_boardAdapter.m_OpenGlSelectionColor );
} }
if( m_boardAdapter.GetFlag( FL_RENDER_OPENGL_SHOW_MODEL_BBOX ) ) if( m_boardAdapter.m_Cfg->m_Render.opengl_show_model_bbox )
{ {
glEnable( GL_BLEND ); glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );

120
3d-viewer/3d_rendering/raytracing/create_scene.cpp
View File

@ -70,30 +70,23 @@ static float TransparencyControl( float aGrayColorValue, float aTransparency )
void RENDER_3D_RAYTRACE::setupMaterials() void RENDER_3D_RAYTRACE::setupMaterials()
{ {
MATERIAL::SetDefaultRefractionRayCount( m_boardAdapter.m_RtRefractionSampleCount ); MATERIAL::SetDefaultRefractionRayCount( m_boardAdapter.m_Cfg->m_Render.raytrace_nrsamples_refractions );
MATERIAL::SetDefaultReflectionRayCount( m_boardAdapter.m_RtReflectionSampleCount ); MATERIAL::SetDefaultReflectionRayCount( m_boardAdapter.m_Cfg->m_Render.raytrace_nrsamples_reflections );
MATERIAL::SetDefaultRefractionRecursionCount( m_boardAdapter.m_RtRecursiveRefractionCount ); MATERIAL::SetDefaultRefractionRecursionCount( m_boardAdapter.m_Cfg->m_Render.raytrace_recursivelevel_refractions );
MATERIAL::SetDefaultReflectionRecursionCount( m_boardAdapter.m_RtRecursiveReflectionCount ); MATERIAL::SetDefaultReflectionRecursionCount( m_boardAdapter.m_Cfg->m_Render.raytrace_recursivelevel_reflections );
double mmTo3Dunits = IU_PER_MM * m_boardAdapter.BiuTo3dUnits(); double mmTo3Dunits = IU_PER_MM * m_boardAdapter.BiuTo3dUnits();
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_procedural_textures )
{ {
m_boardMaterial = BOARD_NORMAL( 0.40f * mmTo3Dunits ); m_boardMaterial = BOARD_NORMAL( 0.40f * mmTo3Dunits );
m_copperMaterial = COPPER_NORMAL( 4.0f * mmTo3Dunits, &m_boardMaterial ); m_copperMaterial = COPPER_NORMAL( 4.0f * mmTo3Dunits, &m_boardMaterial );
m_platedCopperMaterial = PLATED_COPPER_NORMAL( 0.5f * mmTo3Dunits ); m_platedCopperMaterial = PLATED_COPPER_NORMAL( 0.5f * mmTo3Dunits );
m_solderMaskMaterial = SOLDER_MASK_NORMAL( &m_boardMaterial ); m_solderMaskMaterial = SOLDER_MASK_NORMAL( &m_boardMaterial );
m_plasticMaterial = PLASTIC_NORMAL( 0.05f * mmTo3Dunits ); m_plasticMaterial = PLASTIC_NORMAL( 0.05f * mmTo3Dunits );
m_shinyPlasticMaterial = PLASTIC_SHINE_NORMAL( 0.1f * mmTo3Dunits ); m_shinyPlasticMaterial = PLASTIC_SHINE_NORMAL( 0.1f * mmTo3Dunits );
m_brushedMetalMaterial = BRUSHED_METAL_NORMAL( 0.05f * mmTo3Dunits ); m_brushedMetalMaterial = BRUSHED_METAL_NORMAL( 0.05f * mmTo3Dunits );
m_silkScreenMaterial = SILK_SCREEN_NORMAL( 0.25f * mmTo3Dunits ); m_silkScreenMaterial = SILK_SCREEN_NORMAL( 0.25f * mmTo3Dunits );
} }
@ -107,14 +100,14 @@ void RENDER_3D_RAYTRACE::setupMaterials()
ConvertSRGBToLinear( (SFVEC3F) m_boardAdapter.m_CopperColor * 0.3f ), ConvertSRGBToLinear( (SFVEC3F) m_boardAdapter.m_CopperColor * 0.3f ),
SFVEC3F( 0.0f ), copperSpecularLinear, 0.4f * 128.0f, 0.0f, 0.0f ); SFVEC3F( 0.0f ), copperSpecularLinear, 0.4f * 128.0f, 0.0f, 0.0f );
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_procedural_textures )
m_materials.m_Copper.SetGenerator( &m_platedCopperMaterial ); m_materials.m_Copper.SetGenerator( &m_platedCopperMaterial );
m_materials.m_NonPlatedCopper = BLINN_PHONG_MATERIAL( m_materials.m_NonPlatedCopper = BLINN_PHONG_MATERIAL(
ConvertSRGBToLinear( SFVEC3F( 0.191f, 0.073f, 0.022f ) ), SFVEC3F( 0.0f, 0.0f, 0.0f ), ConvertSRGBToLinear( SFVEC3F( 0.191f, 0.073f, 0.022f ) ), SFVEC3F( 0.0f, 0.0f, 0.0f ),
SFVEC3F( 0.256f, 0.137f, 0.086f ), 0.15f * 128.0f, 0.0f, 0.0f ); SFVEC3F( 0.256f, 0.137f, 0.086f ), 0.15f * 128.0f, 0.0f, 0.0f );
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_procedural_textures )
m_materials.m_NonPlatedCopper.SetGenerator( &m_copperMaterial ); m_materials.m_NonPlatedCopper.SetGenerator( &m_copperMaterial );
m_materials.m_Paste = BLINN_PHONG_MATERIAL( m_materials.m_Paste = BLINN_PHONG_MATERIAL(
@ -132,7 +125,7 @@ void RENDER_3D_RAYTRACE::setupMaterials()
(SFVEC3F) m_boardAdapter.m_SilkScreenColorTop ) ), (SFVEC3F) m_boardAdapter.m_SilkScreenColorTop ) ),
SFVEC3F( 0.0f ), SFVEC3F( 0.10f ) ), 0.078125f * 128.0f, 0.0f, 0.0f ); SFVEC3F( 0.0f ), SFVEC3F( 0.10f ) ), 0.078125f * 128.0f, 0.0f, 0.0f );
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_procedural_textures )
m_materials.m_SilkS.SetGenerator( &m_silkScreenMaterial ); m_materials.m_SilkS.SetGenerator( &m_silkScreenMaterial );
// Assume that SolderMaskTop == SolderMaskBot // Assume that SolderMaskTop == SolderMaskBot
@ -153,7 +146,7 @@ void RENDER_3D_RAYTRACE::setupMaterials()
m_materials.m_SolderMask.SetCastShadows( true ); m_materials.m_SolderMask.SetCastShadows( true );
m_materials.m_SolderMask.SetRefractionRayCount( 1 ); m_materials.m_SolderMask.SetRefractionRayCount( 1 );
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_procedural_textures )
m_materials.m_SolderMask.SetGenerator( &m_solderMaskMaterial ); m_materials.m_SolderMask.SetGenerator( &m_solderMaskMaterial );
m_materials.m_EpoxyBoard = m_materials.m_EpoxyBoard =
@ -166,7 +159,7 @@ void RENDER_3D_RAYTRACE::setupMaterials()
m_materials.m_EpoxyBoard.SetAbsorvance( 10.0f ); m_materials.m_EpoxyBoard.SetAbsorvance( 10.0f );
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_procedural_textures )
m_materials.m_EpoxyBoard.SetGenerator( &m_boardMaterial ); m_materials.m_EpoxyBoard.SetGenerator( &m_boardMaterial );
SFVEC3F bgTop = ConvertSRGBToLinear( (SFVEC3F) m_boardAdapter.m_BgColorTop ); SFVEC3F bgTop = ConvertSRGBToLinear( (SFVEC3F) m_boardAdapter.m_BgColorTop );
@ -278,11 +271,11 @@ void RENDER_3D_RAYTRACE::createItemsFromContainer( const BVH_CONTAINER_2D* aCont
// layer and the flag is set, then clip the silk at the outer edge of the annular ring, // layer and the flag is set, then clip the silk at the outer edge of the annular ring,
// rather than the at the outer edge of the copper plating. // rather than the at the outer edge of the copper plating.
const BVH_CONTAINER_2D& throughHoleOuter = const BVH_CONTAINER_2D& throughHoleOuter =
( m_boardAdapter.GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) m_boardAdapter.m_Cfg->m_Render.clip_silk_on_via_annulus
&& m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) && m_boardAdapter.m_Cfg->m_Render.realistic
&& ( ( aLayer_id == B_SilkS ) || ( aLayer_id == F_SilkS ) ) ) ? && ( aLayer_id == B_SilkS || aLayer_id == F_SilkS ) ?
m_boardAdapter.GetThroughHoleAnnularRings() : m_boardAdapter.GetThroughHoleAnnularRings() :
m_boardAdapter.GetThroughHoleOds(); m_boardAdapter.GetThroughHoleOds();
if( !throughHoleOuter.GetList().empty() ) if( !throughHoleOuter.GetList().empty() )
{ {
@ -308,8 +301,8 @@ void RENDER_3D_RAYTRACE::createItemsFromContainer( const BVH_CONTAINER_2D* aCont
const MAP_CONTAINER_2D_BASE& mapLayers = m_boardAdapter.GetLayerMap(); const MAP_CONTAINER_2D_BASE& mapLayers = m_boardAdapter.GetLayerMap();
if( m_boardAdapter.GetFlag( FL_SUBTRACT_MASK_FROM_SILK ) if( m_boardAdapter.m_Cfg->m_Render.subtract_mask_from_silk
&& m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) && m_boardAdapter.m_Cfg->m_Render.realistic
&& ( ( aLayer_id == B_SilkS && mapLayers.find( B_Mask ) != mapLayers.end() ) && ( ( aLayer_id == B_SilkS && mapLayers.find( B_Mask ) != mapLayers.end() )
|| ( aLayer_id == F_SilkS && mapLayers.find( F_Mask ) != mapLayers.end() ) ) ) || ( aLayer_id == F_SilkS && mapLayers.find( F_Mask ) != mapLayers.end() ) ) )
{ {
@ -439,7 +432,7 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
*m_boardAdapter.GetBoard(), ii ); *m_boardAdapter.GetBoard(), ii );
} }
if( m_boardAdapter.GetFlag( FL_SHOW_BOARD_BODY ) ) if( m_boardAdapter.m_Cfg->m_Render.show_board_body )
{ {
const LIST_OBJECT2D& listObjects = m_outlineBoard2dObjects->GetList(); const LIST_OBJECT2D& listObjects = m_outlineBoard2dObjects->GetList();
@ -592,7 +585,7 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
case F_Paste: case F_Paste:
materialLayer = &m_materials.m_Paste; materialLayer = &m_materials.m_Paste;
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.m_Cfg->m_Render.realistic )
layerColor = m_boardAdapter.m_SolderPasteColor; layerColor = m_boardAdapter.m_SolderPasteColor;
else else
layerColor = m_boardAdapter.GetLayerColor( layer_id ); layerColor = m_boardAdapter.GetLayerColor( layer_id );
@ -602,7 +595,7 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
case B_SilkS: case B_SilkS:
materialLayer = &m_materials.m_SilkS; materialLayer = &m_materials.m_SilkS;
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.m_Cfg->m_Render.realistic )
layerColor = m_boardAdapter.m_SilkScreenColorBot; layerColor = m_boardAdapter.m_SilkScreenColorBot;
else else
layerColor = m_boardAdapter.GetLayerColor( layer_id ); layerColor = m_boardAdapter.GetLayerColor( layer_id );
@ -612,7 +605,7 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
case F_SilkS: case F_SilkS:
materialLayer = &m_materials.m_SilkS; materialLayer = &m_materials.m_SilkS;
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.m_Cfg->m_Render.realistic )
layerColor = m_boardAdapter.m_SilkScreenColorTop; layerColor = m_boardAdapter.m_SilkScreenColorTop;
else else
layerColor = m_boardAdapter.GetLayerColor( layer_id ); layerColor = m_boardAdapter.GetLayerColor( layer_id );
@ -636,9 +629,9 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
break; break;
default: default:
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.m_Cfg->m_Render.realistic )
{ {
if( m_boardAdapter.GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) ) if( m_boardAdapter.m_Cfg->m_Render.renderPlatedPadsAsPlated )
layerColor = SFVEC3F( 184.0f / 255.0f, 115.0f / 255.0f, 50.0f / 255.0f ); layerColor = SFVEC3F( 184.0f / 255.0f, 115.0f / 255.0f, 50.0f / 255.0f );
else else
layerColor = m_boardAdapter.m_CopperColor; layerColor = m_boardAdapter.m_CopperColor;
@ -656,8 +649,8 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
} // for each layer on map } // for each layer on map
// Create plated copper // Create plated copper
if( m_boardAdapter.GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) if( m_boardAdapter.m_Cfg->m_Render.renderPlatedPadsAsPlated
&& m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) && m_boardAdapter.m_Cfg->m_Render.realistic )
{ {
createItemsFromContainer( m_boardAdapter.GetPlatedPadsFront(), F_Cu, &m_materials.m_Copper, createItemsFromContainer( m_boardAdapter.GetPlatedPadsFront(), F_Cu, &m_materials.m_Copper,
m_boardAdapter.m_CopperColor, m_boardAdapter.m_CopperColor,
@ -674,7 +667,8 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
// Solder mask layers are "negative" layers so the elements that we have in the container // Solder mask layers are "negative" layers so the elements that we have in the container
// should remove the board outline. We will check for all objects in the outline if it // should remove the board outline. We will check for all objects in the outline if it
// intersects any object in the layer container and also any hole. // intersects any object in the layer container and also any hole.
if( m_boardAdapter.GetFlag( FL_SOLDERMASK ) && !m_outlineBoard2dObjects->GetList().empty() ) if( m_boardAdapter.m_Cfg->m_Render.show_soldermask
&& !m_outlineBoard2dObjects->GetList().empty() )
{ {
const MATERIAL* materialLayer = &m_materials.m_SolderMask; const MATERIAL* materialLayer = &m_materials.m_SolderMask;
@ -693,7 +687,7 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
SFVEC3F layerColor; SFVEC3F layerColor;
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.m_Cfg->m_Render.realistic )
{ {
if( layer_id == B_Mask ) if( layer_id == B_Mask )
layerColor = m_boardAdapter.m_SolderMaskColorBot; layerColor = m_boardAdapter.m_SolderMaskColorBot;
@ -798,7 +792,7 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
if( !aOnlyLoadCopperAndShapes ) if( !aOnlyLoadCopperAndShapes )
{ {
// Add floor // Add floor
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_BACKFLOOR ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_backfloor )
{ {
BBOX_3D boardBBox = m_boardAdapter.GetBBox(); BBOX_3D boardBBox = m_boardAdapter.GetBBox();
@ -878,41 +872,47 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
&& ( aSource.b < ( 1.0f / 255.0f ) ) ); && ( aSource.b < ( 1.0f / 255.0f ) ) );
}; };
m_cameraLight = new DIRECTIONAL_LIGHT( SFVEC3F( 0.0f, 0.0f, 0.0f ), SFVEC3F cameraLightColor =
m_boardAdapter.m_RtCameraLightColor ); m_boardAdapter.GetColor( m_boardAdapter.m_Cfg->m_Render.raytrace_lightColorCamera );
SFVEC3F topLightColor =
m_boardAdapter.GetColor( m_boardAdapter.m_Cfg->m_Render.raytrace_lightColorTop );
SFVEC3F bottomLightColor =
m_boardAdapter.GetColor( m_boardAdapter.m_Cfg->m_Render.raytrace_lightColorBottom );
m_cameraLight = new DIRECTIONAL_LIGHT( SFVEC3F( 0.0f, 0.0f, 0.0f ), cameraLightColor );
m_cameraLight->SetCastShadows( false ); m_cameraLight->SetCastShadows( false );
if( !IsColorZero( m_boardAdapter.m_RtCameraLightColor ) ) if( !IsColorZero( cameraLightColor ) )
m_lights.push_back( m_cameraLight ); m_lights.push_back( m_cameraLight );
const SFVEC3F& boardCenter = m_boardAdapter.GetBBox().GetCenter(); const SFVEC3F& boardCenter = m_boardAdapter.GetBBox().GetCenter();
if( !IsColorZero( m_boardAdapter.m_RtLightColorTop ) ) if( !IsColorZero( topLightColor ) )
{ {
m_lights.push_back( new POINT_LIGHT( SFVEC3F( boardCenter.x, boardCenter.y, m_lights.push_back( new POINT_LIGHT( SFVEC3F( boardCenter.x, boardCenter.y,
+RANGE_SCALE_3D * 2.0f ), +RANGE_SCALE_3D * 2.0f ),
m_boardAdapter.m_RtLightColorTop ) ); topLightColor ) );
} }
if( !IsColorZero( m_boardAdapter.m_RtLightColorBottom ) ) if( !IsColorZero( bottomLightColor ) )
{ {
m_lights.push_back( new POINT_LIGHT( SFVEC3F( boardCenter.x, boardCenter.y, m_lights.push_back( new POINT_LIGHT( SFVEC3F( boardCenter.x, boardCenter.y,
-RANGE_SCALE_3D * 2.0f ), -RANGE_SCALE_3D * 2.0f ),
m_boardAdapter.m_RtLightColorBottom ) ); bottomLightColor ) );
} }
wxASSERT( m_boardAdapter.m_RtLightColor.size() for( size_t i = 0; i < m_boardAdapter.m_Cfg->m_Render.raytrace_lightColor.size(); ++i )
== m_boardAdapter.m_RtLightSphericalCoords.size() );
for( size_t i = 0; i < m_boardAdapter.m_RtLightColor.size(); ++i )
{ {
if( !IsColorZero( m_boardAdapter.m_RtLightColor[i] ) ) SFVEC3F lightColor =
m_boardAdapter.GetColor( m_boardAdapter.m_Cfg->m_Render.raytrace_lightColor[i] );
if( !IsColorZero( lightColor ) )
{ {
const SFVEC2F sc = m_boardAdapter.m_RtLightSphericalCoords[i]; const SFVEC2F sc = m_boardAdapter.GetSphericalCoord( i );
m_lights.push_back( new DIRECTIONAL_LIGHT( m_lights.push_back( new DIRECTIONAL_LIGHT(
SphericalToCartesian( glm::pi<float>() * sc.x, glm::pi<float>() * sc.y ), SphericalToCartesian( glm::pi<float>() * sc.x, glm::pi<float>() * sc.y ),
m_boardAdapter.m_RtLightColor[i] ) ); lightColor ) );
} }
} }
} }
@ -970,7 +970,7 @@ void RENDER_3D_RAYTRACE::insertHole( const PCB_VIA* aVia )
objPtr->SetMaterial( &m_materials.m_Copper ); objPtr->SetMaterial( &m_materials.m_Copper );
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.m_Cfg->m_Render.realistic )
objPtr->SetColor( ConvertSRGBToLinear( m_boardAdapter.m_CopperColor ) ); objPtr->SetColor( ConvertSRGBToLinear( m_boardAdapter.m_CopperColor ) );
else if( aVia->GetViaType() == VIATYPE::MICROVIA ) else if( aVia->GetViaType() == VIATYPE::MICROVIA )
objPtr->SetColor( ConvertSRGBToLinear( m_boardAdapter.GetItemColor( LAYER_VIA_MICROVIA ) ) ); objPtr->SetColor( ConvertSRGBToLinear( m_boardAdapter.GetItemColor( LAYER_VIA_MICROVIA ) ) );
@ -989,7 +989,7 @@ void RENDER_3D_RAYTRACE::insertHole( const PAD* aPad )
SFVEC3F objColor; SFVEC3F objColor;
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.m_Cfg->m_Render.realistic )
objColor = m_boardAdapter.m_CopperColor; objColor = m_boardAdapter.m_CopperColor;
else else
objColor = m_boardAdapter.GetItemColor( LAYER_PADS_TH ); objColor = m_boardAdapter.GetItemColor( LAYER_PADS_TH );
@ -1195,9 +1195,9 @@ void RENDER_3D_RAYTRACE::load3DModels( CONTAINER_3D& aDstContainer, bool aSkipMa
if( !m_boardAdapter.GetBoard() ) if( !m_boardAdapter.GetBoard() )
return; return;
if( !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_NORMAL ) if( !m_boardAdapter.m_Cfg->m_Render.show_footprints_normal
&& !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_NORMAL_INSERT ) && !m_boardAdapter.m_Cfg->m_Render.show_footprints_insert
&& !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_VIRTUAL ) ) && !m_boardAdapter.m_Cfg->m_Render.show_footprints_virtual )
{ {
return; return;
} }
@ -1312,7 +1312,7 @@ MODEL_MATERIALS* RENDER_3D_RAYTRACE::getModelMaterial( const S3DMODEL* a3DModel
for( unsigned int imat = 0; imat < a3DModel->m_MaterialsSize; ++imat ) for( unsigned int imat = 0; imat < a3DModel->m_MaterialsSize; ++imat )
{ {
if( m_boardAdapter.GetMaterialMode() == MATERIAL_MODE::NORMAL ) if( m_boardAdapter.m_Cfg->m_Render.material_mode == MATERIAL_MODE::NORMAL )
{ {
const SMATERIAL& material = a3DModel->m_Materials[imat]; const SMATERIAL& material = a3DModel->m_Materials[imat];
@ -1334,7 +1334,7 @@ MODEL_MATERIALS* RENDER_3D_RAYTRACE::getModelMaterial( const S3DMODEL* a3DModel
ConvertSRGBToLinear( material.m_Specular ), material.m_Shininess * 180.0f, ConvertSRGBToLinear( material.m_Specular ), material.m_Shininess * 180.0f,
material.m_Transparency, reflectionFactor ); material.m_Transparency, reflectionFactor );
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_procedural_textures )
{ {
// Guess material type and apply a normal perturbator // Guess material type and apply a normal perturbator
if( ( RGBtoGray( material.m_Diffuse ) < 0.3f ) if( ( RGBtoGray( material.m_Diffuse ) < 0.3f )
@ -1502,7 +1502,7 @@ void RENDER_3D_RAYTRACE::addModels( CONTAINER_3D& aDstContainer, const S3DMODEL*
const SFVEC3F diffuseColor = const SFVEC3F diffuseColor =
a3DModel->m_Materials[mesh.m_MaterialIdx].m_Diffuse; a3DModel->m_Materials[mesh.m_MaterialIdx].m_Diffuse;
if( m_boardAdapter.GetMaterialMode() == MATERIAL_MODE::CAD_MODE ) if( m_boardAdapter.m_Cfg->m_Render.material_mode == MATERIAL_MODE::CAD_MODE )
newTriangle->SetColor( ConvertSRGBToLinear( newTriangle->SetColor( ConvertSRGBToLinear(
MaterialDiffuseToColorCAD( diffuseColor ) ) ); MaterialDiffuseToColorCAD( diffuseColor ) ) );
else else
@ -1510,7 +1510,8 @@ void RENDER_3D_RAYTRACE::addModels( CONTAINER_3D& aDstContainer, const S3DMODEL*
} }
else else
{ {
if( m_boardAdapter.GetMaterialMode() == MATERIAL_MODE::CAD_MODE ) if( m_boardAdapter.m_Cfg->m_Render.material_mode == MATERIAL_MODE::CAD_MODE )
{
newTriangle->SetColor( newTriangle->SetColor(
ConvertSRGBToLinear( MaterialDiffuseToColorCAD( ConvertSRGBToLinear( MaterialDiffuseToColorCAD(
mesh.m_Color[idx0] ) ), mesh.m_Color[idx0] ) ),
@ -1518,11 +1519,14 @@ void RENDER_3D_RAYTRACE::addModels( CONTAINER_3D& aDstContainer, const S3DMODEL*
mesh.m_Color[idx1] ) ), mesh.m_Color[idx1] ) ),
ConvertSRGBToLinear( MaterialDiffuseToColorCAD( ConvertSRGBToLinear( MaterialDiffuseToColorCAD(
mesh.m_Color[idx2] ) ) ); mesh.m_Color[idx2] ) ) );
}
else else
{
newTriangle->SetColor( newTriangle->SetColor(
ConvertSRGBToLinear( mesh.m_Color[idx0] ), ConvertSRGBToLinear( mesh.m_Color[idx0] ),
ConvertSRGBToLinear( mesh.m_Color[idx1] ), ConvertSRGBToLinear( mesh.m_Color[idx1] ),
ConvertSRGBToLinear( mesh.m_Color[idx2] ) ); ConvertSRGBToLinear( mesh.m_Color[idx2] ) );
}
} }
} }
} }

56
3d-viewer/3d_rendering/raytracing/render_3d_raytrace.cpp
View File

@ -293,7 +293,7 @@ void RENDER_3D_RAYTRACE::render( GLubyte* ptrPBO, REPORTER* aStatusReporter )
if( m_cameraLight ) if( m_cameraLight )
m_cameraLight->SetDirection( -m_camera.GetDir() ); m_cameraLight->SetDirection( -m_camera.GetDir() );
if( m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::OPENGL ) if( m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
{ {
// Set all pixels of PBO transparent (Alpha to 0) // Set all pixels of PBO transparent (Alpha to 0)
// This way it will draw the full buffer but only shows the updated ( // This way it will draw the full buffer but only shows the updated (
@ -399,7 +399,7 @@ void RENDER_3D_RAYTRACE::renderTracing( GLubyte* ptrPBO, REPORTER* aStatusReport
// or mark it as finished // or mark it as finished
if( m_blockRenderProgressCount >= m_blockPositions.size() ) if( m_blockRenderProgressCount >= m_blockPositions.size() )
{ {
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_post_processing )
m_renderState = RT_RENDER_STATE_POST_PROCESS_SHADE; m_renderState = RT_RENDER_STATE_POST_PROCESS_SHADE;
else else
m_renderState = RT_RENDER_STATE_FINISH; m_renderState = RT_RENDER_STATE_FINISH;
@ -504,7 +504,7 @@ void RENDER_3D_RAYTRACE::renderAntiAliasPackets( const SFVEC3F* aBgColorY,
const HITINFO_PACKET* aHitPck_AA_X1Y1, const HITINFO_PACKET* aHitPck_AA_X1Y1,
const RAY* aRayPck, SFVEC3F* aOutHitColor ) const RAY* aRayPck, SFVEC3F* aOutHitColor )
{ {
const bool is_testShadow = m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_SHADOWS ); const bool is_testShadow = m_boardAdapter.m_Cfg->m_Render.raytrace_shadows;
for( unsigned int y = 0, i = 0; y < RAYPACKET_DIM; ++y ) for( unsigned int y = 0, i = 0; y < RAYPACKET_DIM; ++y )
{ {
@ -652,7 +652,7 @@ void RENDER_3D_RAYTRACE::renderBlockTracing( GLubyte* ptrPBO, signed int iBlock
if( !m_accelerator->Intersect( blockPacket, hitPacket_X0Y0 ) ) if( !m_accelerator->Intersect( blockPacket, hitPacket_X0Y0 ) )
{ {
// If block is empty then set shades and continue // If block is empty then set shades and continue
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_post_processing )
{ {
for( unsigned int y = 0; y < RAYPACKET_DIM; ++y ) for( unsigned int y = 0; y < RAYPACKET_DIM; ++y )
{ {
@ -670,10 +670,9 @@ void RENDER_3D_RAYTRACE::renderBlockTracing( GLubyte* ptrPBO, signed int iBlock
} }
// This will set the output color to be displayed // This will set the output color to be displayed
// If post processing is enabled, it will not reflect the final result // If post processing is enabled, it will not reflect the final result (as the final
// (as the final color will be computed on post processing) // color will be computed on post processing) but it is used for report progress
// but it is used for report progress const bool isFinalColor = !m_boardAdapter.m_Cfg->m_Render.raytrace_post_processing;
const bool isFinalColor = !m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING );
for( unsigned int y = 0; y < RAYPACKET_DIM; ++y ) for( unsigned int y = 0; y < RAYPACKET_DIM; ++y )
{ {
@ -698,9 +697,9 @@ void RENDER_3D_RAYTRACE::renderBlockTracing( GLubyte* ptrPBO, signed int iBlock
// Shade original (0, 0) hits ("paint" the intersected objects) // Shade original (0, 0) hits ("paint" the intersected objects)
renderRayPackets( bgColor, blockPacket.m_ray, hitPacket_X0Y0, renderRayPackets( bgColor, blockPacket.m_ray, hitPacket_X0Y0,
m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_SHADOWS ), hitColor_X0Y0 ); m_boardAdapter.m_Cfg->m_Render.raytrace_shadows, hitColor_X0Y0 );
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_ANTI_ALIASING ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_anti_aliasing )
{ {
SFVEC3F hitColor_AA_X1Y1[RAYPACKET_RAYS_PER_PACKET]; SFVEC3F hitColor_AA_X1Y1[RAYPACKET_RAYS_PER_PACKET];
@ -719,16 +718,13 @@ void RENDER_3D_RAYTRACE::renderBlockTracing( GLubyte* ptrPBO, signed int iBlock
const SFVEC3F& outColor = bgColor[y]; const SFVEC3F& outColor = bgColor[y];
for( unsigned int x = 0; x < RAYPACKET_DIM; ++x, ++i ) for( unsigned int x = 0; x < RAYPACKET_DIM; ++x, ++i )
{
hitColor_AA_X1Y1[i] = outColor; hitColor_AA_X1Y1[i] = outColor;
}
} }
} }
else else
{ {
renderRayPackets( bgColor, blockPacket_AA_X1Y1.m_ray, hitPacket_AA_X1Y1, renderRayPackets( bgColor, blockPacket_AA_X1Y1.m_ray, hitPacket_AA_X1Y1,
m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_SHADOWS ), m_boardAdapter.m_Cfg->m_Render.raytrace_shadows, hitColor_AA_X1Y1 );
hitColor_AA_X1Y1 );
} }
SFVEC3F hitColor_AA_X1Y0[RAYPACKET_RAYS_PER_PACKET]; SFVEC3F hitColor_AA_X1Y0[RAYPACKET_RAYS_PER_PACKET];
@ -737,8 +733,7 @@ void RENDER_3D_RAYTRACE::renderBlockTracing( GLubyte* ptrPBO, signed int iBlock
for( unsigned int i = 0; i < RAYPACKET_RAYS_PER_PACKET; ++i ) for( unsigned int i = 0; i < RAYPACKET_RAYS_PER_PACKET; ++i )
{ {
const SFVEC3F color_average = ( hitColor_X0Y0[i] + SFVEC3F color_average = ( hitColor_X0Y0[i] + hitColor_AA_X1Y1[i] ) * SFVEC3F( 0.5f );
hitColor_AA_X1Y1[i] ) * SFVEC3F( 0.5f );
hitColor_AA_X1Y0[i] = color_average; hitColor_AA_X1Y0[i] = color_average;
hitColor_AA_X0Y1[i] = color_average; hitColor_AA_X0Y1[i] = color_average;
@ -784,7 +779,7 @@ void RENDER_3D_RAYTRACE::renderBlockTracing( GLubyte* ptrPBO, signed int iBlock
const uint32_t ptrInc = ( m_realBufferSize.x - RAYPACKET_DIM ) * 4; const uint32_t ptrInc = ( m_realBufferSize.x - RAYPACKET_DIM ) * 4;
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_post_processing )
{ {
SFVEC2I bPos; SFVEC2I bPos;
bPos.y = blockPos.y; bPos.y = blockPos.y;
@ -798,6 +793,7 @@ void RENDER_3D_RAYTRACE::renderBlockTracing( GLubyte* ptrPBO, signed int iBlock
const SFVEC3F& hColor = hitColor_X0Y0[i]; const SFVEC3F& hColor = hitColor_X0Y0[i];
if( hitPacket_X0Y0[i].m_hitresult == true ) if( hitPacket_X0Y0[i].m_hitresult == true )
{
m_postShaderSsao.SetPixelData( bPos.x, bPos.y, m_postShaderSsao.SetPixelData( bPos.x, bPos.y,
hitPacket_X0Y0[i].m_HitInfo.m_HitNormal, hitPacket_X0Y0[i].m_HitInfo.m_HitNormal,
hColor, hColor,
@ -805,9 +801,12 @@ void RENDER_3D_RAYTRACE::renderBlockTracing( GLubyte* ptrPBO, signed int iBlock
hitPacket_X0Y0[i].m_HitInfo.m_tHit ), hitPacket_X0Y0[i].m_HitInfo.m_tHit ),
hitPacket_X0Y0[i].m_HitInfo.m_tHit, hitPacket_X0Y0[i].m_HitInfo.m_tHit,
hitPacket_X0Y0[i].m_HitInfo.m_ShadowFactor ); hitPacket_X0Y0[i].m_HitInfo.m_ShadowFactor );
}
else else
{
m_postShaderSsao.SetPixelData( bPos.x, bPos.y, SFVEC3F( 0.0f ), hColor, m_postShaderSsao.SetPixelData( bPos.x, bPos.y, SFVEC3F( 0.0f ), hColor,
SFVEC3F( 0.0f ), 0, 1.0f ); SFVEC3F( 0.0f ), 0, 1.0f );
}
renderFinalColor( ptr, hColor, false ); renderFinalColor( ptr, hColor, false );
@ -837,13 +836,12 @@ void RENDER_3D_RAYTRACE::renderBlockTracing( GLubyte* ptrPBO, signed int iBlock
void RENDER_3D_RAYTRACE::postProcessShading( GLubyte* /* ptrPBO */, REPORTER* aStatusReporter ) void RENDER_3D_RAYTRACE::postProcessShading( GLubyte* /* ptrPBO */, REPORTER* aStatusReporter )
{ {
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_post_processing )
{ {
if( aStatusReporter ) if( aStatusReporter )
aStatusReporter->Report( _( "Rendering: Post processing shader" ) ); aStatusReporter->Report( _( "Rendering: Post processing shader" ) );
m_postShaderSsao.SetShadowsEnabled( m_postShaderSsao.SetShadowsEnabled( m_boardAdapter.m_Cfg->m_Render.raytrace_shadows );
m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_SHADOWS ) );
std::atomic<size_t> nextBlock( 0 ); std::atomic<size_t> nextBlock( 0 );
std::atomic<size_t> threadsFinished( 0 ); std::atomic<size_t> threadsFinished( 0 );
@ -890,7 +888,7 @@ void RENDER_3D_RAYTRACE::postProcessShading( GLubyte* /* ptrPBO */, REPORTER* aS
void RENDER_3D_RAYTRACE::postProcessBlurFinish( GLubyte* ptrPBO, REPORTER* /* aStatusReporter */ ) void RENDER_3D_RAYTRACE::postProcessBlurFinish( GLubyte* ptrPBO, REPORTER* /* aStatusReporter */ )
{ {
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) if( m_boardAdapter.m_Cfg->m_Render.raytrace_post_processing )
{ {
// Now blurs the shader result and compute the final color // Now blurs the shader result and compute the final color
std::atomic<size_t> nextBlock( 0 ); std::atomic<size_t> nextBlock( 0 );
@ -1560,8 +1558,7 @@ SFVEC3F RENDER_3D_RAYTRACE::shadeHit( const SFVEC3F& aBgColor, const RAY& aRay,
const SFVEC3F diffuseColorObj = aHitInfo.pHitObject->GetDiffuseColor( aHitInfo ); const SFVEC3F diffuseColorObj = aHitInfo.pHitObject->GetDiffuseColor( aHitInfo );
#if USE_EXPERIMENTAL_SOFT_SHADOWS #if USE_EXPERIMENTAL_SOFT_SHADOWS
const bool is_aa_enabled = m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_ANTI_ALIASING ) && bool is_aa_enabled = m_boardAdapter.m_Cfg->m_Render.raytrace_anti_aliasing && !m_isPreview;
(!m_isPreview);
#endif #endif
float shadow_att_factor_sum = 0.0f; float shadow_att_factor_sum = 0.0f;
@ -1607,9 +1604,8 @@ SFVEC3F RENDER_3D_RAYTRACE::shadeHit( const SFVEC3F& aBgColor, const RAY& aRay,
} }
else // Experimental softshadow calculation else // Experimental softshadow calculation
{ {
const unsigned int shadow_number_of_samples = const unsigned int shadow_number_of_samples =
m_boardAdapter.m_RtShadowSampleCount; m_boardAdapter.m_Cfg->m_Render.raytrace_nrsamples_shadows;
const float shadow_inc_factor = 1.0f / (float) ( shadow_number_of_samples ); const float shadow_inc_factor = 1.0f / (float) ( shadow_number_of_samples );
for( unsigned int i = 0; i < shadow_number_of_samples; ++i ) for( unsigned int i = 0; i < shadow_number_of_samples; ++i )
@ -1625,7 +1621,7 @@ SFVEC3F RENDER_3D_RAYTRACE::shadeHit( const SFVEC3F& aBgColor, const RAY& aRay,
const SFVEC3F unifVector = UniformRandomHemisphereDirection(); const SFVEC3F unifVector = UniformRandomHemisphereDirection();
const SFVEC3F disturbed_vector_to_light = const SFVEC3F disturbed_vector_to_light =
glm::normalize( vectorToLight + unifVector * glm::normalize( vectorToLight + unifVector *
m_boardAdapter.m_RtSpreadShadows ); m_boardAdapter.m_Cfg->m_Render.raytrace_spread_shadows );
rayToLight.Init( hitPoint, disturbed_vector_to_light ); rayToLight.Init( hitPoint, disturbed_vector_to_light );
} }
@ -1670,7 +1666,7 @@ SFVEC3F RENDER_3D_RAYTRACE::shadeHit( const SFVEC3F& aBgColor, const RAY& aRay,
{ {
// Reflections // Reflections
if( ( objMaterial->GetReflection() > 0.0f ) if( ( objMaterial->GetReflection() > 0.0f )
&& m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_REFLECTIONS ) && m_boardAdapter.m_Cfg->m_Render.raytrace_reflections
&& ( aRecursiveLevel < objMaterial->GetReflectionRecursionCount() ) ) && ( aRecursiveLevel < objMaterial->GetReflectionRecursionCount() ) )
{ {
const unsigned int reflection_number_of_samples = const unsigned int reflection_number_of_samples =
@ -1695,7 +1691,7 @@ SFVEC3F RENDER_3D_RAYTRACE::shadeHit( const SFVEC3F& aBgColor, const RAY& aRay,
const SFVEC3F random_reflectVector = const SFVEC3F random_reflectVector =
glm::normalize( reflectVector + glm::normalize( reflectVector +
UniformRandomHemisphereDirection() * UniformRandomHemisphereDirection() *
m_boardAdapter.m_RtSpreadReflections ); m_boardAdapter.m_Cfg->m_Render.raytrace_spread_reflections );
reflectedRay.Init( hitPoint, random_reflectVector ); reflectedRay.Init( hitPoint, random_reflectVector );
} }
@ -1721,7 +1717,7 @@ SFVEC3F RENDER_3D_RAYTRACE::shadeHit( const SFVEC3F& aBgColor, const RAY& aRay,
// Refraction // Refraction
const float objTransparency = aHitInfo.pHitObject->GetModelTransparency(); const float objTransparency = aHitInfo.pHitObject->GetModelTransparency();
if( ( objTransparency > 0.0f ) && m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_REFRACTIONS ) if( ( objTransparency > 0.0f ) && m_boardAdapter.m_Cfg->m_Render.raytrace_refractions
&& ( aRecursiveLevel < objMaterial->GetRefractionRecursionCount() ) ) && ( aRecursiveLevel < objMaterial->GetRefractionRecursionCount() ) )
{ {
const float airIndex = 1.000293f; const float airIndex = 1.000293f;
@ -1760,7 +1756,7 @@ SFVEC3F RENDER_3D_RAYTRACE::shadeHit( const SFVEC3F& aBgColor, const RAY& aRay,
const SFVEC3F randomizeRefractedVector = const SFVEC3F randomizeRefractedVector =
glm::normalize( refractedVector + glm::normalize( refractedVector +
UniformRandomHemisphereDirection() * UniformRandomHemisphereDirection() *
m_boardAdapter.m_RtSpreadRefractions ); m_boardAdapter.m_Cfg->m_Render.raytrace_spread_refractions );
refractedRay.Init( startPoint, randomizeRefractedVector ); refractedRay.Init( startPoint, randomizeRefractedVector );
} }

261
3d-viewer/3d_viewer/eda_3d_viewer_frame.cpp
View File

@ -101,20 +101,19 @@ EDA_3D_VIEWER_FRAME::EDA_3D_VIEWER_FRAME( KIWAY *aKiway, PCB_BASE_FRAME *aParent
wxStatusBar *status_bar = CreateStatusBar( arrayDim( status_dims ) ); wxStatusBar *status_bar = CreateStatusBar( arrayDim( status_dims ) );
SetStatusWidths( arrayDim( status_dims ), status_dims ); SetStatusWidths( arrayDim( status_dims ), status_dims );
m_canvas = new EDA_3D_CANVAS( this, SETTINGS_MANAGER& mgr = Pgm().GetSettingsManager();
OGL_ATT_LIST::GetAttributesList( m_boardAdapter.GetAntiAliasingMode() ), EDA_3D_VIEWER_SETTINGS* cfg = mgr.GetAppSettings<EDA_3D_VIEWER_SETTINGS>();
m_boardAdapter, m_currentCamera, ANTIALIASING_MODE aaMode = static_cast<ANTIALIASING_MODE>( cfg->m_Render.opengl_AA_mode );
Prj().Get3DCacheManager() );
auto config = Pgm().GetSettingsManager().GetAppSettings<EDA_3D_VIEWER_SETTINGS>(); m_canvas = new EDA_3D_CANVAS( this, OGL_ATT_LIST::GetAttributesList( aaMode ),
LoadSettings( config ); m_boardAdapter, m_currentCamera, Prj().Get3DCacheManager() );
// Some settings need the canvas LoadSettings( cfg );
loadCommonSettings(); loadCommonSettings();
// Create the manager // Create the manager
m_toolManager = new TOOL_MANAGER; m_toolManager = new TOOL_MANAGER;
m_toolManager->SetEnvironment( GetBoard(), nullptr, nullptr, config, this ); m_toolManager->SetEnvironment( GetBoard(), nullptr, nullptr, cfg, this );
m_actions = new EDA_3D_ACTIONS(); m_actions = new EDA_3D_ACTIONS();
m_toolDispatcher = new TOOL_DISPATCHER( m_toolManager ); m_toolDispatcher = new TOOL_DISPATCHER( m_toolManager );
@ -128,7 +127,7 @@ EDA_3D_VIEWER_FRAME::EDA_3D_VIEWER_FRAME( KIWAY *aKiway, PCB_BASE_FRAME *aParent
setupUIConditions(); setupUIConditions();
if( EDA_3D_CONTROLLER* ctrlTool = GetToolManager()->GetTool<EDA_3D_CONTROLLER>() ) if( EDA_3D_CONTROLLER* ctrlTool = GetToolManager()->GetTool<EDA_3D_CONTROLLER>() )
ctrlTool->SetRotationIncrement( config->m_Camera.rotation_increment ); ctrlTool->SetRotationIncrement( cfg->m_Camera.rotation_increment );
// Run the viewer control tool, it is supposed to be always active // Run the viewer control tool, it is supposed to be always active
m_toolManager->InvokeTool( "3DViewer.Control" ); m_toolManager->InvokeTool( "3DViewer.Control" );
@ -182,39 +181,59 @@ void EDA_3D_VIEWER_FRAME::setupUIConditions()
EDA_3D_CONDITIONS cond( &m_boardAdapter ); EDA_3D_CONDITIONS cond( &m_boardAdapter );
// Helper to define check conditions // Helper to define check conditions
#define FlagCheck( x ) ACTION_CONDITIONS().Check( cond.Flag( x ) )
#define GridSizeCheck( x ) ACTION_CONDITIONS().Check( cond.GridSize( x ) ) #define GridSizeCheck( x ) ACTION_CONDITIONS().Check( cond.GridSize( x ) )
auto raytracingCondition = auto raytracing =
[this]( const SELECTION& aSel ) [this]( const SELECTION& aSel )
{ {
return m_boardAdapter.GetRenderEngine() != RENDER_ENGINE::OPENGL; return m_boardAdapter.m_Cfg->m_Render.engine != RENDER_ENGINE::OPENGL;
};
auto showTH =
[this]( const SELECTION& aSel )
{
return m_boardAdapter.m_Cfg->m_Render.show_footprints_normal;
};
auto showSMD =
[this]( const SELECTION& aSel )
{
return m_boardAdapter.m_Cfg->m_Render.show_footprints_insert;
};
auto showVirtual =
[this]( const SELECTION& aSel )
{
return m_boardAdapter.m_Cfg->m_Render.show_footprints_virtual;
};
auto showBBoxes =
[this]( const SELECTION& aSel )
{
return m_boardAdapter.m_Cfg->m_Render.opengl_show_model_bbox;
};
auto showAxes =
[this]( const SELECTION& aSel )
{
return m_boardAdapter.m_Cfg->m_Render.show_axis;
};
auto ortho =
[this]( const SELECTION& )
{
return m_currentCamera.GetProjection() == PROJECTION_TYPE::ORTHO;
}; };
RegisterUIUpdateHandler( ID_RENDER_CURRENT_VIEW, RegisterUIUpdateHandler( ID_RENDER_CURRENT_VIEW, ACTION_CONDITIONS().Check( raytracing ) );
ACTION_CONDITIONS().Check( raytracingCondition ) );
mgr->SetConditions( EDA_3D_ACTIONS::showTHT, FlagCheck( FL_FP_ATTRIBUTES_NORMAL ) ); mgr->SetConditions( EDA_3D_ACTIONS::showTHT, ACTION_CONDITIONS().Check( showTH ) );
mgr->SetConditions( EDA_3D_ACTIONS::showSMD, FlagCheck( FL_FP_ATTRIBUTES_NORMAL_INSERT ) ); mgr->SetConditions( EDA_3D_ACTIONS::showSMD, ACTION_CONDITIONS().Check( showSMD ) );
mgr->SetConditions( EDA_3D_ACTIONS::showVirtual, FlagCheck( FL_FP_ATTRIBUTES_VIRTUAL ) ); mgr->SetConditions( EDA_3D_ACTIONS::showVirtual, ACTION_CONDITIONS().Check( showVirtual ) );
mgr->SetConditions( EDA_3D_ACTIONS::showBBoxes, FlagCheck( FL_RENDER_OPENGL_SHOW_MODEL_BBOX ) ); mgr->SetConditions( EDA_3D_ACTIONS::showBBoxes, ACTION_CONDITIONS().Check( showBBoxes ) );
mgr->SetConditions( EDA_3D_ACTIONS::showAxis, FlagCheck( FL_AXIS ) ); mgr->SetConditions( EDA_3D_ACTIONS::showAxis, ACTION_CONDITIONS().Check( showAxes ) );
mgr->SetConditions( EDA_3D_ACTIONS::noGrid, GridSizeCheck( GRID3D_TYPE::NONE ) ); mgr->SetConditions( EDA_3D_ACTIONS::noGrid, GridSizeCheck( GRID3D_TYPE::NONE ) );
mgr->SetConditions( EDA_3D_ACTIONS::show10mmGrid, GridSizeCheck( GRID3D_TYPE::GRID_10MM ) ); mgr->SetConditions( EDA_3D_ACTIONS::show10mmGrid, GridSizeCheck( GRID3D_TYPE::GRID_10MM ) );
mgr->SetConditions( EDA_3D_ACTIONS::show5mmGrid, GridSizeCheck( GRID3D_TYPE::GRID_5MM ) ); mgr->SetConditions( EDA_3D_ACTIONS::show5mmGrid, GridSizeCheck( GRID3D_TYPE::GRID_5MM ) );
mgr->SetConditions( EDA_3D_ACTIONS::show2_5mmGrid, GridSizeCheck( GRID3D_TYPE::GRID_2P5MM ) ); mgr->SetConditions( EDA_3D_ACTIONS::show2_5mmGrid, GridSizeCheck( GRID3D_TYPE::GRID_2P5MM ) );
mgr->SetConditions( EDA_3D_ACTIONS::show1mmGrid, GridSizeCheck( GRID3D_TYPE::GRID_1MM ) ); mgr->SetConditions( EDA_3D_ACTIONS::show1mmGrid, GridSizeCheck( GRID3D_TYPE::GRID_1MM ) );
mgr->SetConditions( EDA_3D_ACTIONS::toggleOrtho, ACTION_CONDITIONS().Check( ortho ) );
auto orthoCondition =
[this]( const SELECTION& )
{
return m_currentCamera.GetProjection() == PROJECTION_TYPE::ORTHO;
};
mgr->SetConditions( EDA_3D_ACTIONS::toggleOrtho, ACTION_CONDITIONS().Check( orthoCondition ) );
#undef FlagCheck #undef FlagCheck
#undef GridSizeCheck #undef GridSizeCheck
@ -243,14 +262,14 @@ void EDA_3D_VIEWER_FRAME::NewDisplay( bool aForceImmediateRedraw )
void EDA_3D_VIEWER_FRAME::Redraw() void EDA_3D_VIEWER_FRAME::Redraw()
{ {
// Only update in OpenGL for an interactive interaction // Only update in OpenGL for an interactive interaction
if( m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::OPENGL ) if( m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
m_canvas->Request_refresh( true ); m_canvas->Request_refresh( true );
} }
void EDA_3D_VIEWER_FRAME::refreshRender() void EDA_3D_VIEWER_FRAME::refreshRender()
{ {
if( m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::OPENGL ) if( m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
m_canvas->Request_refresh(); m_canvas->Request_refresh();
else else
NewDisplay( true ); NewDisplay( true );
@ -327,18 +346,18 @@ void EDA_3D_VIEWER_FRAME::Process_Special_Functions( wxCommandEvent &event )
void EDA_3D_VIEWER_FRAME::OnRenderEngineSelection( wxCommandEvent &event ) void EDA_3D_VIEWER_FRAME::OnRenderEngineSelection( wxCommandEvent &event )
{ {
const RENDER_ENGINE old_engine = m_boardAdapter.GetRenderEngine(); int old_engine = m_boardAdapter.m_Cfg->m_Render.engine;
if( old_engine == RENDER_ENGINE::OPENGL ) if( old_engine == RENDER_ENGINE::OPENGL )
m_boardAdapter.SetRenderEngine( RENDER_ENGINE::RAYTRACING ); m_boardAdapter.m_Cfg->m_Render.engine = RENDER_ENGINE::RAYTRACING;
else else
m_boardAdapter.SetRenderEngine( RENDER_ENGINE::OPENGL ); m_boardAdapter.m_Cfg->m_Render.engine = RENDER_ENGINE::OPENGL;
wxLogTrace( m_logTrace, "EDA_3D_VIEWER_FRAME::OnRenderEngineSelection type %s ", wxLogTrace( m_logTrace, "EDA_3D_VIEWER_FRAME::OnRenderEngineSelection type %s ",
( m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::RAYTRACING ) ? "raytracing" : m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::RAYTRACING ? "raytracing"
"realtime" ); : "realtime" );
if( old_engine != m_boardAdapter.GetRenderEngine() ) if( old_engine != m_boardAdapter.m_Cfg->m_Render.engine )
RenderEngineChanged(); RenderEngineChanged();
} }
@ -348,7 +367,7 @@ void EDA_3D_VIEWER_FRAME::OnDisableRayTracing( wxCommandEvent& aEvent )
wxLogTrace( m_logTrace, "EDA_3D_VIEWER_FRAME::%s disabling ray tracing.", __WXFUNCTION__ ); wxLogTrace( m_logTrace, "EDA_3D_VIEWER_FRAME::%s disabling ray tracing.", __WXFUNCTION__ );
m_disable_ray_tracing = true; m_disable_ray_tracing = true;
m_boardAdapter.SetRenderEngine( RENDER_ENGINE::OPENGL ); m_boardAdapter.m_Cfg->m_Render.engine = RENDER_ENGINE::OPENGL;
} }
@ -392,88 +411,7 @@ void EDA_3D_VIEWER_FRAME::LoadSettings( APP_SETTINGS_BASE *aCfg )
if( cfg ) if( cfg )
{ {
m_boardAdapter.m_RtCameraLightColor = m_boardAdapter.m_Cfg = cfg;
m_boardAdapter.GetColor( cfg->m_Render.raytrace_lightColorCamera );
m_boardAdapter.m_RtLightColorTop =
m_boardAdapter.GetColor( cfg->m_Render.raytrace_lightColorTop );
m_boardAdapter.m_RtLightColorBottom =
m_boardAdapter.GetColor( cfg->m_Render.raytrace_lightColorBottom );
m_boardAdapter.m_RtLightColor.resize( cfg->m_Render.raytrace_lightColor.size() );
m_boardAdapter.m_RtLightSphericalCoords.resize( cfg->m_Render.raytrace_lightColor.size() );
for( size_t i = 0; i < cfg->m_Render.raytrace_lightColor.size(); ++i )
{
m_boardAdapter.m_RtLightColor[i] =
m_boardAdapter.GetColor( cfg->m_Render.raytrace_lightColor[i] );
SFVEC2F sphericalCoord =
SFVEC2F( ( cfg->m_Render.raytrace_lightElevation[i] + 90.0f ) / 180.0f,
cfg->m_Render.raytrace_lightAzimuth[i] / 180.0f );
sphericalCoord.x = glm::clamp( sphericalCoord.x, 0.0f, 1.0f );
sphericalCoord.y = glm::clamp( sphericalCoord.y, 0.0f, 2.0f );
m_boardAdapter.m_RtLightSphericalCoords[i] = sphericalCoord;
}
#define TRANSFER_SETTING( flag, field ) m_boardAdapter.SetFlag( flag, cfg->m_Render.field )
TRANSFER_SETTING( FL_USE_REALISTIC_MODE, realistic );
TRANSFER_SETTING( FL_SUBTRACT_MASK_FROM_SILK, subtract_mask_from_silk );
// OpenGL options
TRANSFER_SETTING( FL_RENDER_OPENGL_COPPER_THICKNESS, opengl_copper_thickness );
TRANSFER_SETTING( FL_RENDER_OPENGL_SHOW_MODEL_BBOX, opengl_show_model_bbox );
TRANSFER_SETTING( FL_HIGHLIGHT_ROLLOVER_ITEM, opengl_highlight_on_rollover );
TRANSFER_SETTING( FL_RENDER_OPENGL_AA_DISABLE_ON_MOVE, opengl_AA_disableOnMove );
TRANSFER_SETTING( FL_RENDER_OPENGL_THICKNESS_DISABLE_ON_MOVE, opengl_thickness_disableOnMove );
TRANSFER_SETTING( FL_RENDER_OPENGL_VIAS_DISABLE_ON_MOVE, opengl_vias_disableOnMove );
TRANSFER_SETTING( FL_RENDER_OPENGL_HOLES_DISABLE_ON_MOVE, opengl_holes_disableOnMove );
// Raytracing options
TRANSFER_SETTING( FL_RENDER_RAYTRACING_SHADOWS, raytrace_shadows );
TRANSFER_SETTING( FL_RENDER_RAYTRACING_BACKFLOOR, raytrace_backfloor );
TRANSFER_SETTING( FL_RENDER_RAYTRACING_REFRACTIONS, raytrace_refractions );
TRANSFER_SETTING( FL_RENDER_RAYTRACING_REFLECTIONS, raytrace_reflections );
TRANSFER_SETTING( FL_RENDER_RAYTRACING_POST_PROCESSING, raytrace_post_processing );
TRANSFER_SETTING( FL_RENDER_RAYTRACING_ANTI_ALIASING, raytrace_anti_aliasing );
TRANSFER_SETTING( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES, raytrace_procedural_textures );
TRANSFER_SETTING( FL_AXIS, show_axis );
TRANSFER_SETTING( FL_FP_ATTRIBUTES_NORMAL, show_footprints_normal );
TRANSFER_SETTING( FL_FP_ATTRIBUTES_NORMAL_INSERT, show_footprints_insert );
TRANSFER_SETTING( FL_FP_ATTRIBUTES_VIRTUAL, show_footprints_virtual );
TRANSFER_SETTING( FL_ZONE, show_zones );
TRANSFER_SETTING( FL_ADHESIVE, show_adhesive );
TRANSFER_SETTING( FL_SILKSCREEN, show_silkscreen );
TRANSFER_SETTING( FL_SOLDERMASK, show_soldermask );
TRANSFER_SETTING( FL_SOLDERPASTE, show_solderpaste );
TRANSFER_SETTING( FL_COMMENTS, show_comments );
TRANSFER_SETTING( FL_ECO, show_eco );
TRANSFER_SETTING( FL_SHOW_BOARD_BODY, show_board_body );
TRANSFER_SETTING( FL_CLIP_SILK_ON_VIA_ANNULUS, clip_silk_on_via_annulus );
TRANSFER_SETTING( FL_RENDER_PLATED_PADS_AS_PLATED, renderPlatedPadsAsPlated );
m_boardAdapter.SetGridType( static_cast<GRID3D_TYPE>( cfg->m_Render.grid_type ) );
m_boardAdapter.SetAntiAliasingMode(
static_cast<ANTIALIASING_MODE>( cfg->m_Render.opengl_AA_mode ) );
m_boardAdapter.m_OpenGlSelectionColor =
m_boardAdapter.GetColor( cfg->m_Render.opengl_selection_color );
m_boardAdapter.m_RtShadowSampleCount = cfg->m_Render.raytrace_nrsamples_shadows;
m_boardAdapter.m_RtReflectionSampleCount = cfg->m_Render.raytrace_nrsamples_reflections;
m_boardAdapter.m_RtRefractionSampleCount = cfg->m_Render.raytrace_nrsamples_refractions;
m_boardAdapter.m_RtSpreadShadows = cfg->m_Render.raytrace_spread_shadows;
m_boardAdapter.m_RtSpreadReflections = cfg->m_Render.raytrace_spread_reflections;
m_boardAdapter.m_RtSpreadRefractions = cfg->m_Render.raytrace_spread_refractions;
m_boardAdapter.m_RtRecursiveRefractionCount =
cfg->m_Render.raytrace_recursivelevel_refractions;
m_boardAdapter.m_RtRecursiveReflectionCount =
cfg->m_Render.raytrace_recursivelevel_reflections;
// When opening the 3D viewer, we use the opengl mode, not the ray tracing engine // When opening the 3D viewer, we use the opengl mode, not the ray tracing engine
// because the ray tracing is very time consumming, and can be seen as not working // because the ray tracing is very time consumming, and can be seen as not working
@ -484,11 +422,9 @@ void EDA_3D_VIEWER_FRAME::LoadSettings( APP_SETTINGS_BASE *aCfg )
"EDA_3D_VIEWER_FRAME::LoadSettings render setting Ray Trace" : "EDA_3D_VIEWER_FRAME::LoadSettings render setting Ray Trace" :
"EDA_3D_VIEWER_FRAME::LoadSettings render setting OpenGL" ); "EDA_3D_VIEWER_FRAME::LoadSettings render setting OpenGL" );
#else #else
m_boardAdapter.SetRenderEngine( RENDER_ENGINE::OPENGL ); m_boardAdapter.m_Cfg->m_Render.engine = RENDER_ENGINE::OPENGL;
#endif #endif
m_boardAdapter.SetMaterialMode( static_cast<MATERIAL_MODE>( cfg->m_Render.material_mode ) );
m_canvas->SetAnimationEnabled( cfg->m_Camera.animation_enabled ); m_canvas->SetAnimationEnabled( cfg->m_Camera.animation_enabled );
m_canvas->SetMovingSpeedMultiplier( cfg->m_Camera.moving_speed_multiplier ); m_canvas->SetMovingSpeedMultiplier( cfg->m_Camera.moving_speed_multiplier );
m_canvas->SetProjectionMode( cfg->m_Camera.projection_mode ); m_canvas->SetProjectionMode( cfg->m_Camera.projection_mode );
@ -506,95 +442,18 @@ void EDA_3D_VIEWER_FRAME::SaveSettings( APP_SETTINGS_BASE *aCfg )
wxLogTrace( m_logTrace, "EDA_3D_VIEWER_FRAME::SaveSettings" ); wxLogTrace( m_logTrace, "EDA_3D_VIEWER_FRAME::SaveSettings" );
wxLogTrace( m_logTrace, m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::RAYTRACING ? wxLogTrace( m_logTrace, m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::RAYTRACING ?
"EDA_3D_VIEWER_FRAME::SaveSettings render setting Ray Trace" : "EDA_3D_VIEWER_FRAME::SaveSettings render setting Ray Trace" :
"EDA_3D_VIEWER_FRAME::SaveSettings render setting OpenGL" ); "EDA_3D_VIEWER_FRAME::SaveSettings render setting OpenGL" );
if( cfg ) if( cfg )
{ {
auto save_color =
[] ( const SFVEC3F& aSource, COLOR4D& aTarget )
{
aTarget = COLOR4D( aSource.r, aSource.g, aSource.b, 1.0 );
};
save_color( m_boardAdapter.m_RtCameraLightColor, cfg->m_Render.raytrace_lightColorCamera );
save_color( m_boardAdapter.m_RtLightColorTop, cfg->m_Render.raytrace_lightColorTop );
save_color( m_boardAdapter.m_RtLightColorBottom, cfg->m_Render.raytrace_lightColorBottom );
for( size_t i = 0; i < cfg->m_Render.raytrace_lightColor.size(); ++i )
{
save_color( m_boardAdapter.m_RtLightColor[i], cfg->m_Render.raytrace_lightColor[i] );
cfg->m_Render.raytrace_lightElevation[i] =
(int)( m_boardAdapter.m_RtLightSphericalCoords[i].x * 180.0f - 90.0f );
cfg->m_Render.raytrace_lightAzimuth[i] =
(int)( m_boardAdapter.m_RtLightSphericalCoords[i].y * 180.0f );
}
cfg->m_Render.raytrace_nrsamples_shadows = m_boardAdapter.m_RtShadowSampleCount;
cfg->m_Render.raytrace_nrsamples_reflections = m_boardAdapter.m_RtReflectionSampleCount;
cfg->m_Render.raytrace_nrsamples_refractions = m_boardAdapter.m_RtRefractionSampleCount;
cfg->m_Render.raytrace_spread_shadows = m_boardAdapter.m_RtSpreadShadows;
cfg->m_Render.raytrace_spread_reflections = m_boardAdapter.m_RtSpreadReflections;
cfg->m_Render.raytrace_spread_refractions = m_boardAdapter.m_RtSpreadRefractions;
cfg->m_Render.raytrace_recursivelevel_refractions =
m_boardAdapter.m_RtRecursiveRefractionCount;
cfg->m_Render.raytrace_recursivelevel_reflections =
m_boardAdapter.m_RtRecursiveReflectionCount;
#define TRANSFER_SETTING( field, flag ) cfg->m_Render.field = m_boardAdapter.GetFlag( flag )
cfg->m_Render.engine = static_cast<int>( m_boardAdapter.GetRenderEngine() );
cfg->m_Render.grid_type = static_cast<int>( m_boardAdapter.GetGridType() );
cfg->m_Render.material_mode = static_cast<int>( m_boardAdapter.GetMaterialMode() );
cfg->m_Render.opengl_AA_mode = static_cast<int>( m_boardAdapter.GetAntiAliasingMode() );
save_color( m_boardAdapter.m_OpenGlSelectionColor, cfg->m_Render.opengl_selection_color );
cfg->m_Camera.animation_enabled = m_canvas->GetAnimationEnabled(); cfg->m_Camera.animation_enabled = m_canvas->GetAnimationEnabled();
cfg->m_Camera.moving_speed_multiplier = m_canvas->GetMovingSpeedMultiplier(); cfg->m_Camera.moving_speed_multiplier = m_canvas->GetMovingSpeedMultiplier();
cfg->m_Camera.projection_mode = m_canvas->GetProjectionMode(); cfg->m_Camera.projection_mode = m_canvas->GetProjectionMode();
if( EDA_3D_CONTROLLER* ctrlTool = GetToolManager()->GetTool<EDA_3D_CONTROLLER>() ) if( EDA_3D_CONTROLLER* ctrlTool = GetToolManager()->GetTool<EDA_3D_CONTROLLER>() )
cfg->m_Camera.rotation_increment = ctrlTool->GetRotationIncrement(); cfg->m_Camera.rotation_increment = ctrlTool->GetRotationIncrement();
TRANSFER_SETTING( opengl_AA_disableOnMove, FL_RENDER_OPENGL_AA_DISABLE_ON_MOVE );
TRANSFER_SETTING( opengl_copper_thickness, FL_RENDER_OPENGL_COPPER_THICKNESS );
TRANSFER_SETTING( opengl_show_model_bbox, FL_RENDER_OPENGL_SHOW_MODEL_BBOX );
TRANSFER_SETTING( opengl_highlight_on_rollover, FL_HIGHLIGHT_ROLLOVER_ITEM );
TRANSFER_SETTING( opengl_thickness_disableOnMove, FL_RENDER_OPENGL_THICKNESS_DISABLE_ON_MOVE );
TRANSFER_SETTING( opengl_vias_disableOnMove, FL_RENDER_OPENGL_VIAS_DISABLE_ON_MOVE );
TRANSFER_SETTING( opengl_holes_disableOnMove, FL_RENDER_OPENGL_HOLES_DISABLE_ON_MOVE );
TRANSFER_SETTING( raytrace_anti_aliasing, FL_RENDER_RAYTRACING_ANTI_ALIASING );
TRANSFER_SETTING( raytrace_backfloor, FL_RENDER_RAYTRACING_BACKFLOOR );
TRANSFER_SETTING( raytrace_post_processing, FL_RENDER_RAYTRACING_POST_PROCESSING );
TRANSFER_SETTING( raytrace_procedural_textures, FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES );
TRANSFER_SETTING( raytrace_reflections, FL_RENDER_RAYTRACING_REFLECTIONS );
TRANSFER_SETTING( raytrace_refractions, FL_RENDER_RAYTRACING_REFRACTIONS );
TRANSFER_SETTING( raytrace_shadows, FL_RENDER_RAYTRACING_SHADOWS );
TRANSFER_SETTING( realistic, FL_USE_REALISTIC_MODE );
TRANSFER_SETTING( show_adhesive, FL_ADHESIVE );
TRANSFER_SETTING( show_axis, FL_AXIS );
TRANSFER_SETTING( show_board_body, FL_SHOW_BOARD_BODY );
TRANSFER_SETTING( clip_silk_on_via_annulus, FL_CLIP_SILK_ON_VIA_ANNULUS );
TRANSFER_SETTING( renderPlatedPadsAsPlated, FL_RENDER_PLATED_PADS_AS_PLATED );
TRANSFER_SETTING( show_comments, FL_COMMENTS );
TRANSFER_SETTING( show_eco, FL_ECO );
TRANSFER_SETTING( show_footprints_insert, FL_FP_ATTRIBUTES_NORMAL_INSERT );
TRANSFER_SETTING( show_footprints_normal, FL_FP_ATTRIBUTES_NORMAL );
TRANSFER_SETTING( show_footprints_virtual, FL_FP_ATTRIBUTES_VIRTUAL );
TRANSFER_SETTING( show_silkscreen, FL_SILKSCREEN );
TRANSFER_SETTING( show_soldermask, FL_SOLDERMASK );
TRANSFER_SETTING( show_solderpaste, FL_SOLDERPASTE );
TRANSFER_SETTING( show_zones, FL_ZONE );
TRANSFER_SETTING( subtract_mask_from_silk, FL_SUBTRACT_MASK_FROM_SILK );
#undef TRANSFER_SETTING
} }
} }
@ -727,5 +586,5 @@ void EDA_3D_VIEWER_FRAME::loadCommonSettings()
const DPI_SCALING dpi{ settings, this }; const DPI_SCALING dpi{ settings, this };
m_canvas->SetScaleFactor( dpi.GetScaleFactor() ); m_canvas->SetScaleFactor( dpi.GetScaleFactor() );
// TODO(JE) use all control options // TODO(JE) use all control options
m_boardAdapter.SetFlag( FL_MOUSEWHEEL_PANNING, settings->m_Input.scroll_modifier_zoom != 0 ); m_boardAdapter.m_MousewheelPanning = settings->m_Input.scroll_modifier_zoom != 0;
} }

37
3d-viewer/3d_viewer/tools/eda_3d_actions.cpp
View File

@ -211,72 +211,63 @@ TOOL_ACTION EDA_3D_ACTIONS::showTHT( "3DViewer.Control.attributesTHT",
AS_ACTIVE, AS_ACTIVE,
'T', "", 'T', "",
_( "Toggle Through Hole 3D models" ), _( "Toggle 3D models for 'Through hole' type components" ), _( "Toggle Through Hole 3D models" ), _( "Toggle 3D models for 'Through hole' type components" ),
BITMAPS::show_tht, AF_NONE, (void*) FL_FP_ATTRIBUTES_NORMAL ); BITMAPS::show_tht, AF_NONE );
TOOL_ACTION EDA_3D_ACTIONS::showSMD( "3DViewer.Control.attributesSMD", TOOL_ACTION EDA_3D_ACTIONS::showSMD( "3DViewer.Control.attributesSMD",
AS_ACTIVE, AS_ACTIVE,
'S', "", 'S', "",
_( "Toggle SMD 3D models" ), _( "Toggle 3D models for 'Surface mount' type components" ), _( "Toggle SMD 3D models" ), _( "Toggle 3D models for 'Surface mount' type components" ),
BITMAPS::show_smt, AF_NONE, (void*) FL_FP_ATTRIBUTES_NORMAL_INSERT ); BITMAPS::show_smt, AF_NONE );
TOOL_ACTION EDA_3D_ACTIONS::showVirtual( "3DViewer.Control.attributesOther", TOOL_ACTION EDA_3D_ACTIONS::showVirtual( "3DViewer.Control.attributesOther",
AS_ACTIVE, AS_ACTIVE,
'V', "", 'V', "",
_( "Toggle Other 3D models" ), _( "Toggle 3D models for 'Other' type components" ), _( "Toggle Other 3D models" ), _( "Toggle 3D models for 'Other' type components" ),
BITMAPS::show_other, AF_NONE, (void*) FL_FP_ATTRIBUTES_VIRTUAL ); BITMAPS::show_other, AF_NONE );
TOOL_ACTION EDA_3D_ACTIONS::showBBoxes( "3DViewer.Control.showBoundingBoxes", TOOL_ACTION EDA_3D_ACTIONS::showBBoxes( "3DViewer.Control.showBoundingBoxes",
AS_GLOBAL, 0, "", AS_GLOBAL, 0, "",
_( "Show Model Bounding Boxes" ), _( "Show Model Bounding Boxes" ), _( "Show Model Bounding Boxes" ), _( "Show Model Bounding Boxes" ),
BITMAPS::ortho, AF_NONE, (void*) FL_RENDER_OPENGL_SHOW_MODEL_BBOX ); BITMAPS::ortho, AF_NONE );
TOOL_ACTION EDA_3D_ACTIONS::toggleRealisticMode( "3DViewer.Control.toggleRealisticMode", TOOL_ACTION EDA_3D_ACTIONS::toggleRealisticMode( "3DViewer.Control.toggleRealisticMode",
AS_GLOBAL, 0, "", AS_GLOBAL, 0, "",
_( "Toggle realistic mode" ), _( "Toggle realistic mode" ), _( "Toggle realistic mode" ), _( "Toggle realistic mode" ) );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_USE_REALISTIC_MODE );
TOOL_ACTION EDA_3D_ACTIONS::toggleBoardBody( "3DViewer.Control.toggleBoardBody", TOOL_ACTION EDA_3D_ACTIONS::toggleBoardBody( "3DViewer.Control.toggleBoardBody",
AS_GLOBAL, 0, "", AS_GLOBAL, 0, "",
_( "Toggle board body display" ), _( "Toggle board body display" ), _( "Toggle board body display" ), _( "Toggle board body display" ) );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_SHOW_BOARD_BODY );
TOOL_ACTION EDA_3D_ACTIONS::showAxis( "3DViewer.Control.showAxis", TOOL_ACTION EDA_3D_ACTIONS::showAxis( "3DViewer.Control.showAxis",
AS_GLOBAL, 0, "", AS_GLOBAL, 0, "",
_( "Show 3D Axis" ), _( "Show 3D Axis" ), _( "Show 3D Axis" ), _( "Show 3D Axis" ),
BITMAPS::axis3d_front, AF_NONE, (void*) FL_AXIS ); BITMAPS::axis3d_front, AF_NONE );
TOOL_ACTION EDA_3D_ACTIONS::toggleZones( "3DViewer.Control.toggleZones", TOOL_ACTION EDA_3D_ACTIONS::toggleZones( "3DViewer.Control.toggleZones",
AS_GLOBAL, 0, "", AS_GLOBAL, 0, "",
_( "Toggle zone display" ), _( "Toggle zone display" ), _( "Toggle zone display" ), _( "Toggle zone display" ) );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_ZONE );
TOOL_ACTION EDA_3D_ACTIONS::toggleAdhesive( "3DViewer.Control.toggleAdhesive", TOOL_ACTION EDA_3D_ACTIONS::toggleAdhesive( "3DViewer.Control.toggleAdhesive",
AS_GLOBAL, 0, "", AS_GLOBAL, 0, "",
_( "Toggle adhesive display" ), _( "Toggle display of adhesive layers" ), _( "Toggle adhesive display" ), _( "Toggle display of adhesive layers" ) );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_ADHESIVE );
TOOL_ACTION EDA_3D_ACTIONS::toggleSilk( "3DViewer.Control.toggleSilk", TOOL_ACTION EDA_3D_ACTIONS::toggleSilk( "3DViewer.Control.toggleSilk",
AS_GLOBAL, 0, "", AS_GLOBAL, 0, "",
_( "Toggle silkscreen display" ), _( "Toggle display of silkscreen layers" ), _( "Toggle silkscreen display" ), _( "Toggle display of silkscreen layers" ) );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_SILKSCREEN );
TOOL_ACTION EDA_3D_ACTIONS::toggleSolderMask( "3DViewer.Control.toggleSolderMask", TOOL_ACTION EDA_3D_ACTIONS::toggleSolderMask( "3DViewer.Control.toggleSolderMask",
AS_GLOBAL, 0, "", AS_GLOBAL, 0, "",
_( "Toggle solder mask display" ), _( "Toggle display of solder mask layers" ), _( "Toggle solder mask display" ), _( "Toggle display of solder mask layers" ) );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_SOLDERMASK );
TOOL_ACTION EDA_3D_ACTIONS::toggleSolderPaste( "3DViewer.Control.toggleSolderPaste", TOOL_ACTION EDA_3D_ACTIONS::toggleSolderPaste( "3DViewer.Control.toggleSolderPaste",
AS_GLOBAL, 0, "", AS_GLOBAL, 0, "",
_( "Toggle solder paste display" ), _( "Toggle display of solder paste layers" ), _( "Toggle solder paste display" ), _( "Toggle display of solder paste layers" ) );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_SOLDERPASTE );
TOOL_ACTION EDA_3D_ACTIONS::toggleComments( "3DViewer.Control.toggleComments", TOOL_ACTION EDA_3D_ACTIONS::toggleComments( "3DViewer.Control.toggleComments",
AS_GLOBAL, 0, "", AS_GLOBAL, 0, "",
_( "Toggle comments display" ), _( "Toggle display of comments and drawings layers" ), _( "Toggle comments display" ), _( "Toggle display of comments and drawings layers" ) );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_COMMENTS );
TOOL_ACTION EDA_3D_ACTIONS::toggleECO( "3DViewer.Control.toggleECO", TOOL_ACTION EDA_3D_ACTIONS::toggleECO( "3DViewer.Control.toggleECO",
AS_GLOBAL, 0, "", AS_GLOBAL, 0, "",
_( "Toggle ECO display" ), _( "Toggle display of ECO layers" ), _( "Toggle ECO display" ), _( "Toggle display of ECO layers" ) );
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_ECO );

30
3d-viewer/3d_viewer/tools/eda_3d_conditions.cpp
View File

@ -30,43 +30,15 @@
using namespace std::placeholders; using namespace std::placeholders;
SELECTION_CONDITION EDA_3D_CONDITIONS::MaterialMode( MATERIAL_MODE aMaterial )
{
return std::bind( &EDA_3D_CONDITIONS::materialModeFunction, _1, m_adapter, aMaterial );
}
SELECTION_CONDITION EDA_3D_CONDITIONS::Flag( DISPLAY3D_FLG aFlag )
{
return std::bind( &EDA_3D_CONDITIONS::flagFunction, _1, m_adapter, aFlag );
}
SELECTION_CONDITION EDA_3D_CONDITIONS::GridSize( GRID3D_TYPE aGridSize ) SELECTION_CONDITION EDA_3D_CONDITIONS::GridSize( GRID3D_TYPE aGridSize )
{ {
return std::bind( &EDA_3D_CONDITIONS::gridSizeFunction, _1, m_adapter, aGridSize ); return std::bind( &EDA_3D_CONDITIONS::gridSizeFunction, _1, m_adapter, aGridSize );
} }
bool EDA_3D_CONDITIONS::materialModeFunction( const SELECTION& aSelection,
BOARD_ADAPTER* aAdapter,
MATERIAL_MODE aMaterial )
{
return aAdapter->GetMaterialMode() == aMaterial;
}
bool EDA_3D_CONDITIONS::flagFunction( const SELECTION& aSelection,
BOARD_ADAPTER* aAdapter,
DISPLAY3D_FLG aFlag )
{
return aAdapter->GetFlag( aFlag );
}
bool EDA_3D_CONDITIONS::gridSizeFunction( const SELECTION& aSelection, bool EDA_3D_CONDITIONS::gridSizeFunction( const SELECTION& aSelection,
BOARD_ADAPTER* aAdapter, BOARD_ADAPTER* aAdapter,
GRID3D_TYPE aGridSize ) GRID3D_TYPE aGridSize )
{ {
return aAdapter->GetGridType() == aGridSize; return aAdapter->m_Cfg->m_Render.grid_type == aGridSize;
} }

26
3d-viewer/3d_viewer/tools/eda_3d_conditions.h
View File

@ -44,24 +44,6 @@ public:
m_adapter( aAdapter ) m_adapter( aAdapter )
{} {}
/**
* Creates a functor that tests if a specific material mode is active.
*
* @param aAdapter is the board adapter the setting is in
* @param aMaterial is the material mode to test for.
* @return Functor testing if a material mode is active.
*/
SELECTION_CONDITION MaterialMode( MATERIAL_MODE aMaterial );
/**
* Creates a functor that tests if the board adapter has a flag set currently.
*
* @param aAdapter is the board adapter the setting is in
* @param aFlag is the flag to test for.
* @return Functor testing if the flag is set.
*/
SELECTION_CONDITION Flag( DISPLAY3D_FLG aFlag );
/** /**
* Creates a functor that tests the current grid size. * Creates a functor that tests the current grid size.
* *
@ -72,14 +54,6 @@ public:
SELECTION_CONDITION GridSize( GRID3D_TYPE aGridSize ); SELECTION_CONDITION GridSize( GRID3D_TYPE aGridSize );
private: private:
///< Helper function used by MaterialMode()
static bool materialModeFunction( const SELECTION& aSelection, BOARD_ADAPTER* aAdapter,
MATERIAL_MODE aMaterial );
///< Helper function used by Flag()
static bool flagFunction( const SELECTION& aSelection, BOARD_ADAPTER* aAdapter,
DISPLAY3D_FLG aFlag );
///< Helper function used by GridDize() ///< Helper function used by GridDize()
static bool gridSizeFunction( const SELECTION& aSelection, BOARD_ADAPTER* aAdapter, static bool gridSizeFunction( const SELECTION& aSelection, BOARD_ADAPTER* aAdapter,
GRID3D_TYPE aGridSize ); GRID3D_TYPE aGridSize );

126
3d-viewer/3d_viewer/tools/eda_3d_controller.cpp
View File

@ -1,7 +1,7 @@
/* /*
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2020 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 2020-2021 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -152,17 +152,17 @@ int EDA_3D_CONTROLLER::RotateView( const TOOL_EVENT& aEvent )
switch( aEvent.Parameter<ROTATION_DIR>() ) switch( aEvent.Parameter<ROTATION_DIR>() )
{ {
case ROTATION_DIR::X_CW: m_camera->RotateX( -rotIncrement ); break; case ROTATION_DIR::X_CW: m_camera->RotateX( -rotIncrement ); break;
case ROTATION_DIR::X_CCW: m_camera->RotateX( rotIncrement ); break; case ROTATION_DIR::X_CCW: m_camera->RotateX( rotIncrement ); break;
/// Y rotations are backward b/c the RHR has Y pointing into the screen /// Y rotations are backward b/c the RHR has Y pointing into the screen
case ROTATION_DIR::Y_CW: m_camera->RotateY( rotIncrement ); break; case ROTATION_DIR::Y_CW: m_camera->RotateY( rotIncrement ); break;
case ROTATION_DIR::Y_CCW: m_camera->RotateY( -rotIncrement ); break; case ROTATION_DIR::Y_CCW: m_camera->RotateY( -rotIncrement ); break;
case ROTATION_DIR::Z_CW: m_camera->RotateZ( -rotIncrement ); break; case ROTATION_DIR::Z_CW: m_camera->RotateZ( -rotIncrement ); break;
case ROTATION_DIR::Z_CCW: m_camera->RotateZ( rotIncrement ); break; case ROTATION_DIR::Z_CCW: m_camera->RotateZ( rotIncrement ); break;
default: wxFAIL; break; default: wxFAIL; break;
} }
if( m_boardAdapter->GetRenderEngine() == RENDER_ENGINE::OPENGL ) if( m_boardAdapter->m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
m_canvas->Request_refresh(); m_canvas->Request_refresh();
else else
m_canvas->RenderRaytracingRequest(); m_canvas->RenderRaytracingRequest();
@ -173,9 +173,7 @@ int EDA_3D_CONTROLLER::RotateView( const TOOL_EVENT& aEvent )
int EDA_3D_CONTROLLER::SetMaterial( const TOOL_EVENT& aEvent ) int EDA_3D_CONTROLLER::SetMaterial( const TOOL_EVENT& aEvent )
{ {
MATERIAL_MODE mode = aEvent.Parameter<MATERIAL_MODE>(); m_boardAdapter->m_Cfg->m_Render.material_mode = aEvent.Parameter<MATERIAL_MODE>();
m_boardAdapter->SetMaterialMode( mode );
if( auto* viewer = dynamic_cast<EDA_3D_VIEWER_FRAME*>( m_toolMgr->GetToolHolder() ) ) if( auto* viewer = dynamic_cast<EDA_3D_VIEWER_FRAME*>( m_toolMgr->GetToolHolder() ) )
viewer->NewDisplay( true ); viewer->NewDisplay( true );
@ -190,7 +188,7 @@ int EDA_3D_CONTROLLER::ToggleOrtho( const TOOL_EVENT& aEvent )
{ {
m_camera->ToggleProjection(); m_camera->ToggleProjection();
if( m_boardAdapter->GetRenderEngine() == RENDER_ENGINE::OPENGL ) if( m_boardAdapter->m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
m_canvas->Request_refresh(); m_canvas->Request_refresh();
else else
m_canvas->RenderRaytracingRequest(); m_canvas->RenderRaytracingRequest();
@ -198,56 +196,91 @@ int EDA_3D_CONTROLLER::ToggleOrtho( const TOOL_EVENT& aEvent )
return 0; return 0;
} }
int EDA_3D_CONTROLLER::ToggleVisibility( const TOOL_EVENT& aEvent ) int EDA_3D_CONTROLLER::ToggleVisibility( const TOOL_EVENT& aEvent )
{ {
DISPLAY3D_FLG flag = aEvent.Parameter<DISPLAY3D_FLG>(); bool reload = false;
m_boardAdapter->SetFlag( flag, !m_boardAdapter->GetFlag( flag ) ); #define FLIP( x ) x = !x
switch( flag ) if( aEvent.IsAction( &EDA_3D_ACTIONS::showTHT ) )
{ {
// These commands do not request a 3D scene rebuild (and do not exist in raytracing): FLIP( m_boardAdapter->m_Cfg->m_Render.show_footprints_normal );
case FL_RENDER_OPENGL_SHOW_MODEL_BBOX: reload = true;
case FL_AXIS: }
m_canvas->Request_refresh(); else if( aEvent.IsAction( &EDA_3D_ACTIONS::showSMD ) )
break; {
FLIP( m_boardAdapter->m_Cfg->m_Render.show_footprints_insert );
reload = true;
}
else if( aEvent.IsAction( &EDA_3D_ACTIONS::showVirtual ) )
{
FLIP( m_boardAdapter->m_Cfg->m_Render.show_footprints_virtual );
reload = true;
}
else if( aEvent.IsAction( &EDA_3D_ACTIONS::showBBoxes ) )
{
FLIP( m_boardAdapter->m_Cfg->m_Render.opengl_show_model_bbox );
}
else if( aEvent.IsAction( &EDA_3D_ACTIONS::toggleRealisticMode ) )
{
FLIP( m_boardAdapter->m_Cfg->m_Render.realistic );
}
else if( aEvent.IsAction( &EDA_3D_ACTIONS::toggleBoardBody ) )
{
FLIP( m_boardAdapter->m_Cfg->m_Render.show_board_body );
}
else if( aEvent.IsAction( &EDA_3D_ACTIONS::showAxis ) )
{
FLIP( m_boardAdapter->m_Cfg->m_Render.show_axis );
}
else if( aEvent.IsAction( &EDA_3D_ACTIONS::toggleZones ) )
{
FLIP( m_boardAdapter->m_Cfg->m_Render.show_zones );
}
else if( aEvent.IsAction( &EDA_3D_ACTIONS::toggleAdhesive ) )
{
FLIP( m_boardAdapter->m_Cfg->m_Render.show_adhesive );
}
else if( aEvent.IsAction( &EDA_3D_ACTIONS::toggleSilk ) )
{
FLIP( m_boardAdapter->m_Cfg->m_Render.show_silkscreen );
}
else if( aEvent.IsAction( &EDA_3D_ACTIONS::toggleSolderMask ) )
{
FLIP( m_boardAdapter->m_Cfg->m_Render.show_soldermask );
}
else if( aEvent.IsAction( &EDA_3D_ACTIONS::toggleSolderPaste ) )
{
FLIP( m_boardAdapter->m_Cfg->m_Render.show_solderpaste );
}
else if( aEvent.IsAction( &EDA_3D_ACTIONS::toggleComments ) )
{
FLIP( m_boardAdapter->m_Cfg->m_Render.show_comments );
}
else if( aEvent.IsAction( &EDA_3D_ACTIONS::toggleECO ) )
{
FLIP( m_boardAdapter->m_Cfg->m_Render.show_eco );
}
// These commands do not request a 3D scene rebuild and exist in raytracing: if( reload )
case FL_RENDER_RAYTRACING_SHADOWS: {
case FL_RENDER_RAYTRACING_REFRACTIONS: if( m_boardAdapter->m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
case FL_RENDER_RAYTRACING_REFLECTIONS:
case FL_RENDER_RAYTRACING_ANTI_ALIASING:
if( m_boardAdapter->GetRenderEngine() == RENDER_ENGINE::OPENGL )
m_canvas->Request_refresh();
else
m_canvas->RenderRaytracingRequest();
break;
case FL_FP_ATTRIBUTES_NORMAL:
case FL_FP_ATTRIBUTES_NORMAL_INSERT:
case FL_FP_ATTRIBUTES_VIRTUAL:
// Loading 3D shapes can be needed if not yet loaded
if( m_boardAdapter->GetRenderEngine() == RENDER_ENGINE::OPENGL )
{ {
RENDER_3D_OPENGL* render = static_cast<RENDER_3D_OPENGL*>( m_canvas->GetCurrentRender() ); auto* renderer = static_cast<RENDER_3D_OPENGL*>( m_canvas->GetCurrentRender() );
render->Load3dModelsIfNeeded(); renderer->Load3dModelsIfNeeded();
m_canvas->Request_refresh(); m_canvas->Request_refresh();
} }
else else
{
m_canvas->RenderRaytracingRequest(); m_canvas->RenderRaytracingRequest();
}
break; }
else
default:
{ {
if( auto viewer = dynamic_cast<EDA_3D_VIEWER_FRAME*>( m_toolMgr->GetToolHolder() ) ) if( auto viewer = dynamic_cast<EDA_3D_VIEWER_FRAME*>( m_toolMgr->GetToolHolder() ) )
viewer->NewDisplay( true ); viewer->NewDisplay( true );
else else
m_canvas->Request_refresh(); m_canvas->Request_refresh();
break;
}
} }
return 0; return 0;
@ -256,8 +289,7 @@ int EDA_3D_CONTROLLER::ToggleVisibility( const TOOL_EVENT& aEvent )
int EDA_3D_CONTROLLER::On3DGridSelection( const TOOL_EVENT& aEvent ) int EDA_3D_CONTROLLER::On3DGridSelection( const TOOL_EVENT& aEvent )
{ {
GRID3D_TYPE grid = aEvent.Parameter<GRID3D_TYPE>(); m_boardAdapter->m_Cfg->m_Render.grid_type = aEvent.Parameter<GRID3D_TYPE>();
m_boardAdapter->SetGridType( grid );
if( m_canvas ) if( m_canvas )
m_canvas->Request_refresh(); m_canvas->Request_refresh();

10
3d-viewer/dialogs/panel_preview_3d_model.cpp
View File

@ -97,11 +97,9 @@ PANEL_PREVIEW_3D_MODEL::PANEL_PREVIEW_3D_MODEL( wxWindow* aParent, PCB_BASE_FRAM
aFrame->Prj().Get3DCacheManager() ); aFrame->Prj().Get3DCacheManager() );
m_boardAdapter.SetBoard( m_dummyBoard ); m_boardAdapter.SetBoard( m_dummyBoard );
m_boardAdapter.m_IsBoardView = false;
loadSettings(); loadSettings();
m_boardAdapter.SetFlag( FL_USE_SELECTION, false );
m_boardAdapter.SetFlag( FL_HIGHLIGHT_ROLLOVER_ITEM, false );
// Create the manager // Create the manager
m_toolManager = new TOOL_MANAGER; m_toolManager = new TOOL_MANAGER;
m_toolManager->SetEnvironment( m_dummyBoard, nullptr, nullptr, nullptr, this ); m_toolManager->SetEnvironment( m_dummyBoard, nullptr, nullptr, nullptr, this );
@ -174,7 +172,7 @@ void PANEL_PREVIEW_3D_MODEL::loadSettings()
m_previewPane->SetScaleFactor( dpi.GetScaleFactor() ); m_previewPane->SetScaleFactor( dpi.GetScaleFactor() );
// TODO(JE) use all control options // TODO(JE) use all control options
m_boardAdapter.SetFlag( FL_MOUSEWHEEL_PANNING, settings->m_Input.scroll_modifier_zoom != 0 ); m_boardAdapter.m_MousewheelPanning = settings->m_Input.scroll_modifier_zoom != 0;
COLOR_SETTINGS* colors = Pgm().GetSettingsManager().GetColorSettings(); COLOR_SETTINGS* colors = Pgm().GetSettingsManager().GetColorSettings();
@ -204,9 +202,7 @@ void PANEL_PREVIEW_3D_MODEL::loadSettings()
if( cfg ) if( cfg )
{ {
m_boardAdapter.SetRenderEngine( RENDER_ENGINE::OPENGL ); m_boardAdapter.m_Cfg = cfg;
m_boardAdapter.SetFlag( FL_USE_REALISTIC_MODE, cfg->m_Render.realistic );
m_boardAdapter.SetMaterialMode( static_cast<MATERIAL_MODE>( cfg->m_Render.material_mode ) );
m_previewPane->SetAnimationEnabled( cfg->m_Camera.animation_enabled ); m_previewPane->SetAnimationEnabled( cfg->m_Camera.animation_enabled );
m_previewPane->SetMovingSpeedMultiplier( cfg->m_Camera.moving_speed_multiplier ); m_previewPane->SetMovingSpeedMultiplier( cfg->m_Camera.moving_speed_multiplier );

2
eeschema/sch_painter.cpp
View File

@ -30,7 +30,6 @@
#include <symbol_library.h> #include <symbol_library.h>
#include <connection_graph.h> #include <connection_graph.h>
#include <gal/graphics_abstraction_layer.h> #include <gal/graphics_abstraction_layer.h>
#include <geometry/geometry_utils.h>
#include <geometry/shape_segment.h> #include <geometry/shape_segment.h>
#include <geometry/shape_simple.h> #include <geometry/shape_simple.h>
#include <gr_text.h> #include <gr_text.h>
@ -40,7 +39,6 @@
#include <lib_pin.h> #include <lib_pin.h>
#include <lib_text.h> #include <lib_text.h>
#include <math/util.h> #include <math/util.h>
#include <plotters/plotter.h>
#include <sch_bitmap.h> #include <sch_bitmap.h>
#include <sch_bus_entry.h> #include <sch_bus_entry.h>
#include <sch_symbol.h> #include <sch_symbol.h>