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() :
m_Cfg( nullptr ),
m_IsBoardView( true ),
m_MousewheelPanning( true ),
m_board( nullptr ),
m_3dModelManager( nullptr ),
m_colors( nullptr ),
@ -75,16 +78,9 @@ 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() )
m_colors = Pgm().GetSettingsManager().GetColorSettings();
m_renderEngine = RENDER_ENGINE::OPENGL;
m_materialMode = MATERIAL_MODE::NORMAL;
m_boardPos = wxPoint();
m_boardSize = wxSize();
m_boardCenter = SFVEC3F( 0.0f );
@ -109,27 +105,6 @@ BOARD_ADAPTER::BOARD_ADAPTER() :
m_averageHoleDiameter = 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_BgColorTop = SFVEC4F( 0.8, 0.8, 0.9, 1.0 );
m_BoardBodyColor = SFVEC4F( 0.4, 0.4, 0.5, 0.9 );
@ -146,18 +121,6 @@ BOARD_ADAPTER::BOARD_ADAPTER() :
m_frontPlatedPadPolys = 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 )
{
#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 F_Adhes:
return GetFlag( FL_ADHESIVE );
return m_Cfg->m_Render.show_adhesive;
case B_Paste:
case F_Paste:
return GetFlag( FL_SOLDERPASTE );
return m_Cfg->m_Render.show_solderpaste;
case B_SilkS:
case F_SilkS:
return GetFlag( FL_SILKSCREEN );
return m_Cfg->m_Render.show_silkscreen;
case B_Mask:
case F_Mask:
return GetFlag( FL_SOLDERMASK );
return m_Cfg->m_Render.show_soldermask;
case Dwgs_User:
case Cmts_User:
if( GetFlag( FL_USE_REALISTIC_MODE ) )
return false;
return GetFlag( FL_COMMENTS );
return !m_Cfg->m_Render.realistic && m_Cfg->m_Render.show_comments;
case Eco1_User:
case Eco2_User:
if( GetFlag( FL_USE_REALISTIC_MODE ) )
return false;
return GetFlag( FL_ECO );
return !m_Cfg->m_Render.realistic && m_Cfg->m_Render.show_eco;
case Edge_Cuts:
if( GetFlag( FL_SHOW_BOARD_BODY ) || GetFlag( FL_USE_REALISTIC_MODE ) )
return false;
return true;
return !m_Cfg->m_Render.realistic && !m_Cfg->m_Render.show_board_body;
case Margin:
if( GetFlag( FL_USE_REALISTIC_MODE ) )
return false;
return true;
return !m_Cfg->m_Render.realistic;
case B_Cu:
case F_Cu:
return m_board ? m_board->IsLayerVisible( aLayer ) || GetFlag( FL_USE_REALISTIC_MODE )
: true;
return !m_board || m_board->IsLayerVisible( aLayer ) || m_Cfg->m_Render.realistic;
default:
// 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
{
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 )
return GetFlag( FL_FP_ATTRIBUTES_NORMAL );
return m_Cfg->m_Render.show_footprints_normal;
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;
const bool succeedToGetBoardPolygon = createBoardPolygon( &msg );
const bool haveOutline = createBoardPolygon( &msg );
if( aWarningReporter )
{
if( !succeedToGetBoardPolygon )
if( !haveOutline )
aWarningReporter->Report( msg, RPT_SEVERITY_WARNING );
else
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;
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
if( ( bbbox.GetWidth() == 0 ) && ( bbbox.GetHeight() == 0 ) )
@ -720,14 +648,14 @@ float BOARD_ADAPTER::GetFootprintZPos( bool aIsFlipped ) const
{
if( aIsFlipped )
{
if( GetFlag( FL_SOLDERPASTE ) )
if( m_Cfg->m_Render.show_solderpaste )
return m_layerZcoordBottom[B_SilkS];
else
return m_layerZcoordBottom[B_Paste];
}
else
{
if( GetFlag( FL_SOLDERPASTE ) )
if( m_Cfg->m_Render.show_solderpaste )
return m_layerZcoordTop[F_SilkS];
else
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 );
}
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_cache/3d_cache.h"
#include "../common_ogl/ogl_attr_list.h"
#include "../3d_viewer/eda_3d_viewer_settings.h"
#include <layer_ids.h>
#include <pad.h>
@ -51,10 +52,10 @@
class COLOR_SETTINGS;
/// 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
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.
/// It will use this value to convert to a normalized value between
@ -90,22 +91,6 @@ public:
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.
*
@ -247,72 +232,6 @@ public:
*/
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.
*
@ -345,6 +264,8 @@ public:
*/
SFVEC4F GetColor( const COLOR4D& aColor ) const;
SFVEC2F GetSphericalCoord( int i ) const;
/**
* Get the top z position.
*
@ -464,8 +385,6 @@ public:
/**
* Get number of vias in this board.
*
* @return number of vias.
*/
unsigned int GetViaCount() const noexcept
{
@ -474,8 +393,6 @@ public:
/**
* Get number of holes in this board.
*
* @return number of holes.
*/
unsigned int GetHoleCount() const noexcept
{
@ -624,6 +541,10 @@ public:
static KIGFX::COLOR4D g_DefaultBoardBody;
public:
EDA_3D_VIEWER_SETTINGS* m_Cfg;
bool m_IsBoardView;
bool m_MousewheelPanning;
SFVEC4F m_BgColorBot; ///< background bottom color
SFVEC4F m_BgColorTop; ///< background top 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_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:
BOARD* m_board;
S3D_CACHE* m_3dModelManager;
COLOR_SETTINGS* m_colors;
BOARD* m_board;
S3D_CACHE* m_3dModelManager;
COLOR_SETTINGS* m_colors;
std::vector< bool > m_drawFlags;
GRID3D_TYPE m_gridType;
RENDER_ENGINE m_renderEngine;
MATERIAL_MODE m_materialMode;
ANTIALIASING_MODE m_antiAliasingMode;
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.
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.
///< Amalgamated polygon contours for various types of items
MAP_POLY m_layers_poly;
SHAPE_POLY_SET* m_frontPlatedPadPolys;
SHAPE_POLY_SET* m_backPlatedPadPolys;
///< Polygon contours for hole outer diameters for each layer.
MAP_POLY m_layerHoleOdPolys;
MAP_POLY m_layerHoleOdPolys; ///< Hole outer diameters (per layer)
MAP_POLY m_layerHoleIdPolys; ///< Hole inner diameters (per layer)
///< Polygon contours for hole inner diameters for each layer.
MAP_POLY m_layerHoleIdPolys;
SHAPE_POLY_SET m_nonPlatedThroughHoleOdPolys; ///< NPTH outer diameters
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_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.
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_layerHoleMap; ///< Holes for each layer.
BVH_CONTAINER_2D* m_platedPadsFront;
BVH_CONTAINER_2D* m_platedPadsBack;
///< The holes per each layer.
MAP_CONTAINER_2D_BASE m_layerHoleMap;
BVH_CONTAINER_2D m_throughHoleOds; ///< List of PTH outer diameters
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.
BVH_CONTAINER_2D m_throughHoleOds;
unsigned int m_copperLayersCount;
///< List of plated through hole annular rings.
BVH_CONTAINER_2D m_throughHoleAnnularRings;
double m_biuTo3Dunits; ///< Scale factor to convert board internal units to
///< 3D units normalized between -1.0 and 1.0.
///< List of through hole inner diameters.
BVH_CONTAINER_2D m_throughHoleIds;
std::array<float, PCB_LAYER_ID_COUNT> m_layerZcoordTop; ///< Top (End) Z position of each
///< layer in 3D units.
///< List of through hole vias with the radius of the hole inflated with the copper thickness.
BVH_CONTAINER_2D m_throughHoleViaOds;
std::array<float, PCB_LAYER_ID_COUNT> m_layerZcoordBottom; ///< Bottom (Start) Z position of
///< each layer in 3D units.
///< List of through hole via inner diameters.
BVH_CONTAINER_2D m_throughHoleViaIds;
float m_copperThickness3DU;
float m_epoxyThickness3DU;
float m_nonCopperLayerThickness3DU;
float m_solderPasteLayerThickness3DU;
///< Number of copper layers actually used by the board.
unsigned int m_copperLayersCount;
///< Scale factor to convert board internal units to 3D units normalized between -1.0 and 1.0.
double m_biuTo3Dunits;
///< 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;
unsigned int m_trackCount;
float m_averageTrackWidth;
unsigned int m_viaCount;
float m_averageViaHoleDiameter;
unsigned int m_holeCount;
float m_averageHoleDiameter;
/**
* Trace mask used to enable or disable the trace output of this class.
* The debug output can be turned on by setting the WXTRACE environment variable to
* "KI_TRACE_EDA_CINFO3D_VISU". See the wxWidgets documentation on wxLogTrace for
* more information.
* Trace mask used to enable or disable debug output for this class. Output can be turned
* on by setting the WXTRACE environment variable to "KI_TRACE_EDA_CINFO3D_VISU". See the
* wxWidgets documentation on wxLogTrace for more information.
*/
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 "../3d_rendering/raytracing/shapes2D/ring_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 <footprint.h>
#include <pad.h>
@ -205,14 +201,15 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
BVH_CONTAINER_2D *layerContainer = new BVH_CONTAINER_2D;
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;
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_backPlatedPadPolys = new SHAPE_POLY_SET;
@ -316,16 +313,15 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
hole_inner_radius + thickness,
*track ) );
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( new FILLED_CIRCLE_2D( via_center,
ring_radius,
*track ) );
ring_radius,
*track ) );
}
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(),
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,
via->GetStart(), hole_outer_ring_radius,
ARC_HIGH_DEF, ERROR_INSIDE );
TransformCircleToPolygon( m_throughHoleAnnularRingPolys, via->GetStart(),
hole_outer_ring_radius, ARC_HIGH_DEF,
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
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 )
{
@ -469,10 +465,8 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
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_throughHoleIds.Add( createPadWithDrill( pad, 0 ) );
}
@ -496,7 +490,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
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,
inflate, ARC_HIGH_DEF, ERROR_INSIDE );
@ -508,7 +502,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
else
{
// 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,
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 ) &&
GetFlag( FL_USE_REALISTIC_MODE );
const bool renderPlatedPadsAsPlated = m_Cfg->m_Render.renderPlatedPadsAsPlated
&& m_Cfg->m_Render.realistic;
// Add footprints PADs objects to containers
for( PCB_LAYER_ID curr_layer_id : layer_id )
@ -533,10 +527,10 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
// ADD PADS
for( FOOTPRINT* footprint : m_board->Footprints() )
{
// Note: NPTH pads are not drawn on copper layers when the pad
// has same shape as its hole
addPadsWithClearance( footprint, layerContainer, curr_layer_id, 0,
true, renderPlatedPadsAsPlated, false );
// Note: NPTH pads are not drawn on copper layers when the pad has the same shape
// as its hole
addPadsWithClearance( footprint, layerContainer, curr_layer_id, 0, true,
renderPlatedPadsAsPlated, false );
// Micro-wave footprints may have items on copper layers
addFootprintShapesWithClearance( footprint, layerContainer, curr_layer_id, 0 );
@ -558,7 +552,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
}
// 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 )
{
@ -639,7 +633,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
}
// 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 )
{
@ -678,7 +672,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
}
}
if( GetFlag( FL_ZONE ) )
if( m_Cfg->m_Render.show_zones )
{
if( aStatusReporter )
aStatusReporter->Report( _( "Create zones" ) );
@ -725,9 +719,9 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
addSolidAreasShapes( zone, layerContainer->second, layer );
}
if( GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS )
&& m_renderEngine == RENDER_ENGINE::OPENGL
&& layerPolyContainer != m_layers_poly.end() )
if( m_Cfg->m_Render.opengl_copper_thickness
&& m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL
&& layerPolyContainer != m_layers_poly.end() )
{
auto mut_it = layer_lock.find( layer );
@ -752,9 +746,9 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
if( aStatusReporter )
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() ) )
{
@ -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 > 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.reserve( layer_id.size() );
@ -799,9 +793,10 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
if( selected_layer_id.size() > 0 )
{
if( aStatusReporter )
aStatusReporter->Report( wxString::Format(
_( "Simplifying %d copper layers" ),
(int)selected_layer_id.size() ) );
{
aStatusReporter->Report( wxString::Format( _( "Simplifying %d copper layers" ),
(int) selected_layer_id.size() ) );
}
std::atomic<size_t> nextItem( 0 );
std::atomic<size_t> threadsFinished( 0 );
@ -1025,7 +1020,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
// Draw non copper zones
if( GetFlag( FL_ZONE ) )
if( m_Cfg->m_Render.show_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_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
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();
@ -485,7 +485,7 @@ void EDA_3D_CANVAS::DoRePaint()
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() )
{
reloadRaytracingForCalculations = true;
@ -593,11 +593,10 @@ void EDA_3D_CANVAS::OnMouseWheel( wxMouseEvent& event )
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();
else
if( event.GetWheelRotation() < 0 )
delta_move = -delta_move;
else if( event.GetWheelRotation() < 0 )
delta_move = -delta_move;
// mousewheel_panning enabled:
// wheel -> pan;
@ -608,7 +607,7 @@ void EDA_3D_CANVAS::OnMouseWheel( wxMouseEvent& event )
// wheel + ctrl -> horizontal scrolling;
// 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() )
m_camera.Pan( SFVEC3F( -delta_move, 0.0f, 0.0f ) );
@ -617,12 +616,12 @@ void EDA_3D_CANVAS::OnMouseWheel( wxMouseEvent& event )
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 ) );
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 ) );
mouseActivity = true;
@ -699,7 +698,7 @@ void EDA_3D_CANVAS::OnMouseMove( wxMouseEvent& event )
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,
static_cast<int>( EDA_3D_VIEWER_STATUSBAR::HOVERED_ITEM ) );
@ -777,7 +776,8 @@ void EDA_3D_CANVAS::OnMouseMove( wxMouseEvent& event )
}
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 );
Request_refresh();
@ -1111,7 +1111,10 @@ bool EDA_3D_CANVAS::SetView3D( int aKeycode )
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::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_
#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
enum class ROTATION_DIR
{
@ -96,7 +50,7 @@ enum class CAMERA_TYPE
/// Grid types
enum class GRID3D_TYPE
enum GRID3D_TYPE
{
NONE,
GRID_1MM,
@ -107,7 +61,7 @@ enum class GRID3D_TYPE
/// Render engine mode
enum class RENDER_ENGINE
enum RENDER_ENGINE
{
OPENGL,
RAYTRACING,
@ -115,7 +69,7 @@ enum class RENDER_ENGINE
/// Render 3d model shape materials mode
enum class MATERIAL_MODE
enum MATERIAL_MODE
{
NORMAL, ///< Use all material properties from model file
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
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.NewOutline();
@ -483,7 +483,7 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
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(),
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.GetThroughHoleViaOdPolys(), 1.0f, 0.0f, false );
if( m_boardAdapter.GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS ) &&
m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
if( m_boardAdapter.m_Cfg->m_Render.clip_silk_on_via_annulus &&
m_boardAdapter.m_Cfg->m_Render.realistic )
{
m_outerThroughHoleRings = generateHoles(
m_boardAdapter.GetThroughHoleAnnularRings().GetList(),
@ -557,8 +557,10 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
continue;
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;
@ -571,12 +573,12 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
{
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(),
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(),
SHAPE_POLY_SET::PM_FAST );
@ -585,7 +587,7 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
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() )
{
@ -611,8 +613,8 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
}
if( m_boardAdapter.GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) &&
m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
if( m_boardAdapter.m_Cfg->m_Render.renderPlatedPadsAsPlated
&& m_boardAdapter.m_Cfg->m_Render.realistic )
{
if( m_boardAdapter.GetFrontPlatedPadPolys() )
{
@ -652,8 +654,7 @@ void RENDER_3D_OPENGL::reload( REPORTER* aStatusReporter, REPORTER* aWarningRepo
if( aStatusReporter )
{
// Calculation time in seconds
const double calculation_time = (double)( GetRunningMicroSecs() -
stats_startReloadTime) / 1e6;
double calculation_time = (double)( GetRunningMicroSecs() - stats_startReloadTime) / 1e6;
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 );
aOutZtop = m_boardAdapter.GetLayerTopZPos( aLayerID );
aOutZbot = m_boardAdapter.GetLayerBottomZPos( aLayer );
aOutZtop = m_boardAdapter.GetLayerTopZPos( aLayer );
if( aOutZtop < aOutZbot )
{
@ -732,13 +733,11 @@ void RENDER_3D_OPENGL::generateViasAndPads()
if( m_boardAdapter.GetViaCount() > 0 )
{
const unsigned int reserve_nr_triangles_estimation =
m_boardAdapter.GetCircleSegmentCount(
m_boardAdapter.GetAverageViaHoleDiameter() ) * 8 *
m_boardAdapter.GetViaCount();
float averageDiameter = m_boardAdapter.GetAverageViaHoleDiameter();
unsigned int averageSegCount = m_boardAdapter.GetCircleSegmentCount( averageDiameter );
unsigned int trianglesEstimate = averageSegCount * 8 * m_boardAdapter.GetViaCount();
TRIANGLE_DISPLAY_LIST* layerTriangleVIA =
new TRIANGLE_DISPLAY_LIST( reserve_nr_triangles_estimation );
TRIANGLE_DISPLAY_LIST* layerTriangleVIA = new TRIANGLE_DISPLAY_LIST( trianglesEstimate );
// Insert plated vertical holes inside the board
@ -811,29 +810,27 @@ void RENDER_3D_OPENGL::generateViasAndPads()
// Subtract the holes
tht_outer_holes_poly.BooleanSubtract( tht_inner_holes_poly, SHAPE_POLY_SET::PM_FAST );
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
if( m_boardAdapter.m_Cfg->m_Render.realistic )
tht_outer_holes_poly.BooleanSubtract( m_antiBoardPolys, SHAPE_POLY_SET::PM_FAST );
CONTAINER_2D holesContainer;
ConvertPolygonToTriangles( tht_outer_holes_poly, holesContainer,
m_boardAdapter.BiuTo3dUnits(),
(const BOARD_ITEM &)*m_boardAdapter.GetBoard() );
m_boardAdapter.BiuTo3dUnits(), *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;
getLayerZPos( F_Cu, layer_z_top, dummy );
getLayerZPos( B_Cu, dummy, layer_z_bot );
TRIANGLE_DISPLAY_LIST* layerTriangles =
new TRIANGLE_DISPLAY_LIST( listHolesObject2d.size() );
TRIANGLE_DISPLAY_LIST* layerTriangles = new TRIANGLE_DISPLAY_LIST( holes2D.size() );
// Convert the list of objects(triangles) to triangle layer structure
for( const OBJECT_2D* itemOnLayer : listHolesObject2d )
for( const OBJECT_2D* itemOnLayer : holes2D )
{
const OBJECT_2D* object2d_A = itemOnLayer;
@ -889,9 +886,9 @@ void RENDER_3D_OPENGL::load3dModels( REPORTER* aStatusReporter )
if( !m_boardAdapter.GetBoard() )
return;
if( !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_NORMAL )
&& !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_NORMAL_INSERT )
&& !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_VIRTUAL ) )
if( !m_boardAdapter.m_Cfg->m_Render.show_footprints_normal
&& !m_boardAdapter.m_Cfg->m_Render.show_footprints_insert
&& !m_boardAdapter.m_Cfg->m_Render.show_footprints_virtual )
{
return;
}
@ -899,35 +896,34 @@ void RENDER_3D_OPENGL::load3dModels( REPORTER* aStatusReporter )
// Go for all 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 )
{
// 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)
wxFileName fn( model.m_Filename );
wxFileName fn( fp_model.m_Filename );
aStatusReporter->Report( wxString::Format( _( "Loading %s..." ),
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)
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
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
if( modelPtr )
{
MATERIAL_MODE materialMode = m_boardAdapter.GetMaterialMode();
MODEL_3D* ogl_model = new MODEL_3D( *modelPtr, materialMode );
int materialMode = m_boardAdapter.m_Cfg->m_Render.material_mode;
MODEL_3D* model = new MODEL_3D( *modelPtr, (MATERIAL_MODE) materialMode );
if( ogl_model )
m_3dModelMap[ model.m_Filename ] = ogl_model;
m_3dModelMap[ fp_model.m_Filename ] = model;
}
}
}

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

@ -169,7 +169,7 @@ void RENDER_3D_OPENGL::setupMaterials()
{
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
@ -328,7 +328,7 @@ void RENDER_3D_OPENGL::setLayerMaterial( PCB_LAYER_ID aLayerID )
// Convert Opacity to Transparency
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;
@ -395,7 +395,7 @@ SFVEC4F RENDER_3D_OPENGL::getLayerColor( PCB_LAYER_ID 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 )
{
@ -563,16 +563,16 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
reload( aStatusReporter, aWarningReporter );
// 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 );
}
else
{
// 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
m_lastGridType = m_boardAdapter.GetGridType();
m_lastGridType = static_cast<GRID3D_TYPE>( m_boardAdapter.m_Cfg->m_Render.grid_type );
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
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 );
else
glEnable( GL_MULTISAMPLE );
@ -627,13 +627,9 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
float zpos;
if( cameraPos.z > 0.0f )
{
zpos = glm::max( cameraPos.z, 0.5f ) + cameraPos.z * cameraPos.z;
}
else
{
zpos = glm::min( cameraPos.z,-0.5f ) - cameraPos.z * cameraPos.z;
}
// This is a point light.
const GLfloat headlight_pos[] = { cameraPos.x, cameraPos.y, zpos, 1.0f };
@ -641,16 +637,13 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
glLightfv( GL_LIGHT0, GL_POSITION, headlight_pos );
}
const bool drawMiddleSegments = !( aIsMoving &&
m_boardAdapter.GetFlag( FL_RENDER_OPENGL_THICKNESS_DISABLE_ON_MOVE ) );
bool skipThickness = aIsMoving && m_boardAdapter.m_Cfg->m_Render.opengl_thickness_disableOnMove;
bool skipRenderHoles = aIsMoving && m_boardAdapter.m_Cfg->m_Render.opengl_holes_disableOnMove;
bool skipRenderVias = aIsMoving && m_boardAdapter.m_Cfg->m_Render.opengl_vias_disableOnMove;
const bool skipRenderHoles = aIsMoving &&
m_boardAdapter.GetFlag( FL_RENDER_OPENGL_HOLES_DISABLE_ON_MOVE );
bool drawMiddleSegments = !skipThickness;
const bool skipRenderVias = aIsMoving &&
m_boardAdapter.GetFlag( FL_RENDER_OPENGL_VIAS_DISABLE_ON_MOVE );
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
if( m_boardAdapter.m_Cfg->m_Render.realistic )
{
// Draw vias and pad holes with copper material
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
const double opacity_min = 0.8;
if( m_boardAdapter.GetFlag( FL_SHOW_BOARD_BODY ) &&
( m_boardAdapter.m_BoardBodyColor.a > opacity_min ) )
if( m_boardAdapter.m_Cfg->m_Render.show_board_body
&& m_boardAdapter.m_BoardBodyColor.a > opacity_min )
{
if( ( layer_id > F_Cu ) && ( layer_id < B_Cu ) )
continue;
@ -693,21 +686,26 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
if( ( layer_id >= F_Cu ) && ( layer_id <= B_Cu ) )
{
if( !m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ||
!( m_boardAdapter.GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED ) &&
m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) ) )
setLayerMaterial( layer_id );
else
if( m_boardAdapter.m_Cfg->m_Render.renderPlatedPadsAsPlated
&& m_boardAdapter.m_Cfg->m_Render.realistic )
{
setCopperMaterial();
}
else
{
setLayerMaterial( layer_id );
}
if( skipRenderHoles )
{
pLayerDispList->DrawAllCameraCulled( m_camera.GetPos().z, drawMiddleSegments );
// Draw copper plated pads
if( ( ( layer_id == F_Cu ) || ( layer_id == B_Cu ) ) &&
( m_platedPadsFront || m_platedPadsBack ) )
if( ( layer_id == F_Cu || layer_id == B_Cu )
&& ( m_platedPadsFront || m_platedPadsBack ) )
{
setPlatedCopperAndDepthOffset( layer_id );
}
if( layer_id == F_Cu && m_platedPadsFront )
{
@ -814,33 +812,32 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
setLayerMaterial( layer_id );
OPENGL_RENDER_LIST* throughHolesOuter =
m_boardAdapter.GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS )
&& m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE )
&& ( layer_id == B_SilkS || layer_id == F_SilkS )
? m_outerThroughHoleRings
: m_outerThroughHoles;
m_boardAdapter.m_Cfg->m_Render.clip_silk_on_via_annulus
&& m_boardAdapter.m_Cfg->m_Render.realistic
&& ( layer_id == B_SilkS || layer_id == F_SilkS ) ? m_outerThroughHoleRings
: m_outerThroughHoles;
if( throughHolesOuter )
{
throughHolesOuter->ApplyScalePosition(
pLayerDispList->GetZBot(),
pLayerDispList->GetZTop() - pLayerDispList->GetZBot() );
throughHolesOuter->ApplyScalePosition( pLayerDispList->GetZBot(),
pLayerDispList->GetZTop()
- pLayerDispList->GetZBot() );
}
OPENGL_RENDER_LIST* anti_board = m_antiBoard;
if( anti_board )
{
anti_board->ApplyScalePosition(
pLayerDispList->GetZBot(),
pLayerDispList->GetZTop() - pLayerDispList->GetZBot() );
anti_board->ApplyScalePosition( pLayerDispList->GetZBot(),
pLayerDispList->GetZTop()
- pLayerDispList->GetZBot() );
}
if( !skipRenderHoles
&& m_boardAdapter.GetFlag( FL_SUBTRACT_MASK_FROM_SILK )
&& m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE )
&& ( ( layer_id == B_SilkS && m_layers.find( B_Mask ) != m_layers.end() )
|| ( layer_id == F_SilkS && m_layers.find( F_Mask ) != m_layers.end() ) ) )
&& m_boardAdapter.m_Cfg->m_Render.subtract_mask_from_silk
&& m_boardAdapter.m_Cfg->m_Render.realistic
&& ( ( layer_id == B_SilkS && m_layers.find( B_Mask ) != m_layers.end() )
|| ( layer_id == F_SilkS && m_layers.find( F_Mask ) != m_layers.end() ) ) )
{
const PCB_LAYER_ID layerMask_id = (layer_id == B_SilkS) ? B_Mask : F_Mask;
@ -880,13 +877,11 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
render3dModels( true, false );
// Display board body
if( m_boardAdapter.GetFlag( FL_SHOW_BOARD_BODY ) )
{
if( m_boardAdapter.m_Cfg->m_Render.show_board_body )
renderBoardBody( skipRenderHoles );
}
// 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
// on silkscreen where the SolderMask is removed
@ -949,7 +944,7 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
glDepthMask( GL_TRUE );
// Render Grid
if( m_boardAdapter.GetGridType() != GRID3D_TYPE::NONE )
if( m_boardAdapter.m_Cfg->m_Render.grid_type != GRID3D_TYPE::NONE )
{
glDisable( GL_LIGHTING );
@ -960,7 +955,7 @@ bool RENDER_3D_OPENGL::Redraw( bool aIsMoving, REPORTER* aStatusReporter,
}
// Render 3D arrows
if( m_boardAdapter.GetFlag( FL_AXIS ) )
if( m_boardAdapter.m_Cfg->m_Render.show_axis )
render3dArrows();
// 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;
if( m_boardAdapter.GetFlag( FL_USE_SELECTION ) )
if( m_boardAdapter.m_IsBoardView )
{
if( fp->IsSelected() )
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;
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 )
{
if( m_boardAdapter.GetFlag( FL_USE_SELECTION ) )
if( m_boardAdapter.m_IsBoardView )
render3dModelsSelected( aRenderTopOrBot, aRenderTransparentOnly, true );
render3dModelsSelected( aRenderTopOrBot, aRenderTransparentOnly, false );
@ -1227,6 +1222,8 @@ void RENDER_3D_OPENGL::renderFootprint( const FOOTPRINT* aFootprint, bool aRende
if( !aFootprint->Models().empty() )
{
const double zpos = m_boardAdapter.GetFootprintZPos( aFootprint->IsFlipped() );
SFVEC3F selColor = m_boardAdapter.GetColor( m_boardAdapter.m_Cfg->m_Render.opengl_selection_color );
glPushMatrix();
@ -1287,15 +1284,14 @@ void RENDER_3D_OPENGL::renderFootprint( const FOOTPRINT* aFootprint, bool aRende
{
modelPtr->DrawTransparent( sM.m_Opacity,
aFootprint->IsSelected() || aIsSelected,
m_boardAdapter.m_OpenGlSelectionColor );
selColor );
}
else
{
modelPtr->DrawOpaque( aFootprint->IsSelected() || aIsSelected,
m_boardAdapter.m_OpenGlSelectionColor );
modelPtr->DrawOpaque( aFootprint->IsSelected() || aIsSelected, selColor );
}
if( m_boardAdapter.GetFlag( FL_RENDER_OPENGL_SHOW_MODEL_BBOX ) )
if( m_boardAdapter.m_Cfg->m_Render.opengl_show_model_bbox )
{
glEnable( GL_BLEND );
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()
{
MATERIAL::SetDefaultRefractionRayCount( m_boardAdapter.m_RtRefractionSampleCount );
MATERIAL::SetDefaultReflectionRayCount( m_boardAdapter.m_RtReflectionSampleCount );
MATERIAL::SetDefaultRefractionRayCount( m_boardAdapter.m_Cfg->m_Render.raytrace_nrsamples_refractions );
MATERIAL::SetDefaultReflectionRayCount( m_boardAdapter.m_Cfg->m_Render.raytrace_nrsamples_reflections );
MATERIAL::SetDefaultRefractionRecursionCount( m_boardAdapter.m_RtRecursiveRefractionCount );
MATERIAL::SetDefaultReflectionRecursionCount( m_boardAdapter.m_RtRecursiveReflectionCount );
MATERIAL::SetDefaultRefractionRecursionCount( m_boardAdapter.m_Cfg->m_Render.raytrace_recursivelevel_refractions );
MATERIAL::SetDefaultReflectionRecursionCount( m_boardAdapter.m_Cfg->m_Render.raytrace_recursivelevel_reflections );
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_copperMaterial = COPPER_NORMAL( 4.0f * mmTo3Dunits, &m_boardMaterial );
m_platedCopperMaterial = PLATED_COPPER_NORMAL( 0.5f * mmTo3Dunits );
m_solderMaskMaterial = SOLDER_MASK_NORMAL( &m_boardMaterial );
m_plasticMaterial = PLASTIC_NORMAL( 0.05f * mmTo3Dunits );
m_shinyPlasticMaterial = PLASTIC_SHINE_NORMAL( 0.1f * mmTo3Dunits );
m_brushedMetalMaterial = BRUSHED_METAL_NORMAL( 0.05f * 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 ),
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_NonPlatedCopper = BLINN_PHONG_MATERIAL(
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 );
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_Paste = BLINN_PHONG_MATERIAL(
@ -132,7 +125,7 @@ void RENDER_3D_RAYTRACE::setupMaterials()
(SFVEC3F) m_boardAdapter.m_SilkScreenColorTop ) ),
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 );
// Assume that SolderMaskTop == SolderMaskBot
@ -153,7 +146,7 @@ void RENDER_3D_RAYTRACE::setupMaterials()
m_materials.m_SolderMask.SetCastShadows( true );
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_EpoxyBoard =
@ -166,7 +159,7 @@ void RENDER_3D_RAYTRACE::setupMaterials()
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 );
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,
// rather than the at the outer edge of the copper plating.
const BVH_CONTAINER_2D& throughHoleOuter =
( m_boardAdapter.GetFlag( FL_CLIP_SILK_ON_VIA_ANNULUS )
&& m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE )
&& ( ( aLayer_id == B_SilkS ) || ( aLayer_id == F_SilkS ) ) ) ?
m_boardAdapter.GetThroughHoleAnnularRings() :
m_boardAdapter.GetThroughHoleOds();
m_boardAdapter.m_Cfg->m_Render.clip_silk_on_via_annulus
&& m_boardAdapter.m_Cfg->m_Render.realistic
&& ( aLayer_id == B_SilkS || aLayer_id == F_SilkS ) ?
m_boardAdapter.GetThroughHoleAnnularRings() :
m_boardAdapter.GetThroughHoleOds();
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();
if( m_boardAdapter.GetFlag( FL_SUBTRACT_MASK_FROM_SILK )
&& m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE )
if( m_boardAdapter.m_Cfg->m_Render.subtract_mask_from_silk
&& m_boardAdapter.m_Cfg->m_Render.realistic
&& ( ( aLayer_id == B_SilkS && mapLayers.find( B_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 );
}
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();
@ -592,7 +585,7 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
case F_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;
else
layerColor = m_boardAdapter.GetLayerColor( layer_id );
@ -602,7 +595,7 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
case B_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;
else
layerColor = m_boardAdapter.GetLayerColor( layer_id );
@ -612,7 +605,7 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
case F_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;
else
layerColor = m_boardAdapter.GetLayerColor( layer_id );
@ -636,9 +629,9 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
break;
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 );
else
layerColor = m_boardAdapter.m_CopperColor;
@ -656,8 +649,8 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
} // for each layer on map
// Create plated copper
if( m_boardAdapter.GetFlag( FL_RENDER_PLATED_PADS_AS_PLATED )
&& m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
if( m_boardAdapter.m_Cfg->m_Render.renderPlatedPadsAsPlated
&& m_boardAdapter.m_Cfg->m_Render.realistic )
{
createItemsFromContainer( m_boardAdapter.GetPlatedPadsFront(), F_Cu, &m_materials.m_Copper,
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
// 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.
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;
@ -693,7 +687,7 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
SFVEC3F layerColor;
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
if( m_boardAdapter.m_Cfg->m_Render.realistic )
{
if( layer_id == B_Mask )
layerColor = m_boardAdapter.m_SolderMaskColorBot;
@ -798,7 +792,7 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
if( !aOnlyLoadCopperAndShapes )
{
// 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();
@ -878,41 +872,47 @@ void RENDER_3D_RAYTRACE::Reload( REPORTER* aStatusReporter, REPORTER* aWarningRe
&& ( aSource.b < ( 1.0f / 255.0f ) ) );
};
m_cameraLight = new DIRECTIONAL_LIGHT( SFVEC3F( 0.0f, 0.0f, 0.0f ),
m_boardAdapter.m_RtCameraLightColor );
SFVEC3F cameraLightColor =
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 );
if( !IsColorZero( m_boardAdapter.m_RtCameraLightColor ) )
if( !IsColorZero( cameraLightColor ) )
m_lights.push_back( m_cameraLight );
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,
+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,
-RANGE_SCALE_3D * 2.0f ),
m_boardAdapter.m_RtLightColorBottom ) );
bottomLightColor ) );
}
wxASSERT( m_boardAdapter.m_RtLightColor.size()
== m_boardAdapter.m_RtLightSphericalCoords.size() );
for( size_t i = 0; i < m_boardAdapter.m_RtLightColor.size(); ++i )
for( size_t i = 0; i < m_boardAdapter.m_Cfg->m_Render.raytrace_lightColor.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(
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 );
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
if( m_boardAdapter.m_Cfg->m_Render.realistic )
objPtr->SetColor( ConvertSRGBToLinear( m_boardAdapter.m_CopperColor ) );
else if( aVia->GetViaType() == VIATYPE::MICROVIA )
objPtr->SetColor( ConvertSRGBToLinear( m_boardAdapter.GetItemColor( LAYER_VIA_MICROVIA ) ) );
@ -989,7 +989,7 @@ void RENDER_3D_RAYTRACE::insertHole( const PAD* aPad )
SFVEC3F objColor;
if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
if( m_boardAdapter.m_Cfg->m_Render.realistic )
objColor = m_boardAdapter.m_CopperColor;
else
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() )
return;
if( !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_NORMAL )
&& !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_NORMAL_INSERT )
&& !m_boardAdapter.GetFlag( FL_FP_ATTRIBUTES_VIRTUAL ) )
if( !m_boardAdapter.m_Cfg->m_Render.show_footprints_normal
&& !m_boardAdapter.m_Cfg->m_Render.show_footprints_insert
&& !m_boardAdapter.m_Cfg->m_Render.show_footprints_virtual )
{
return;
}
@ -1312,7 +1312,7 @@ MODEL_MATERIALS* RENDER_3D_RAYTRACE::getModelMaterial( const S3DMODEL* a3DModel
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];
@ -1334,7 +1334,7 @@ MODEL_MATERIALS* RENDER_3D_RAYTRACE::getModelMaterial( const S3DMODEL* a3DModel
ConvertSRGBToLinear( material.m_Specular ), material.m_Shininess * 180.0f,
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
if( ( RGBtoGray( material.m_Diffuse ) < 0.3f )
@ -1502,7 +1502,7 @@ void RENDER_3D_RAYTRACE::addModels( CONTAINER_3D& aDstContainer, const S3DMODEL*
const SFVEC3F diffuseColor =
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(
MaterialDiffuseToColorCAD( diffuseColor ) ) );
else
@ -1510,7 +1510,8 @@ void RENDER_3D_RAYTRACE::addModels( CONTAINER_3D& aDstContainer, const S3DMODEL*
}
else
{
if( m_boardAdapter.GetMaterialMode() == MATERIAL_MODE::CAD_MODE )
if( m_boardAdapter.m_Cfg->m_Render.material_mode == MATERIAL_MODE::CAD_MODE )
{
newTriangle->SetColor(
ConvertSRGBToLinear( MaterialDiffuseToColorCAD(
mesh.m_Color[idx0] ) ),
@ -1518,11 +1519,14 @@ void RENDER_3D_RAYTRACE::addModels( CONTAINER_3D& aDstContainer, const S3DMODEL*
mesh.m_Color[idx1] ) ),
ConvertSRGBToLinear( MaterialDiffuseToColorCAD(
mesh.m_Color[idx2] ) ) );
}
else
{
newTriangle->SetColor(
ConvertSRGBToLinear( mesh.m_Color[idx0] ),
ConvertSRGBToLinear( mesh.m_Color[idx1] ),
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 )
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)
// 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
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;
else
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 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 )
{
@ -652,7 +652,7 @@ void RENDER_3D_RAYTRACE::renderBlockTracing( GLubyte* ptrPBO, signed int iBlock
if( !m_accelerator->Intersect( blockPacket, hitPacket_X0Y0 ) )
{
// 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 )
{
@ -670,10 +670,9 @@ void RENDER_3D_RAYTRACE::renderBlockTracing( GLubyte* ptrPBO, signed int iBlock
}
// This will set the output color to be displayed
// If post processing is enabled, it will not reflect the final result
// (as the final color will be computed on post processing)
// but it is used for report progress
const bool isFinalColor = !m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING );
// If post processing is enabled, it will not reflect the final result (as the final
// color will be computed on post processing) but it is used for report progress
const bool isFinalColor = !m_boardAdapter.m_Cfg->m_Render.raytrace_post_processing;
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)
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];
@ -719,16 +718,13 @@ void RENDER_3D_RAYTRACE::renderBlockTracing( GLubyte* ptrPBO, signed int iBlock
const SFVEC3F& outColor = bgColor[y];
for( unsigned int x = 0; x < RAYPACKET_DIM; ++x, ++i )
{
hitColor_AA_X1Y1[i] = outColor;
}
}
}
else
{
renderRayPackets( bgColor, blockPacket_AA_X1Y1.m_ray, hitPacket_AA_X1Y1,
m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_SHADOWS ),
hitColor_AA_X1Y1 );
m_boardAdapter.m_Cfg->m_Render.raytrace_shadows, hitColor_AA_X1Y1 );
}
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 )
{
const SFVEC3F color_average = ( hitColor_X0Y0[i] +
hitColor_AA_X1Y1[i] ) * SFVEC3F( 0.5f );
SFVEC3F color_average = ( hitColor_X0Y0[i] + hitColor_AA_X1Y1[i] ) * SFVEC3F( 0.5f );
hitColor_AA_X1Y0[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;
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) )
if( m_boardAdapter.m_Cfg->m_Render.raytrace_post_processing )
{
SFVEC2I bPos;
bPos.y = blockPos.y;
@ -798,6 +793,7 @@ void RENDER_3D_RAYTRACE::renderBlockTracing( GLubyte* ptrPBO, signed int iBlock
const SFVEC3F& hColor = hitColor_X0Y0[i];
if( hitPacket_X0Y0[i].m_hitresult == true )
{
m_postShaderSsao.SetPixelData( bPos.x, bPos.y,
hitPacket_X0Y0[i].m_HitInfo.m_HitNormal,
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_ShadowFactor );
}
else
{
m_postShaderSsao.SetPixelData( bPos.x, bPos.y, SFVEC3F( 0.0f ), hColor,
SFVEC3F( 0.0f ), 0, 1.0f );
}
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 )
{
if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) )
if( m_boardAdapter.m_Cfg->m_Render.raytrace_post_processing )
{
if( aStatusReporter )
aStatusReporter->Report( _( "Rendering: Post processing shader" ) );
m_postShaderSsao.SetShadowsEnabled(
m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_SHADOWS ) );
m_postShaderSsao.SetShadowsEnabled( m_boardAdapter.m_Cfg->m_Render.raytrace_shadows );
std::atomic<size_t> nextBlock( 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 */ )
{
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
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 );
#if USE_EXPERIMENTAL_SOFT_SHADOWS
const bool is_aa_enabled = m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_ANTI_ALIASING ) &&
(!m_isPreview);
bool is_aa_enabled = m_boardAdapter.m_Cfg->m_Render.raytrace_anti_aliasing && !m_isPreview;
#endif
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
{
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 );
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 disturbed_vector_to_light =
glm::normalize( vectorToLight + unifVector *
m_boardAdapter.m_RtSpreadShadows );
m_boardAdapter.m_Cfg->m_Render.raytrace_spread_shadows );
rayToLight.Init( hitPoint, disturbed_vector_to_light );
}
@ -1670,7 +1666,7 @@ SFVEC3F RENDER_3D_RAYTRACE::shadeHit( const SFVEC3F& aBgColor, const RAY& aRay,
{
// Reflections
if( ( objMaterial->GetReflection() > 0.0f )
&& m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_REFLECTIONS )
&& m_boardAdapter.m_Cfg->m_Render.raytrace_reflections
&& ( aRecursiveLevel < objMaterial->GetReflectionRecursionCount() ) )
{
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 =
glm::normalize( reflectVector +
UniformRandomHemisphereDirection() *
m_boardAdapter.m_RtSpreadReflections );
m_boardAdapter.m_Cfg->m_Render.raytrace_spread_reflections );
reflectedRay.Init( hitPoint, random_reflectVector );
}
@ -1721,7 +1717,7 @@ SFVEC3F RENDER_3D_RAYTRACE::shadeHit( const SFVEC3F& aBgColor, const RAY& aRay,
// Refraction
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() ) )
{
const float airIndex = 1.000293f;
@ -1760,7 +1756,7 @@ SFVEC3F RENDER_3D_RAYTRACE::shadeHit( const SFVEC3F& aBgColor, const RAY& aRay,
const SFVEC3F randomizeRefractedVector =
glm::normalize( refractedVector +
UniformRandomHemisphereDirection() *
m_boardAdapter.m_RtSpreadRefractions );
m_boardAdapter.m_Cfg->m_Render.raytrace_spread_refractions );
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 ) );
SetStatusWidths( arrayDim( status_dims ), status_dims );
m_canvas = new EDA_3D_CANVAS( this,
OGL_ATT_LIST::GetAttributesList( m_boardAdapter.GetAntiAliasingMode() ),
m_boardAdapter, m_currentCamera,
Prj().Get3DCacheManager() );
SETTINGS_MANAGER& mgr = Pgm().GetSettingsManager();
EDA_3D_VIEWER_SETTINGS* cfg = mgr.GetAppSettings<EDA_3D_VIEWER_SETTINGS>();
ANTIALIASING_MODE aaMode = static_cast<ANTIALIASING_MODE>( cfg->m_Render.opengl_AA_mode );
auto config = Pgm().GetSettingsManager().GetAppSettings<EDA_3D_VIEWER_SETTINGS>();
LoadSettings( config );
m_canvas = new EDA_3D_CANVAS( this, OGL_ATT_LIST::GetAttributesList( aaMode ),
m_boardAdapter, m_currentCamera, Prj().Get3DCacheManager() );
// Some settings need the canvas
LoadSettings( cfg );
loadCommonSettings();
// Create the 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_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();
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
m_toolManager->InvokeTool( "3DViewer.Control" );
@ -182,39 +181,59 @@ void EDA_3D_VIEWER_FRAME::setupUIConditions()
EDA_3D_CONDITIONS cond( &m_boardAdapter );
// Helper to define check conditions
#define FlagCheck( x ) ACTION_CONDITIONS().Check( cond.Flag( x ) )
#define GridSizeCheck( x ) ACTION_CONDITIONS().Check( cond.GridSize( x ) )
auto raytracingCondition =
auto raytracing =
[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,
ACTION_CONDITIONS().Check( raytracingCondition ) );
RegisterUIUpdateHandler( ID_RENDER_CURRENT_VIEW, ACTION_CONDITIONS().Check( raytracing ) );
mgr->SetConditions( EDA_3D_ACTIONS::showTHT, FlagCheck( FL_FP_ATTRIBUTES_NORMAL ) );
mgr->SetConditions( EDA_3D_ACTIONS::showSMD, FlagCheck( FL_FP_ATTRIBUTES_NORMAL_INSERT ) );
mgr->SetConditions( EDA_3D_ACTIONS::showVirtual, FlagCheck( FL_FP_ATTRIBUTES_VIRTUAL ) );
mgr->SetConditions( EDA_3D_ACTIONS::showTHT, ACTION_CONDITIONS().Check( showTH ) );
mgr->SetConditions( EDA_3D_ACTIONS::showSMD, ACTION_CONDITIONS().Check( showSMD ) );
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::showAxis, FlagCheck( FL_AXIS ) );
mgr->SetConditions( EDA_3D_ACTIONS::showBBoxes, ACTION_CONDITIONS().Check( showBBoxes ) );
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::show10mmGrid, GridSizeCheck( GRID3D_TYPE::GRID_10MM ) );
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::show1mmGrid, GridSizeCheck( GRID3D_TYPE::GRID_1MM ) );
auto orthoCondition =
[this]( const SELECTION& )
{
return m_currentCamera.GetProjection() == PROJECTION_TYPE::ORTHO;
};
mgr->SetConditions( EDA_3D_ACTIONS::toggleOrtho, ACTION_CONDITIONS().Check( orthoCondition ) );
mgr->SetConditions( EDA_3D_ACTIONS::toggleOrtho, ACTION_CONDITIONS().Check( ortho ) );
#undef FlagCheck
#undef GridSizeCheck
@ -243,14 +262,14 @@ void EDA_3D_VIEWER_FRAME::NewDisplay( bool aForceImmediateRedraw )
void EDA_3D_VIEWER_FRAME::Redraw()
{
// 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 );
}
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();
else
NewDisplay( true );
@ -327,18 +346,18 @@ void EDA_3D_VIEWER_FRAME::Process_Special_Functions( 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 )
m_boardAdapter.SetRenderEngine( RENDER_ENGINE::RAYTRACING );
m_boardAdapter.m_Cfg->m_Render.engine = RENDER_ENGINE::RAYTRACING;
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 ",
( m_boardAdapter.GetRenderEngine() == RENDER_ENGINE::RAYTRACING ) ? "raytracing" :
"realtime" );
m_boardAdapter.m_Cfg->m_Render.engine == RENDER_ENGINE::RAYTRACING ? "raytracing"
: "realtime" );
if( old_engine != m_boardAdapter.GetRenderEngine() )
if( old_engine != m_boardAdapter.m_Cfg->m_Render.engine )
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__ );
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 )
{
m_boardAdapter.m_RtCameraLightColor =
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;
m_boardAdapter.m_Cfg = cfg;
// 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
@ -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 OpenGL" );
#else
m_boardAdapter.SetRenderEngine( RENDER_ENGINE::OPENGL );
m_boardAdapter.m_Cfg->m_Render.engine = RENDER_ENGINE::OPENGL;
#endif
m_boardAdapter.SetMaterialMode( static_cast<MATERIAL_MODE>( cfg->m_Render.material_mode ) );
m_canvas->SetAnimationEnabled( cfg->m_Camera.animation_enabled );
m_canvas->SetMovingSpeedMultiplier( cfg->m_Camera.moving_speed_multiplier );
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, 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 OpenGL" );
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.moving_speed_multiplier = m_canvas->GetMovingSpeedMultiplier();
cfg->m_Camera.projection_mode = m_canvas->GetProjectionMode();
if( EDA_3D_CONTROLLER* ctrlTool = GetToolManager()->GetTool<EDA_3D_CONTROLLER>() )
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 };
m_canvas->SetScaleFactor( dpi.GetScaleFactor() );
// 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,
'T', "",
_( "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",
AS_ACTIVE,
'S', "",
_( "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",
AS_ACTIVE,
'V', "",
_( "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",
AS_GLOBAL, 0, "",
_( "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",
AS_GLOBAL, 0, "",
_( "Toggle realistic mode" ), _( "Toggle realistic mode" ),
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_USE_REALISTIC_MODE );
_( "Toggle realistic mode" ), _( "Toggle realistic mode" ) );
TOOL_ACTION EDA_3D_ACTIONS::toggleBoardBody( "3DViewer.Control.toggleBoardBody",
AS_GLOBAL, 0, "",
_( "Toggle board body display" ), _( "Toggle board body display" ),
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_SHOW_BOARD_BODY );
_( "Toggle board body display" ), _( "Toggle board body display" ) );
TOOL_ACTION EDA_3D_ACTIONS::showAxis( "3DViewer.Control.showAxis",
AS_GLOBAL, 0, "",
_( "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",
AS_GLOBAL, 0, "",
_( "Toggle zone display" ), _( "Toggle zone display" ),
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_ZONE );
_( "Toggle zone display" ), _( "Toggle zone display" ) );
TOOL_ACTION EDA_3D_ACTIONS::toggleAdhesive( "3DViewer.Control.toggleAdhesive",
AS_GLOBAL, 0, "",
_( "Toggle adhesive display" ), _( "Toggle display of adhesive layers" ),
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_ADHESIVE );
_( "Toggle adhesive display" ), _( "Toggle display of adhesive layers" ) );
TOOL_ACTION EDA_3D_ACTIONS::toggleSilk( "3DViewer.Control.toggleSilk",
AS_GLOBAL, 0, "",
_( "Toggle silkscreen display" ), _( "Toggle display of silkscreen layers" ),
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_SILKSCREEN );
_( "Toggle silkscreen display" ), _( "Toggle display of silkscreen layers" ) );
TOOL_ACTION EDA_3D_ACTIONS::toggleSolderMask( "3DViewer.Control.toggleSolderMask",
AS_GLOBAL, 0, "",
_( "Toggle solder mask display" ), _( "Toggle display of solder mask layers" ),
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_SOLDERMASK );
_( "Toggle solder mask display" ), _( "Toggle display of solder mask layers" ) );
TOOL_ACTION EDA_3D_ACTIONS::toggleSolderPaste( "3DViewer.Control.toggleSolderPaste",
AS_GLOBAL, 0, "",
_( "Toggle solder paste display" ), _( "Toggle display of solder paste layers" ),
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_SOLDERPASTE );
_( "Toggle solder paste display" ), _( "Toggle display of solder paste layers" ) );
TOOL_ACTION EDA_3D_ACTIONS::toggleComments( "3DViewer.Control.toggleComments",
AS_GLOBAL, 0, "",
_( "Toggle comments display" ), _( "Toggle display of comments and drawings layers" ),
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_COMMENTS );
_( "Toggle comments display" ), _( "Toggle display of comments and drawings layers" ) );
TOOL_ACTION EDA_3D_ACTIONS::toggleECO( "3DViewer.Control.toggleECO",
AS_GLOBAL, 0, "",
_( "Toggle ECO display" ), _( "Toggle display of ECO layers" ),
BITMAPS::INVALID_BITMAP, AF_NONE, (void*) FL_ECO );
_( "Toggle ECO display" ), _( "Toggle display of ECO layers" ) );

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

@ -30,43 +30,15 @@
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 )
{
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,
BOARD_ADAPTER* aAdapter,
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 )
{}
/**
* 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.
*
@ -72,14 +54,6 @@ public:
SELECTION_CONDITION GridSize( GRID3D_TYPE aGridSize );
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()
static bool gridSizeFunction( const SELECTION& aSelection, BOARD_ADAPTER* aAdapter,
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.
*
* 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
* 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>() )
{
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;
/// 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_CCW: m_camera->RotateY( -rotIncrement ); break;
case ROTATION_DIR::Z_CW: m_camera->RotateZ( -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::Z_CW: 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();
else
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 )
{
MATERIAL_MODE mode = aEvent.Parameter<MATERIAL_MODE>();
m_boardAdapter->SetMaterialMode( mode );
m_boardAdapter->m_Cfg->m_Render.material_mode = aEvent.Parameter<MATERIAL_MODE>();
if( auto* viewer = dynamic_cast<EDA_3D_VIEWER_FRAME*>( m_toolMgr->GetToolHolder() ) )
viewer->NewDisplay( true );
@ -190,7 +188,7 @@ int EDA_3D_CONTROLLER::ToggleOrtho( const TOOL_EVENT& aEvent )
{
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();
else
m_canvas->RenderRaytracingRequest();
@ -198,56 +196,91 @@ int EDA_3D_CONTROLLER::ToggleOrtho( const TOOL_EVENT& aEvent )
return 0;
}
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):
case FL_RENDER_OPENGL_SHOW_MODEL_BBOX:
case FL_AXIS:
m_canvas->Request_refresh();
break;
FLIP( m_boardAdapter->m_Cfg->m_Render.show_footprints_normal );
reload = true;
}
else if( aEvent.IsAction( &EDA_3D_ACTIONS::showSMD ) )
{
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:
case FL_RENDER_RAYTRACING_SHADOWS:
case FL_RENDER_RAYTRACING_REFRACTIONS:
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 )
if( reload )
{
if( m_boardAdapter->m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
{
RENDER_3D_OPENGL* render = static_cast<RENDER_3D_OPENGL*>( m_canvas->GetCurrentRender() );
render->Load3dModelsIfNeeded();
auto* renderer = static_cast<RENDER_3D_OPENGL*>( m_canvas->GetCurrentRender() );
renderer->Load3dModelsIfNeeded();
m_canvas->Request_refresh();
}
else
{
m_canvas->RenderRaytracingRequest();
break;
default:
}
}
else
{
if( auto viewer = dynamic_cast<EDA_3D_VIEWER_FRAME*>( m_toolMgr->GetToolHolder() ) )
viewer->NewDisplay( true );
else
m_canvas->Request_refresh();
break;
}
}
return 0;
@ -256,8 +289,7 @@ int EDA_3D_CONTROLLER::ToggleVisibility( const TOOL_EVENT& aEvent )
int EDA_3D_CONTROLLER::On3DGridSelection( const TOOL_EVENT& aEvent )
{
GRID3D_TYPE grid = aEvent.Parameter<GRID3D_TYPE>();
m_boardAdapter->SetGridType( grid );
m_boardAdapter->m_Cfg->m_Render.grid_type = aEvent.Parameter<GRID3D_TYPE>();
if( m_canvas )
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() );
m_boardAdapter.SetBoard( m_dummyBoard );
m_boardAdapter.m_IsBoardView = false;
loadSettings();
m_boardAdapter.SetFlag( FL_USE_SELECTION, false );
m_boardAdapter.SetFlag( FL_HIGHLIGHT_ROLLOVER_ITEM, false );
// Create the manager
m_toolManager = new TOOL_MANAGER;
m_toolManager->SetEnvironment( m_dummyBoard, nullptr, nullptr, nullptr, this );
@ -174,7 +172,7 @@ void PANEL_PREVIEW_3D_MODEL::loadSettings()
m_previewPane->SetScaleFactor( dpi.GetScaleFactor() );
// 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();
@ -204,9 +202,7 @@ void PANEL_PREVIEW_3D_MODEL::loadSettings()
if( cfg )
{
m_boardAdapter.SetRenderEngine( RENDER_ENGINE::OPENGL );
m_boardAdapter.SetFlag( FL_USE_REALISTIC_MODE, cfg->m_Render.realistic );
m_boardAdapter.SetMaterialMode( static_cast<MATERIAL_MODE>( cfg->m_Render.material_mode ) );
m_boardAdapter.m_Cfg = cfg;
m_previewPane->SetAnimationEnabled( cfg->m_Camera.animation_enabled );
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 <connection_graph.h>
#include <gal/graphics_abstraction_layer.h>
#include <geometry/geometry_utils.h>
#include <geometry/shape_segment.h>
#include <geometry/shape_simple.h>
#include <gr_text.h>
@ -40,7 +39,6 @@
#include <lib_pin.h>
#include <lib_text.h>
#include <math/util.h>
#include <plotters/plotter.h>
#include <sch_bitmap.h>
#include <sch_bus_entry.h>
#include <sch_symbol.h>