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

Rationalise 3D settings data-structure. 

Move the camera out to its own so that everything else is board-
related, and then rename BOARD_ADAPTER.

At some point the flags should probably be moved out too, and they
can have the EDA_3D_SETTINGS name.
This commit is contained in:
Jeff Young 2020-03-26 14:05:20 +00:00
parent 3e247a70d5
commit 5134856f18
34 changed files with 749 additions and 787 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
3d-viewer/3d_cache/dialogs/panel_prev_3d.cpp
View File

@ -42,7 +42,11 @@
PANEL_PREV_3D::PANEL_PREV_3D( wxWindow* aParent, PCB_BASE_FRAME* aFrame, MODULE* aModule, PANEL_PREV_3D::PANEL_PREV_3D( wxWindow* aParent, PCB_BASE_FRAME* aFrame, MODULE* aModule,
std::vector<MODULE_3D_SETTINGS>* aParentModelList ) : std::vector<MODULE_3D_SETTINGS>* aParentModelList ) :
PANEL_PREV_3D_BASE( aParent, wxID_ANY ) PANEL_PREV_3D_BASE( aParent, wxID_ANY ),
m_previewPane( nullptr ),
m_boardAdapter(),
m_currentCamera( m_trackBallCamera ),
m_trackBallCamera( RANGE_SCALE_3D )
{ {
m_userUnits = aFrame->GetUserUnits(); m_userUnits = aFrame->GetUserUnits();
@ -79,12 +83,9 @@ PANEL_PREV_3D::PANEL_PREV_3D( wxWindow* aParent, PCB_BASE_FRAME* aFrame, MODULE*
m_dummyModule = new MODULE( *aModule ); m_dummyModule = new MODULE( *aModule );
m_dummyBoard->Add( m_dummyModule ); m_dummyBoard->Add( m_dummyModule );
// Set 3d viewer configuration for preview
m_settings3Dviewer = new EDA_3D_SETTINGS();
// Create the 3D canvas // Create the 3D canvas
m_previewPane = new EDA_3D_CANVAS( this, COGL_ATT_LIST::GetAttributesList( true ), m_previewPane = new EDA_3D_CANVAS( this, COGL_ATT_LIST::GetAttributesList( true ),
m_dummyBoard, *m_settings3Dviewer, m_dummyBoard, m_boardAdapter, m_currentCamera,
aFrame->Prj().Get3DCacheManager() ); aFrame->Prj().Get3DCacheManager() );
loadCommonSettings(); loadCommonSettings();
@ -113,7 +114,6 @@ PANEL_PREV_3D::PANEL_PREV_3D( wxWindow* aParent, PCB_BASE_FRAME* aFrame, MODULE*
PANEL_PREV_3D::~PANEL_PREV_3D() PANEL_PREV_3D::~PANEL_PREV_3D()
{ {
delete m_settings3Dviewer;
delete m_dummyBoard; delete m_dummyBoard;
delete m_previewPane; delete m_previewPane;
} }
@ -137,7 +137,7 @@ void PANEL_PREV_3D::loadCommonSettings()
const DPI_SCALING dpi{ settings, this }; const DPI_SCALING dpi{ settings, this };
m_previewPane->SetScaleFactor( dpi.GetScaleFactor() ); m_previewPane->SetScaleFactor( dpi.GetScaleFactor() );
m_settings3Dviewer->SetFlag( FL_MOUSEWHEEL_PANNING, settings->m_Input.mousewheel_pan ); m_boardAdapter.SetFlag( FL_MOUSEWHEEL_PANNING, settings->m_Input.mousewheel_pan );
} }

15
3d-viewer/3d_cache/dialogs/panel_prev_3d.h
View File

@ -42,6 +42,7 @@
#include <tools_holder.h> #include <tools_holder.h>
#include <3d_canvas/eda_3d_canvas.h> #include <3d_canvas/eda_3d_canvas.h>
#include <3d_viewer_id.h> #include <3d_viewer_id.h>
#include <3d_rendering/ctrack_ball.h>
// Define min and max parameter values // Define min and max parameter values
#define MAX_SCALE 10000.0 #define MAX_SCALE 10000.0
@ -66,10 +67,10 @@
class S3D_CACHE; class S3D_CACHE;
class FILENAME_RESOLVER; class FILENAME_RESOLVER;
class BOARD; class BOARD;
class EDA_3D_SETTINGS; class BOARD_ADAPTER;
class MODULE; class MODULE;
class PANEL_PREV_3D: public EDA_3D_SETTINGS_HOLDER, public TOOLS_HOLDER, public PANEL_PREV_3D_BASE class PANEL_PREV_3D: public EDA_3D_BOARD_HOLDER, public TOOLS_HOLDER, public PANEL_PREV_3D_BASE
{ {
public: public:
PANEL_PREV_3D( wxWindow* aParent, PCB_BASE_FRAME* aFrame, MODULE* aModule, PANEL_PREV_3D( wxWindow* aParent, PCB_BASE_FRAME* aFrame, MODULE* aModule,
@ -79,7 +80,9 @@ public:
private: private:
EDA_3D_CANVAS* m_previewPane; EDA_3D_CANVAS* m_previewPane;
EDA_3D_SETTINGS* m_settings3Dviewer; BOARD_ADAPTER m_boardAdapter;
CCAMERA& m_currentCamera;
CTRACK_BALL m_trackBallCamera;
BOARD* m_dummyBoard; BOARD* m_dummyBoard;
MODULE* m_dummyModule; MODULE* m_dummyModule;
@ -141,7 +144,7 @@ private:
void View3DISO( wxCommandEvent& event ) override void View3DISO( wxCommandEvent& event ) override
{ {
m_settings3Dviewer->CameraGet().ToggleProjection(); m_currentCamera.ToggleProjection();
m_previewPane->Refresh(); m_previewPane->Refresh();
} }
@ -189,7 +192,9 @@ public:
void OnMenuEvent( wxMenuEvent& aEvent ); void OnMenuEvent( wxMenuEvent& aEvent );
wxWindow* GetToolCanvas() const override { return m_previewPane; } wxWindow* GetToolCanvas() const override { return m_previewPane; }
EDA_3D_SETTINGS* GetSettings() override { return m_settings3Dviewer; }
BOARD_ADAPTER& GetAdapter() override { return m_boardAdapter; }
CCAMERA& GetCurrentCamera() override { return m_currentCamera; }
/** /**
* @brief SetModelDataIdx - Sets the currently selected index in the model list so that * @brief SetModelDataIdx - Sets the currently selected index in the model list so that

49
3d-viewer/3d_canvas/3d_settings.cpp → 3d-viewer/3d_canvas/board_adapter.cpp
View File

@ -28,7 +28,7 @@
*/ */
#include "../3d_rendering/ccamera.h" #include "../3d_rendering/ccamera.h"
#include "3d_settings.h" #include "board_adapter.h"
#include <3d_rendering/3d_render_raytracing/shapes2D/cpolygon2d.h> #include <3d_rendering/3d_render_raytracing/shapes2D/cpolygon2d.h>
#include <class_board.h> #include <class_board.h>
#include <3d_math.h> #include <3d_math.h>
@ -44,22 +44,17 @@
* "KI_TRACE_EDA_CINFO3D_VISU". See the wxWidgets documentation on wxLogTrace for * "KI_TRACE_EDA_CINFO3D_VISU". See the wxWidgets documentation on wxLogTrace for
* more information. * more information.
*/ */
const wxChar *EDA_3D_SETTINGS::m_logTrace = wxT( "KI_TRACE_EDA_CINFO3D_VISU" ); const wxChar *BOARD_ADAPTER::m_logTrace = wxT( "KI_TRACE_EDA_CINFO3D_VISU" );
EDA_3D_SETTINGS G_null_EDA_3D_SETTINGS; BOARD_ADAPTER::BOARD_ADAPTER() :
EDA_3D_SETTINGS::EDA_3D_SETTINGS() :
m_board( nullptr ), m_board( nullptr ),
m_3d_model_manager( nullptr ), m_3d_model_manager( nullptr ),
m_colors( nullptr ), m_colors( nullptr ),
m_layerZcoordTop(), m_layerZcoordTop(),
m_layerZcoordBottom(), m_layerZcoordBottom()
m_currentCamera( m_trackBallCamera ),
m_trackBallCamera( RANGE_SCALE_3D )
{ {
wxLogTrace( m_logTrace, wxT( "EDA_3D_SETTINGS::EDA_3D_SETTINGS" ) ); wxLogTrace( m_logTrace, wxT( "BOARD_ADAPTER::BOARD_ADAPTER" ) );
m_3D_grid_type = GRID3D_TYPE::NONE; m_3D_grid_type = GRID3D_TYPE::NONE;
m_drawFlags.resize( FL_LAST, false ); m_drawFlags.resize( FL_LAST, false );
@ -119,13 +114,13 @@ EDA_3D_SETTINGS::EDA_3D_SETTINGS() :
} }
EDA_3D_SETTINGS::~EDA_3D_SETTINGS() BOARD_ADAPTER::~BOARD_ADAPTER()
{ {
destroyLayers(); destroyLayers();
} }
bool EDA_3D_SETTINGS::Is3DLayerEnabled( PCB_LAYER_ID aLayer ) const bool BOARD_ADAPTER::Is3DLayerEnabled( PCB_LAYER_ID aLayer ) const
{ {
wxASSERT( aLayer < PCB_LAYER_ID_COUNT ); wxASSERT( aLayer < PCB_LAYER_ID_COUNT );
@ -208,7 +203,7 @@ bool EDA_3D_SETTINGS::Is3DLayerEnabled( PCB_LAYER_ID aLayer ) const
} }
bool EDA_3D_SETTINGS::GetFlag( DISPLAY3D_FLG aFlag ) const bool BOARD_ADAPTER::GetFlag( DISPLAY3D_FLG aFlag ) const
{ {
wxASSERT( aFlag < FL_LAST ); wxASSERT( aFlag < FL_LAST );
@ -216,14 +211,14 @@ bool EDA_3D_SETTINGS::GetFlag( DISPLAY3D_FLG aFlag ) const
} }
void EDA_3D_SETTINGS::SetFlag( DISPLAY3D_FLG aFlag, bool aState ) void BOARD_ADAPTER::SetFlag( DISPLAY3D_FLG aFlag, bool aState )
{ {
wxASSERT( aFlag < FL_LAST ); wxASSERT( aFlag < FL_LAST );
m_drawFlags[aFlag] = aState; m_drawFlags[aFlag] = aState;
} }
bool EDA_3D_SETTINGS::ShouldModuleBeDisplayed( MODULE_ATTR_T aModuleAttributs ) const bool BOARD_ADAPTER::ShouldModuleBeDisplayed( MODULE_ATTR_T aModuleAttributs ) const
{ {
if( ( ( aModuleAttributs == MOD_DEFAULT ) && if( ( ( aModuleAttributs == MOD_DEFAULT ) &&
GetFlag( FL_MODULE_ATTRIBUTES_NORMAL ) ) || GetFlag( FL_MODULE_ATTRIBUTES_NORMAL ) ) ||
@ -243,12 +238,12 @@ bool EDA_3D_SETTINGS::ShouldModuleBeDisplayed( MODULE_ATTR_T aModuleAttributs )
#define COPPER_THICKNESS KiROUND( 0.035 * IU_PER_MM ) // for 35 um #define COPPER_THICKNESS KiROUND( 0.035 * IU_PER_MM ) // for 35 um
#define TECH_LAYER_THICKNESS KiROUND( 0.04 * IU_PER_MM ) #define TECH_LAYER_THICKNESS KiROUND( 0.04 * IU_PER_MM )
int EDA_3D_SETTINGS::GetCopperThicknessBIU() const int BOARD_ADAPTER::GetCopperThicknessBIU() const
{ {
return COPPER_THICKNESS; return COPPER_THICKNESS;
} }
unsigned int EDA_3D_SETTINGS::GetNrSegmentsCircle( float aDiameter3DU ) const unsigned int BOARD_ADAPTER::GetNrSegmentsCircle( float aDiameter3DU ) const
{ {
wxASSERT( aDiameter3DU > 0.0f ); wxASSERT( aDiameter3DU > 0.0f );
@ -256,7 +251,7 @@ unsigned int EDA_3D_SETTINGS::GetNrSegmentsCircle( float aDiameter3DU ) const
} }
unsigned int EDA_3D_SETTINGS::GetNrSegmentsCircle( int aDiameterBIU ) const unsigned int BOARD_ADAPTER::GetNrSegmentsCircle( int aDiameterBIU ) const
{ {
wxASSERT( aDiameterBIU > 0 ); wxASSERT( aDiameterBIU > 0 );
@ -265,7 +260,7 @@ unsigned int EDA_3D_SETTINGS::GetNrSegmentsCircle( int aDiameterBIU ) const
} }
double EDA_3D_SETTINGS::GetCircleCorrectionFactor( int aNrSides ) const double BOARD_ADAPTER::GetCircleCorrectionFactor( int aNrSides ) const
{ {
wxASSERT( aNrSides >= 3 ); wxASSERT( aNrSides >= 3 );
@ -273,9 +268,9 @@ double EDA_3D_SETTINGS::GetCircleCorrectionFactor( int aNrSides ) const
} }
void EDA_3D_SETTINGS::InitSettings( REPORTER* aStatusTextReporter, REPORTER* aWarningTextReporter ) void BOARD_ADAPTER::InitSettings( REPORTER* aStatusTextReporter, REPORTER* aWarningTextReporter )
{ {
wxLogTrace( m_logTrace, wxT( "EDA_3D_SETTINGS::InitSettings" ) ); wxLogTrace( m_logTrace, wxT( "BOARD_ADAPTER::InitSettings" ) );
// Calculates the board bounding box // Calculates the board bounding box
// First, use only the board outlines // First, use only the board outlines
@ -446,7 +441,7 @@ void EDA_3D_SETTINGS::InitSettings( REPORTER* aStatusTextReporter, REPORTER* aWa
#ifdef PRINT_STATISTICS_3D_VIEWER #ifdef PRINT_STATISTICS_3D_VIEWER
unsigned stats_stopCreateLayersTime = GetRunningMicroSecs(); unsigned stats_stopCreateLayersTime = GetRunningMicroSecs();
printf( "EDA_3D_SETTINGS::InitSettings times\n" ); printf( "BOARD_ADAPTER::InitSettings times\n" );
printf( " CreateBoardPoly: %.3f ms\n", printf( " CreateBoardPoly: %.3f ms\n",
(float)( stats_stopCreateBoardPolyTime - stats_startCreateBoardPolyTime ) / 1e3 ); (float)( stats_stopCreateBoardPolyTime - stats_startCreateBoardPolyTime ) / 1e3 );
printf( " CreateLayers and holes: %.3f ms\n", printf( " CreateLayers and holes: %.3f ms\n",
@ -456,7 +451,7 @@ void EDA_3D_SETTINGS::InitSettings( REPORTER* aStatusTextReporter, REPORTER* aWa
} }
bool EDA_3D_SETTINGS::createBoardPolygon() bool BOARD_ADAPTER::createBoardPolygon()
{ {
m_board_poly.RemoveAllContours(); m_board_poly.RemoveAllContours();
@ -466,7 +461,7 @@ bool EDA_3D_SETTINGS::createBoardPolygon()
} }
float EDA_3D_SETTINGS::GetModulesZcoord3DIU( bool aIsFlipped ) const float BOARD_ADAPTER::GetModulesZcoord3DIU( bool aIsFlipped ) const
{ {
if( aIsFlipped ) if( aIsFlipped )
{ {
@ -485,7 +480,7 @@ float EDA_3D_SETTINGS::GetModulesZcoord3DIU( bool aIsFlipped ) const
} }
SFVEC3F EDA_3D_SETTINGS::GetLayerColor( PCB_LAYER_ID aLayerId ) const SFVEC3F BOARD_ADAPTER::GetLayerColor( PCB_LAYER_ID aLayerId ) const
{ {
wxASSERT( aLayerId < PCB_LAYER_ID_COUNT ); wxASSERT( aLayerId < PCB_LAYER_ID_COUNT );
@ -495,13 +490,13 @@ SFVEC3F EDA_3D_SETTINGS::GetLayerColor( PCB_LAYER_ID aLayerId ) const
} }
SFVEC3F EDA_3D_SETTINGS::GetItemColor( int aItemId ) const SFVEC3F BOARD_ADAPTER::GetItemColor( int aItemId ) const
{ {
return GetColor( m_colors->GetColor( aItemId ) ); return GetColor( m_colors->GetColor( aItemId ) );
} }
SFVEC3F EDA_3D_SETTINGS::GetColor( COLOR4D aColor ) const SFVEC3F BOARD_ADAPTER::GetColor( COLOR4D aColor ) const
{ {
return SFVEC3F( aColor.r, aColor.g, aColor.b ); return SFVEC3F( aColor.r, aColor.g, aColor.b );
} }

53
3d-viewer/3d_canvas/3d_settings.h → 3d-viewer/3d_canvas/board_adapter.h
View File

@ -22,8 +22,8 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/ */
#ifndef EDA_3D_SETTINGS_H #ifndef BOARD_ADAPTER_H
#define EDA_3D_SETTINGS_H #define BOARD_ADAPTER_H
#include <array> #include <array>
#include <vector> #include <vector>
@ -31,7 +31,6 @@
#include "../3d_rendering/3d_render_raytracing/accelerators/ccontainer.h" #include "../3d_rendering/3d_render_raytracing/accelerators/ccontainer.h"
#include "../3d_rendering/3d_render_raytracing/shapes3D/cbbox.h" #include "../3d_rendering/3d_render_raytracing/shapes3D/cbbox.h"
#include "../3d_rendering/ccamera.h" #include "../3d_rendering/ccamera.h"
#include "../3d_rendering/ctrack_ball.h"
#include "../3d_enums.h" #include "../3d_enums.h"
#include "../3d_cache/3d_cache.h" #include "../3d_cache/3d_cache.h"
@ -62,16 +61,16 @@ typedef std::map< PCB_LAYER_ID, SHAPE_POLY_SET *> MAP_POLY;
/** /**
* Class EDA_3D_SETTINGS * Class BOARD_ADAPTER
* Helper class to handle information needed to display 3D board * Helper class to handle information needed to display 3D board
*/ */
class EDA_3D_SETTINGS class BOARD_ADAPTER
{ {
public: public:
EDA_3D_SETTINGS(); BOARD_ADAPTER();
~EDA_3D_SETTINGS(); ~BOARD_ADAPTER();
/** /**
* @brief Set3DCacheManager - Update the Cache manager pointer * @brief Set3DCacheManager - Update the Cache manager pointer
@ -198,12 +197,6 @@ class EDA_3D_SETTINGS
*/ */
float GetModulesZcoord3DIU( bool aIsFlipped ) const ; float GetModulesZcoord3DIU( bool aIsFlipped ) const ;
/**
* @brief CameraGet - get current camera in use
* @return a camera
*/
CCAMERA &CameraGet() const { return m_currentCamera; }
/** /**
* @brief GridGet - get the current grid * @brief GridGet - get the current grid
* @return space type of the grid * @return space type of the grid
@ -517,27 +510,15 @@ public:
private: private:
/// Current board BOARD* m_board;
BOARD *m_board; S3D_CACHE* m_3d_model_manager;
/// pointer to the 3d model manager
S3D_CACHE *m_3d_model_manager;
/// pointer to current color settings
COLOR_SETTINGS* m_colors; COLOR_SETTINGS* m_colors;
// Render options // Render options
/// options flags to render the board
std::vector< bool > m_drawFlags; std::vector< bool > m_drawFlags;
/// Stores the current grid type
GRID3D_TYPE m_3D_grid_type; GRID3D_TYPE m_3D_grid_type;
/// render engine currently on use
RENDER_ENGINE m_render_engine; RENDER_ENGINE m_render_engine;
/// mode to render the 3d shape models material
MATERIAL_MODE m_material_mode; MATERIAL_MODE m_material_mode;
@ -635,13 +616,6 @@ private:
/// Non copper layers thickness /// Non copper layers thickness
float m_nonCopperLayerThickness3DU; float m_nonCopperLayerThickness3DU;
// Cameras
/// Holds a pointer to current camera in use.
CCAMERA &m_currentCamera;
CTRACK_BALL m_trackBallCamera;
/// min factor used for cicle segment approximation calculation /// min factor used for cicle segment approximation calculation
float m_calc_seg_min_factor3DU; float m_calc_seg_min_factor3DU;
@ -680,14 +654,11 @@ private:
}; };
/// This is a dummy visualization configuration class EDA_3D_BOARD_HOLDER
extern EDA_3D_SETTINGS G_null_EDA_3D_SETTINGS;
class EDA_3D_SETTINGS_HOLDER
{ {
public: public:
virtual EDA_3D_SETTINGS* GetSettings() = 0; virtual BOARD_ADAPTER& GetAdapter() = 0;
virtual CCAMERA& GetCurrentCamera() = 0;
}; };
#endif // EDA_3D_SETTINGS_H #endif // BOARD_ADAPTER_H

33
3d-viewer/3d_canvas/create_3Dgraphic_brd_items.cpp
View File

@ -30,17 +30,12 @@
* board_items_to_polygon_shape_transform.cpp * board_items_to_polygon_shape_transform.cpp
*/ */
#include "3d_settings.h"
#include "../3d_rendering/3d_render_raytracing/shapes2D/cring2d.h" #include "../3d_rendering/3d_render_raytracing/shapes2D/cring2d.h"
#include "../3d_rendering/3d_render_raytracing/shapes2D/cfilledcircle2d.h" #include "../3d_rendering/3d_render_raytracing/shapes2D/cfilledcircle2d.h"
#include "../3d_rendering/3d_render_raytracing/shapes2D/croundsegment2d.h" #include "../3d_rendering/3d_render_raytracing/shapes2D/croundsegment2d.h"
#include "../3d_rendering/3d_render_raytracing/shapes2D/cpolygon4pts2d.h" #include "../3d_rendering/3d_render_raytracing/shapes2D/cpolygon4pts2d.h"
#include "../3d_rendering/3d_render_raytracing/shapes2D/cpolygon2d.h"
#include "../3d_rendering/3d_render_raytracing/shapes2D/ctriangle2d.h" #include "../3d_rendering/3d_render_raytracing/shapes2D/ctriangle2d.h"
#include "../3d_rendering/3d_render_raytracing/accelerators/ccontainer2d.h" #include <board_adapter.h>
#include "../3d_rendering/3d_render_raytracing/shapes3D/ccylinder.h"
#include "../3d_rendering/3d_render_raytracing/shapes3D/clayeritem.h"
#include <class_board.h> #include <class_board.h>
#include <class_module.h> #include <class_module.h>
#include <class_pad.h> #include <class_pad.h>
@ -87,7 +82,7 @@ void addTextSegmToContainer( int x0, int y0, int xf, int yf, void* aData )
// Based on // Based on
// void TEXTE_PCB::TransformShapeWithClearanceToPolygonSet // void TEXTE_PCB::TransformShapeWithClearanceToPolygonSet
// board_items_to_polygon_shape_transform.cpp // board_items_to_polygon_shape_transform.cpp
void EDA_3D_SETTINGS::AddShapeWithClearanceToContainer( const TEXTE_PCB* aText, void BOARD_ADAPTER::AddShapeWithClearanceToContainer( const TEXTE_PCB* aText,
CGENERICCONTAINER2D *aDstContainer, CGENERICCONTAINER2D *aDstContainer,
PCB_LAYER_ID aLayerId, PCB_LAYER_ID aLayerId,
int aClearanceValue ) int aClearanceValue )
@ -131,7 +126,7 @@ void EDA_3D_SETTINGS::AddShapeWithClearanceToContainer( const TEXTE_PCB* aText,
} }
void EDA_3D_SETTINGS::AddShapeWithClearanceToContainer( const DIMENSION* aDimension, void BOARD_ADAPTER::AddShapeWithClearanceToContainer( const DIMENSION* aDimension,
CGENERICCONTAINER2D *aDstContainer, CGENERICCONTAINER2D *aDstContainer,
PCB_LAYER_ID aLayerId, PCB_LAYER_ID aLayerId,
int aClearanceValue ) int aClearanceValue )
@ -168,7 +163,7 @@ void EDA_3D_SETTINGS::AddShapeWithClearanceToContainer( const DIMENSION* aDimens
// Based on // Based on
// void MODULE::TransformGraphicShapesWithClearanceToPolygonSet // void MODULE::TransformGraphicShapesWithClearanceToPolygonSet
// board_items_to_polygon_shape_transform.cpp#L204 // board_items_to_polygon_shape_transform.cpp#L204
void EDA_3D_SETTINGS::AddGraphicsShapesWithClearanceToContainer( const MODULE* aModule, void BOARD_ADAPTER::AddGraphicsShapesWithClearanceToContainer( const MODULE* aModule,
CGENERICCONTAINER2D *aDstContainer, CGENERICCONTAINER2D *aDstContainer,
PCB_LAYER_ID aLayerId, PCB_LAYER_ID aLayerId,
int aInflateValue ) int aInflateValue )
@ -234,7 +229,7 @@ void EDA_3D_SETTINGS::AddGraphicsShapesWithClearanceToContainer( const MODULE* a
} }
COBJECT2D *EDA_3D_SETTINGS::createNewTrack( const TRACK* aTrack, COBJECT2D *BOARD_ADAPTER::createNewTrack( const TRACK* aTrack,
int aClearanceValue ) const int aClearanceValue ) const
{ {
SFVEC2F start3DU( aTrack->GetStart().x * m_biuTo3Dunits, SFVEC2F start3DU( aTrack->GetStart().x * m_biuTo3Dunits,
@ -281,7 +276,7 @@ COBJECT2D *EDA_3D_SETTINGS::createNewTrack( const TRACK* aTrack,
// Based on: // Based on:
// void D_PAD:: TransformShapeWithClearanceToPolygon( // void D_PAD:: TransformShapeWithClearanceToPolygon(
// board_items_to_polygon_shape_transform.cpp // board_items_to_polygon_shape_transform.cpp
void EDA_3D_SETTINGS::createNewPadWithClearance( const D_PAD* aPad, void BOARD_ADAPTER::createNewPadWithClearance( const D_PAD* aPad,
CGENERICCONTAINER2D *aDstContainer, CGENERICCONTAINER2D *aDstContainer,
wxSize aClearanceValue ) const wxSize aClearanceValue ) const
{ {
@ -295,7 +290,7 @@ void EDA_3D_SETTINGS::createNewPadWithClearance( const D_PAD* aPad,
if( !dx || !dy ) if( !dx || !dy )
{ {
wxLogTrace( m_logTrace, wxLogTrace( m_logTrace,
wxT( "EDA_3D_SETTINGS::createNewPadWithClearance - found an invalid pad" ) ); wxT( "BOARD_ADAPTER::createNewPadWithClearance - found an invalid pad" ) );
return; return;
} }
@ -533,13 +528,13 @@ void EDA_3D_SETTINGS::createNewPadWithClearance( const D_PAD* aPad,
// Based on: // Based on:
// BuildPadDrillShapePolygon // BuildPadDrillShapePolygon
// board_items_to_polygon_shape_transform.cpp // board_items_to_polygon_shape_transform.cpp
COBJECT2D *EDA_3D_SETTINGS::createNewPadDrill( const D_PAD* aPad, int aInflateValue ) COBJECT2D *BOARD_ADAPTER::createNewPadDrill( const D_PAD* aPad, int aInflateValue )
{ {
wxSize drillSize = aPad->GetDrillSize(); wxSize drillSize = aPad->GetDrillSize();
if( !drillSize.x || !drillSize.y ) if( !drillSize.x || !drillSize.y )
{ {
wxLogTrace( m_logTrace, wxT( "EDA_3D_SETTINGS::createNewPadDrill - found an invalid pad" ) ); wxLogTrace( m_logTrace, wxT( "BOARD_ADAPTER::createNewPadDrill - found an invalid pad" ) );
return NULL; return NULL;
} }
@ -584,7 +579,7 @@ COBJECT2D *EDA_3D_SETTINGS::createNewPadDrill( const D_PAD* aPad, int aInflateVa
} }
void EDA_3D_SETTINGS::AddPadsShapesWithClearanceToContainer( const MODULE* aModule, void BOARD_ADAPTER::AddPadsShapesWithClearanceToContainer( const MODULE* aModule,
CGENERICCONTAINER2D *aDstContainer, CGENERICCONTAINER2D *aDstContainer,
PCB_LAYER_ID aLayerId, PCB_LAYER_ID aLayerId,
int aInflateValue, int aInflateValue,
@ -647,7 +642,7 @@ void EDA_3D_SETTINGS::AddPadsShapesWithClearanceToContainer( const MODULE* aModu
// based on TransformArcToPolygon function from // based on TransformArcToPolygon function from
// common/convert_basic_shapes_to_polygon.cpp // common/convert_basic_shapes_to_polygon.cpp
void EDA_3D_SETTINGS::TransformArcToSegments( const wxPoint &aCentre, void BOARD_ADAPTER::TransformArcToSegments( const wxPoint &aCentre,
const wxPoint &aStart, const wxPoint &aStart,
double aArcAngle, double aArcAngle,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
@ -724,7 +719,7 @@ void EDA_3D_SETTINGS::TransformArcToSegments( const wxPoint &aCentre,
// Based on // Based on
// TransformShapeWithClearanceToPolygon // TransformShapeWithClearanceToPolygon
// board_items_to_polygon_shape_transform.cpp#L431 // board_items_to_polygon_shape_transform.cpp#L431
void EDA_3D_SETTINGS::AddShapeWithClearanceToContainer( const DRAWSEGMENT* aDrawSegment, void BOARD_ADAPTER::AddShapeWithClearanceToContainer( const DRAWSEGMENT* aDrawSegment,
CGENERICCONTAINER2D *aDstContainer, CGENERICCONTAINER2D *aDstContainer,
PCB_LAYER_ID aLayerId, PCB_LAYER_ID aLayerId,
int aClearanceValue ) int aClearanceValue )
@ -815,7 +810,7 @@ void EDA_3D_SETTINGS::AddShapeWithClearanceToContainer( const DRAWSEGMENT* aDraw
// Based on // Based on
// TransformSolidAreasShapesToPolygonSet // TransformSolidAreasShapesToPolygonSet
// board_items_to_polygon_shape_transform.cpp // board_items_to_polygon_shape_transform.cpp
void EDA_3D_SETTINGS::AddSolidAreasShapesToContainer( const ZONE_CONTAINER* aZoneContainer, void BOARD_ADAPTER::AddSolidAreasShapesToContainer( const ZONE_CONTAINER* aZoneContainer,
CGENERICCONTAINER2D *aDstContainer, CGENERICCONTAINER2D *aDstContainer,
PCB_LAYER_ID aLayerId ) PCB_LAYER_ID aLayerId )
{ {
@ -896,7 +891,7 @@ void EDA_3D_SETTINGS::AddSolidAreasShapesToContainer( const ZONE_CONTAINER* aZon
void EDA_3D_SETTINGS::buildPadShapeThickOutlineAsSegments( const D_PAD* aPad, void BOARD_ADAPTER::buildPadShapeThickOutlineAsSegments( const D_PAD* aPad,
CGENERICCONTAINER2D *aDstContainer, CGENERICCONTAINER2D *aDstContainer,
int aWidth ) int aWidth )
{ {

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

@ -30,7 +30,7 @@
* board_items_to_polygon_shape_transform.cpp * board_items_to_polygon_shape_transform.cpp
*/ */
#include "3d_settings.h" #include "board_adapter.h"
#include "../3d_rendering/3d_render_raytracing/shapes2D/cring2d.h" #include "../3d_rendering/3d_render_raytracing/shapes2D/cring2d.h"
#include "../3d_rendering/3d_render_raytracing/shapes2D/cfilledcircle2d.h" #include "../3d_rendering/3d_render_raytracing/shapes2D/cfilledcircle2d.h"
#include "../3d_rendering/3d_render_raytracing/shapes2D/croundsegment2d.h" #include "../3d_rendering/3d_render_raytracing/shapes2D/croundsegment2d.h"
@ -58,7 +58,7 @@
#include <profile.h> #include <profile.h>
void EDA_3D_SETTINGS::destroyLayers() void BOARD_ADAPTER::destroyLayers()
{ {
if( !m_layers_poly.empty() ) if( !m_layers_poly.empty() )
{ {
@ -113,7 +113,7 @@ void EDA_3D_SETTINGS::destroyLayers()
} }
void EDA_3D_SETTINGS::createLayers( REPORTER *aStatusTextReporter ) void BOARD_ADAPTER::createLayers( REPORTER *aStatusTextReporter )
{ {
destroyLayers(); destroyLayers();
@ -1059,7 +1059,7 @@ void EDA_3D_SETTINGS::createLayers( REPORTER *aStatusTextReporter )
#ifdef PRINT_STATISTICS_3D_VIEWER #ifdef PRINT_STATISTICS_3D_VIEWER
unsigned stats_endHolesBVHTime = GetRunningMicroSecs(); unsigned stats_endHolesBVHTime = GetRunningMicroSecs();
printf( "EDA_3D_SETTINGS::createLayers times\n" ); printf( "BOARD_ADAPTER::createLayers times\n" );
printf( " Copper Layers: %.3f ms\n", printf( " Copper Layers: %.3f ms\n",
(float)( stats_endCopperLayersTime - stats_startCopperLayersTime ) / 1e3 ); (float)( stats_endCopperLayersTime - stats_startCopperLayersTime ) / 1e3 );
printf( " Holes BVH creation: %.3f ms\n", printf( " Holes BVH creation: %.3f ms\n",

10
3d-viewer/3d_canvas/create_layer_poly.cpp
View File

@ -30,7 +30,7 @@
* board_items_to_polygon_shape_transform.cpp * board_items_to_polygon_shape_transform.cpp
*/ */
#include "3d_settings.h" #include "board_adapter.h"
#include <convert_basic_shapes_to_polygon.h> #include <convert_basic_shapes_to_polygon.h>
#include <class_edge_mod.h> #include <class_edge_mod.h>
#include <class_module.h> #include <class_module.h>
@ -38,7 +38,7 @@
// This is the same function as in board_items_to_polygon_shape_transform.cpp // This is the same function as in board_items_to_polygon_shape_transform.cpp
// but it adds the rect/trapezoid shapes with a different winding // but it adds the rect/trapezoid shapes with a different winding
void EDA_3D_SETTINGS::buildPadShapePolygon( const D_PAD* aPad, void BOARD_ADAPTER::buildPadShapePolygon( const D_PAD* aPad,
SHAPE_POLY_SET& aCornerBuffer, SHAPE_POLY_SET& aCornerBuffer,
wxSize aInflateValue ) const wxSize aInflateValue ) const
{ {
@ -105,7 +105,7 @@ void EDA_3D_SETTINGS::buildPadShapePolygon( const D_PAD* aPad,
} }
void EDA_3D_SETTINGS::buildPadShapeThickOutlineAsPolygon( const D_PAD* aPad, void BOARD_ADAPTER::buildPadShapeThickOutlineAsPolygon( const D_PAD* aPad,
SHAPE_POLY_SET& aCornerBuffer, SHAPE_POLY_SET& aCornerBuffer,
int aWidth ) const int aWidth ) const
{ {
@ -139,7 +139,7 @@ void EDA_3D_SETTINGS::buildPadShapeThickOutlineAsPolygon( const D_PAD* aPad,
// Based on the same function name in board_items_to_polyshape_transform.cpp // Based on the same function name in board_items_to_polyshape_transform.cpp
// It was implemented here to allow dynamic segments count per pad shape // It was implemented here to allow dynamic segments count per pad shape
void EDA_3D_SETTINGS::transformPadsShapesWithClearanceToPolygon( const PADS& aPads, PCB_LAYER_ID aLayer, void BOARD_ADAPTER::transformPadsShapesWithClearanceToPolygon( const PADS& aPads, PCB_LAYER_ID aLayer,
SHAPE_POLY_SET& aCornerBuffer, SHAPE_POLY_SET& aCornerBuffer,
int aInflateValue, int aInflateValue,
bool aSkipNPTHPadsWihNoCopper ) const bool aSkipNPTHPadsWihNoCopper ) const
@ -198,7 +198,7 @@ void EDA_3D_SETTINGS::transformPadsShapesWithClearanceToPolygon( const PADS& aPa
} }
} }
void EDA_3D_SETTINGS::transformGraphicModuleEdgeToPolygonSet( const MODULE *aModule, void BOARD_ADAPTER::transformGraphicModuleEdgeToPolygonSet( const MODULE *aModule,
PCB_LAYER_ID aLayer, PCB_LAYER_ID aLayer,
SHAPE_POLY_SET& aCornerBuffer ) const SHAPE_POLY_SET& aCornerBuffer ) const
{ {

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

@ -84,14 +84,16 @@ BEGIN_EVENT_TABLE( EDA_3D_CANVAS, wxGLCanvas )
END_EVENT_TABLE() END_EVENT_TABLE()
EDA_3D_CANVAS::EDA_3D_CANVAS( wxWindow *aParent, const int *aAttribList, BOARD *aBoard, EDA_3D_CANVAS::EDA_3D_CANVAS( wxWindow* aParent, const int* aAttribList, BOARD* aBoard,
EDA_3D_SETTINGS &aSettings , S3D_CACHE *a3DCachePointer ) : BOARD_ADAPTER& aBoardAdapter, CCAMERA& aCamera,
S3D_CACHE* a3DCachePointer ) :
HIDPI_GL_CANVAS( aParent, wxID_ANY, aAttribList, wxDefaultPosition, wxDefaultSize, HIDPI_GL_CANVAS( aParent, wxID_ANY, aAttribList, wxDefaultPosition, wxDefaultSize,
wxFULL_REPAINT_ON_RESIZE ), wxFULL_REPAINT_ON_RESIZE ),
m_eventDispatcher( nullptr ), m_eventDispatcher( nullptr ),
m_parentStatusBar( nullptr ), m_parentStatusBar( nullptr ),
m_glRC( nullptr ), m_glRC( nullptr ),
m_settings( aSettings ), m_boardAdapter( aBoardAdapter ),
m_camera( aCamera ),
m_3d_render( nullptr ) m_3d_render( nullptr )
{ {
wxLogTrace( m_logTrace, "EDA_3D_CANVAS::EDA_3D_CANVAS" ); wxLogTrace( m_logTrace, "EDA_3D_CANVAS::EDA_3D_CANVAS" );
@ -123,8 +125,8 @@ EDA_3D_CANVAS::EDA_3D_CANVAS( wxWindow *aParent, const int *aAttribList, BOARD *
m_render_raytracing_was_requested = false; m_render_raytracing_was_requested = false;
m_opengl_supports_raytracing = false; m_opengl_supports_raytracing = false;
m_3d_render_raytracing = new C3D_RENDER_RAYTRACING( aSettings ); m_3d_render_raytracing = new C3D_RENDER_RAYTRACING( m_boardAdapter, m_camera );
m_3d_render_ogl_legacy = new C3D_RENDER_OGL_LEGACY( aSettings ); m_3d_render_ogl_legacy = new C3D_RENDER_OGL_LEGACY( m_boardAdapter, m_camera );
wxASSERT( m_3d_render_raytracing != NULL ); wxASSERT( m_3d_render_raytracing != NULL );
wxASSERT( m_3d_render_ogl_legacy != NULL ); wxASSERT( m_3d_render_ogl_legacy != NULL );
@ -137,12 +139,12 @@ EDA_3D_CANVAS::EDA_3D_CANVAS( wxWindow *aParent, const int *aAttribList, BOARD *
RenderEngineChanged(); RenderEngineChanged();
wxASSERT( aBoard != NULL ); wxASSERT( aBoard != NULL );
m_settings.SetBoard( aBoard ); m_boardAdapter.SetBoard( aBoard );
m_settings.SetColorSettings( Pgm().GetSettingsManager().GetColorSettings() ); m_boardAdapter.SetColorSettings( Pgm().GetSettingsManager().GetColorSettings() );
wxASSERT( a3DCachePointer != NULL ); wxASSERT( a3DCachePointer != NULL );
m_settings.Set3DCacheManager( a3DCachePointer ); m_boardAdapter.Set3DCacheManager( a3DCachePointer );
const wxEventType events[] = const wxEventType events[] =
{ {
@ -287,12 +289,12 @@ void EDA_3D_CANVAS::GetScreenshot( wxImage &aDstImage )
void EDA_3D_CANVAS::ReloadRequest( BOARD *aBoard , S3D_CACHE *aCachePointer ) void EDA_3D_CANVAS::ReloadRequest( BOARD *aBoard , S3D_CACHE *aCachePointer )
{ {
if( aCachePointer != NULL ) if( aCachePointer != NULL )
m_settings.Set3DCacheManager( aCachePointer ); m_boardAdapter.Set3DCacheManager( aCachePointer );
if( aBoard != NULL ) if( aBoard != NULL )
m_settings.SetBoard( aBoard ); m_boardAdapter.SetBoard( aBoard );
m_settings.SetColorSettings( Pgm().GetSettingsManager().GetColorSettings() ); m_boardAdapter.SetColorSettings( Pgm().GetSettingsManager().GetColorSettings() );
if( m_3d_render ) if( m_3d_render )
m_3d_render->ReloadRequest(); m_3d_render->ReloadRequest();
@ -319,10 +321,10 @@ void EDA_3D_CANVAS::DisplayStatus()
{ {
wxString msg; wxString msg;
msg.Printf( "dx %3.2f", m_settings.CameraGet().GetCameraPos().x ); msg.Printf( "dx %3.2f", m_camera.GetCameraPos().x );
m_parentStatusBar->SetStatusText( msg, static_cast<int>( EDA_3D_VIEWER_STATUSBAR::X_POS ) ); m_parentStatusBar->SetStatusText( msg, static_cast<int>( EDA_3D_VIEWER_STATUSBAR::X_POS ) );
msg.Printf( "dy %3.2f", m_settings.CameraGet().GetCameraPos().y ); msg.Printf( "dy %3.2f", m_camera.GetCameraPos().y );
m_parentStatusBar->SetStatusText( msg, static_cast<int>( EDA_3D_VIEWER_STATUSBAR::Y_POS ) ); m_parentStatusBar->SetStatusText( msg, static_cast<int>( EDA_3D_VIEWER_STATUSBAR::Y_POS ) );
} }
} }
@ -380,7 +382,7 @@ void EDA_3D_CANVAS::OnPaint( wxPaintEvent &event )
// is wrong when next another canvas is repainted. // is wrong when next another canvas is repainted.
wxSize clientSize = GetNativePixelSize(); wxSize clientSize = GetNativePixelSize();
const bool windows_size_changed = m_settings.CameraGet().SetCurWindowSize( clientSize ); const bool windows_size_changed = m_camera.SetCurWindowSize( clientSize );
// Initialize openGL if need // Initialize openGL if need
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
@ -399,13 +401,13 @@ void EDA_3D_CANVAS::OnPaint( wxPaintEvent &event )
{ {
m_3d_render = m_3d_render_ogl_legacy; m_3d_render = m_3d_render_ogl_legacy;
m_render_raytracing_was_requested = false; m_render_raytracing_was_requested = false;
m_settings.RenderEngineSet( RENDER_ENGINE::OPENGL_LEGACY ); m_boardAdapter.RenderEngineSet( RENDER_ENGINE::OPENGL_LEGACY );
} }
// Check if a raytacing was requested and need to switch to raytracing mode // Check if a raytacing was requested and need to switch to raytracing mode
if( m_settings.RenderEngineGet() == RENDER_ENGINE::OPENGL_LEGACY ) if( m_boardAdapter.RenderEngineGet() == RENDER_ENGINE::OPENGL_LEGACY )
{ {
const bool was_camera_changed = m_settings.CameraGet().ParametersChanged(); const bool was_camera_changed = m_camera.ParametersChanged();
// It reverts back to OpenGL mode if it was requested a raytracing // It reverts back to OpenGL mode if it was requested a raytracing
// render of the current scene. AND the mouse / camera is moving // render of the current scene. AND the mouse / camera is moving
@ -426,7 +428,7 @@ void EDA_3D_CANVAS::OnPaint( wxPaintEvent &event )
{ {
const unsigned curtime_delta = GetRunningMicroSecs() - m_strtime_camera_movement; const unsigned curtime_delta = GetRunningMicroSecs() - m_strtime_camera_movement;
curtime_delta_s = (curtime_delta / 1e6) * m_camera_moving_speed; curtime_delta_s = (curtime_delta / 1e6) * m_camera_moving_speed;
m_settings.CameraGet().Interpolate( curtime_delta_s ); m_camera.Interpolate( curtime_delta_s );
if( curtime_delta_s > 1.0f ) if( curtime_delta_s > 1.0f )
{ {
@ -456,7 +458,7 @@ void EDA_3D_CANVAS::OnPaint( wxPaintEvent &event )
if( m_render_pivot ) if( m_render_pivot )
{ {
const float scale = glm::min( m_settings.CameraGet().ZoomGet(), 1.0f ); const float scale = glm::min( m_camera.ZoomGet(), 1.0f );
render_pivot( curtime_delta_s, scale * scale ); render_pivot( curtime_delta_s, scale * scale );
} }
@ -480,7 +482,7 @@ void EDA_3D_CANVAS::OnPaint( wxPaintEvent &event )
} }
// This will reset the flag of camera parameters changed // This will reset the flag of camera parameters changed
m_settings.CameraGet().ParametersChanged(); m_camera.ParametersChanged();
if( !err_messages.IsEmpty() ) if( !err_messages.IsEmpty() )
wxLogMessage( err_messages ); wxLogMessage( err_messages );
@ -540,9 +542,9 @@ void EDA_3D_CANVAS::OnMouseWheel( wxMouseEvent &event )
if( m_camera_is_moving ) if( m_camera_is_moving )
return; return;
float delta_move = m_delta_move_step_factor * m_settings.CameraGet().ZoomGet(); float delta_move = m_delta_move_step_factor * m_camera.ZoomGet();
if( m_settings.GetFlag( FL_MOUSEWHEEL_PANNING ) ) if( m_boardAdapter.GetFlag( FL_MOUSEWHEEL_PANNING ) )
delta_move *= (0.01f * event.GetWheelRotation()); delta_move *= (0.01f * event.GetWheelRotation());
else else
if( event.GetWheelRotation() < 0 ) if( event.GetWheelRotation() < 0 )
@ -557,28 +559,28 @@ void EDA_3D_CANVAS::OnMouseWheel( wxMouseEvent &event )
// wheel + ctrl -> horizontal scrolling; // wheel + ctrl -> horizontal scrolling;
// wheel -> zooming. // wheel -> zooming.
if( m_settings.GetFlag( FL_MOUSEWHEEL_PANNING ) && !event.ControlDown() ) if( m_boardAdapter.GetFlag( FL_MOUSEWHEEL_PANNING ) && !event.ControlDown() )
{ {
if( event.GetWheelAxis() == wxMOUSE_WHEEL_HORIZONTAL || event.ShiftDown() ) if( event.GetWheelAxis() == wxMOUSE_WHEEL_HORIZONTAL || event.ShiftDown() )
m_settings.CameraGet().Pan( SFVEC3F( -delta_move, 0.0f, 0.0f ) ); m_camera.Pan( SFVEC3F( -delta_move, 0.0f, 0.0f ) );
else else
m_settings.CameraGet().Pan( SFVEC3F( 0.0f, -delta_move, 0.0f ) ); m_camera.Pan( SFVEC3F( 0.0f, -delta_move, 0.0f ) );
mouseActivity = true; mouseActivity = true;
} }
else if( event.ShiftDown() && !m_settings.GetFlag( FL_MOUSEWHEEL_PANNING ) ) else if( event.ShiftDown() && !m_boardAdapter.GetFlag( FL_MOUSEWHEEL_PANNING ) )
{ {
m_settings.CameraGet().Pan( SFVEC3F( 0.0f, -delta_move, 0.0f ) ); m_camera.Pan( SFVEC3F( 0.0f, -delta_move, 0.0f ) );
mouseActivity = true; mouseActivity = true;
} }
else if( event.ControlDown() && !m_settings.GetFlag( FL_MOUSEWHEEL_PANNING ) ) else if( event.ControlDown() && !m_boardAdapter.GetFlag( FL_MOUSEWHEEL_PANNING ) )
{ {
m_settings.CameraGet().Pan( SFVEC3F( delta_move, 0.0f, 0.0f ) ); m_camera.Pan( SFVEC3F( delta_move, 0.0f, 0.0f ) );
mouseActivity = true; mouseActivity = true;
} }
else else
{ {
mouseActivity = m_settings.CameraGet().Zoom( event.GetWheelRotation() > 0 ? 1.1f : 1/1.1f ); mouseActivity = m_camera.Zoom( event.GetWheelRotation() > 0 ? 1.1f : 1/1.1f );
} }
// If it results on a camera movement // If it results on a camera movement
@ -594,7 +596,7 @@ void EDA_3D_CANVAS::OnMouseWheel( wxMouseEvent &event )
} }
// Update the cursor current mouse position on the camera // Update the cursor current mouse position on the camera
m_settings.CameraGet().SetCurMousePosition( event.GetPosition() ); m_camera.SetCurMousePosition( event.GetPosition() );
} }
@ -611,7 +613,7 @@ void EDA_3D_CANVAS::OnMagnify( wxMouseEvent& event )
float magnification = ( event.GetMagnification() + 1.0f ); float magnification = ( event.GetMagnification() + 1.0f );
m_settings.CameraGet().Zoom( magnification ); m_camera.Zoom( magnification );
DisplayStatus(); DisplayStatus();
Request_refresh(); Request_refresh();
@ -626,14 +628,14 @@ void EDA_3D_CANVAS::OnMouseMove( wxMouseEvent &event )
if( m_camera_is_moving ) if( m_camera_is_moving )
return; return;
m_settings.CameraGet().SetCurWindowSize( GetNativePixelSize() ); m_camera.SetCurWindowSize( GetNativePixelSize() );
if( event.Dragging() ) if( event.Dragging() )
{ {
if( event.LeftIsDown() ) // Drag if( event.LeftIsDown() ) // Drag
m_settings.CameraGet().Drag( event.GetPosition() ); m_camera.Drag( event.GetPosition() );
else if( event.MiddleIsDown() ) // Pan else if( event.MiddleIsDown() ) // Pan
m_settings.CameraGet().Pan( event.GetPosition() ); m_camera.Pan( event.GetPosition() );
m_mouse_is_moving = true; m_mouse_is_moving = true;
m_mouse_was_moved = true; m_mouse_was_moved = true;
@ -644,7 +646,7 @@ void EDA_3D_CANVAS::OnMouseMove( wxMouseEvent &event )
} }
const wxPoint eventPosition = event.GetPosition(); const wxPoint eventPosition = event.GetPosition();
m_settings.CameraGet().SetCurMousePosition( eventPosition ); m_camera.SetCurMousePosition( eventPosition );
} }
@ -774,7 +776,7 @@ void EDA_3D_CANVAS::move_pivot_based_on_cur_mouse_position()
SFVEC3F rayDir; SFVEC3F rayDir;
// Generate a ray origin and direction based on current mouser position and camera // Generate a ray origin and direction based on current mouser position and camera
m_settings.CameraGet().MakeRayAtCurrrentMousePosition( rayOrigin, rayDir ); m_camera.MakeRayAtCurrrentMousePosition( rayOrigin, rayDir );
RAY mouseRay; RAY mouseRay;
mouseRay.Init( rayOrigin, rayDir ); mouseRay.Init( rayOrigin, rayDir );
@ -782,12 +784,12 @@ void EDA_3D_CANVAS::move_pivot_based_on_cur_mouse_position()
float hit_t; float hit_t;
// Test it with the board bounding box // Test it with the board bounding box
if( m_settings.GetBBox3DU().Intersect( mouseRay, &hit_t ) ) if( m_boardAdapter.GetBBox3DU().Intersect( mouseRay, &hit_t ) )
{ {
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().SetLookAtPos_T1( mouseRay.at( hit_t ) ); m_camera.SetLookAtPos_T1( mouseRay.at( hit_t ) );
m_settings.CameraGet().ResetXYpos_T1(); m_camera.ResetXYpos_T1();
request_start_moving_camera(); request_start_moving_camera();
} }
@ -799,7 +801,7 @@ bool EDA_3D_CANVAS::SetView3D( int aKeycode )
if( m_camera_is_moving ) if( m_camera_is_moving )
return false; return false;
const float delta_move = m_delta_move_step_factor * m_settings.CameraGet().ZoomGet(); const float delta_move = m_delta_move_step_factor * m_camera.ZoomGet();
const float arrow_moving_time_speed = 8.0f; const float arrow_moving_time_speed = 8.0f;
bool handled = false; bool handled = false;
@ -810,126 +812,124 @@ bool EDA_3D_CANVAS::SetView3D( int aKeycode )
return true; return true;
case WXK_LEFT: case WXK_LEFT:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().Pan_T1( SFVEC3F( -delta_move, 0.0f, 0.0f ) ); m_camera.Pan_T1( SFVEC3F( -delta_move, 0.0f, 0.0f ) );
request_start_moving_camera( arrow_moving_time_speed, false ); request_start_moving_camera( arrow_moving_time_speed, false );
return true; return true;
case WXK_RIGHT: case WXK_RIGHT:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().Pan_T1( SFVEC3F( +delta_move, 0.0f, 0.0f ) ); m_camera.Pan_T1( SFVEC3F( +delta_move, 0.0f, 0.0f ) );
request_start_moving_camera( arrow_moving_time_speed, false ); request_start_moving_camera( arrow_moving_time_speed, false );
return true; return true;
case WXK_UP: case WXK_UP:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().Pan_T1( SFVEC3F( 0.0f, +delta_move, 0.0f ) ); m_camera.Pan_T1( SFVEC3F( 0.0f, +delta_move, 0.0f ) );
request_start_moving_camera( arrow_moving_time_speed, false ); request_start_moving_camera( arrow_moving_time_speed, false );
return true; return true;
case WXK_DOWN: case WXK_DOWN:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::LINEAR );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().Pan_T1( SFVEC3F( 0.0f, -delta_move, 0.0f ) ); m_camera.Pan_T1( SFVEC3F( 0.0f, -delta_move, 0.0f ) );
request_start_moving_camera( arrow_moving_time_speed, false ); request_start_moving_camera( arrow_moving_time_speed, false );
return true; return true;
case WXK_HOME: case WXK_HOME:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().Reset_T1(); m_camera.Reset_T1();
request_start_moving_camera( glm::min( glm::max( m_settings.CameraGet().ZoomGet(), 1/1.26f ), 1.26f ) ); request_start_moving_camera( glm::min( glm::max( m_camera.ZoomGet(), 1/1.26f ), 1.26f ) );
return true; return true;
case WXK_END: case WXK_END:
break; break;
case WXK_TAB: case WXK_TAB:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::EASING_IN_OUT ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::EASING_IN_OUT );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().RotateZ_T1( glm::radians( 45.0f ) ); m_camera.RotateZ_T1( glm::radians( 45.0f ) );
request_start_moving_camera(); request_start_moving_camera();
handled = true; handled = true;
break; break;
case WXK_F1: case WXK_F1:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
if( m_settings.CameraGet().Zoom_T1( 1.26f ) ) // 3 steps per doubling if( m_camera.Zoom_T1( 1.26f ) ) // 3 steps per doubling
request_start_moving_camera( 3.0f ); request_start_moving_camera( 3.0f );
return true; return true;
case WXK_F2: case WXK_F2:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
if( m_settings.CameraGet().Zoom_T1( 1/1.26f ) ) // 3 steps per halving if( m_camera.Zoom_T1( 1/1.26f ) ) // 3 steps per halving
request_start_moving_camera( 3.0f ); request_start_moving_camera( 3.0f );
return true; return true;
case ID_VIEW3D_RESET: case ID_VIEW3D_RESET:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().Reset_T1(); m_camera.Reset_T1();
request_start_moving_camera( glm::min( glm::max( m_settings.CameraGet().ZoomGet(), 0.5f ), 1.125f ) ); request_start_moving_camera( glm::min( glm::max( m_camera.ZoomGet(), 0.5f ), 1.125f ) );
return true; return true;
case ID_VIEW3D_RIGHT: case ID_VIEW3D_RIGHT:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().Reset_T1(); m_camera.Reset_T1();
m_settings.CameraGet().RotateZ_T1( glm::radians( -90.0f ) ); m_camera.RotateZ_T1( glm::radians( -90.0f ) );
m_settings.CameraGet().RotateX_T1( glm::radians( -90.0f ) ); m_camera.RotateX_T1( glm::radians( -90.0f ) );
request_start_moving_camera(); request_start_moving_camera();
return true; return true;
case ID_VIEW3D_LEFT: case ID_VIEW3D_LEFT:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().Reset_T1(); m_camera.Reset_T1();
m_settings.CameraGet().RotateZ_T1( glm::radians( 90.0f ) ); m_camera.RotateZ_T1( glm::radians( 90.0f ) );
m_settings.CameraGet().RotateX_T1( glm::radians( -90.0f ) ); m_camera.RotateX_T1( glm::radians( -90.0f ) );
request_start_moving_camera(); request_start_moving_camera();
return true; return true;
case ID_VIEW3D_FRONT: case ID_VIEW3D_FRONT:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().Reset_T1(); m_camera.Reset_T1();
m_settings.CameraGet().RotateX_T1( glm::radians( -90.0f ) ); m_camera.RotateX_T1( glm::radians( -90.0f ) );
request_start_moving_camera(); request_start_moving_camera();
return true; return true;
case ID_VIEW3D_BACK: case ID_VIEW3D_BACK:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().Reset_T1(); m_camera.Reset_T1();
m_settings.CameraGet().RotateX_T1( glm::radians( -90.0f ) ); m_camera.RotateX_T1( glm::radians( -90.0f ) );
m_settings.CameraGet().RotateZ_T1( glm::radians( -180.0f ) ); m_camera.RotateZ_T1( glm::radians( -180.0f ) );
request_start_moving_camera(); request_start_moving_camera();
return true; return true;
case ID_VIEW3D_TOP: case ID_VIEW3D_TOP:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().Reset_T1(); m_camera.Reset_T1();
request_start_moving_camera( request_start_moving_camera( glm::min( glm::max( m_camera.ZoomGet(), 0.5f ), 1.125f ) );
glm::min( glm::max( m_settings.CameraGet().ZoomGet(), 0.5f ), 1.125f ) );
return true; return true;
case ID_VIEW3D_BOTTOM: case ID_VIEW3D_BOTTOM:
m_settings.CameraGet().SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER ); m_camera.SetInterpolateMode( CAMERA_INTERPOLATION::BEZIER );
m_settings.CameraGet().SetT0_and_T1_current_T(); m_camera.SetT0_and_T1_current_T();
m_settings.CameraGet().Reset_T1(); m_camera.Reset_T1();
m_settings.CameraGet().RotateY_T1( glm::radians( 180.0f ) ); m_camera.RotateY_T1( glm::radians( 180.0f ) );
request_start_moving_camera( request_start_moving_camera( glm::min( glm::max( m_camera.ZoomGet(), 0.5f ), 1.125f ) );
glm::min( glm::max( m_settings.CameraGet().ZoomGet(), 0.5f ), 1.125f ) );
return true; return true;
default: default:
@ -949,7 +949,7 @@ bool EDA_3D_CANVAS::SetView3D( int aKeycode )
void EDA_3D_CANVAS::RenderEngineChanged() void EDA_3D_CANVAS::RenderEngineChanged()
{ {
switch( m_settings.RenderEngineGet() ) switch( m_boardAdapter.RenderEngineGet() )
{ {
case RENDER_ENGINE::OPENGL_LEGACY: m_3d_render = m_3d_render_ogl_legacy; break; case RENDER_ENGINE::OPENGL_LEGACY: m_3d_render = m_3d_render_ogl_legacy; break;
case RENDER_ENGINE::RAYTRACING: m_3d_render = m_3d_render_raytracing; break; case RENDER_ENGINE::RAYTRACING: m_3d_render = m_3d_render_raytracing; break;

13
3d-viewer/3d_canvas/eda_3d_canvas.h
View File

@ -26,7 +26,7 @@
#define EDA_3D_CANVAS_H #define EDA_3D_CANVAS_H
#include "3d_settings.h" #include "board_adapter.h"
#include "3d_rendering/c3d_render_base.h" #include "3d_rendering/c3d_render_base.h"
#include "3d_cache/3d_cache.h" #include "3d_cache/3d_cache.h"
#include <gal/hidpi_gl_canvas.h> #include <gal/hidpi_gl_canvas.h>
@ -53,11 +53,8 @@ class EDA_3D_CANVAS : public HIDPI_GL_CANVAS
* @param aBoard: The board * @param aBoard: The board
* @param aSettings: the settings options to be used by this canvas * @param aSettings: the settings options to be used by this canvas
*/ */
EDA_3D_CANVAS( wxWindow *aParent, EDA_3D_CANVAS( wxWindow* aParent, const int* aAttribList, BOARD* aBoard,
const int *aAttribList = 0, BOARD_ADAPTER& aSettings, CCAMERA& aCamera, S3D_CACHE* a3DCachePointer );
BOARD *aBoard = NULL,
EDA_3D_SETTINGS &aSettings = G_null_EDA_3D_SETTINGS,
S3D_CACHE *a3DCachePointer = NULL );
~EDA_3D_CANVAS(); ~EDA_3D_CANVAS();
@ -212,8 +209,8 @@ private:
float m_camera_moving_speed; // 1.0f will be 1:1 float m_camera_moving_speed; // 1.0f will be 1:1
unsigned m_strtime_camera_movement; // Ticktime of camera movement start unsigned m_strtime_camera_movement; // Ticktime of camera movement start
EDA_3D_SETTINGS& m_settings; // Pre-computed 3D information and visual BOARD_ADAPTER& m_boardAdapter; // Pre-computed 3D info and settings
// settings to render the board CCAMERA& m_camera;
C3D_RENDER_BASE* m_3d_render; C3D_RENDER_BASE* m_3d_render;
C3D_RENDER_RAYTRACING* m_3d_render_raytracing; C3D_RENDER_RAYTRACING* m_3d_render_raytracing;
C3D_RENDER_OGL_LEGACY* m_3d_render_ogl_legacy; C3D_RENDER_OGL_LEGACY* m_3d_render_ogl_legacy;

6
3d-viewer/3d_canvas/eda_3d_canvas_pivot.cpp
View File

@ -81,7 +81,7 @@ void EDA_3D_CANVAS::render_pivot( float t , float aScale )
if( t > 1.0f ) if( t > 1.0f )
t = 1.0f; t = 1.0f;
const SFVEC3F &lookAtPos = m_settings.CameraGet().GetLookAtPos_T1(); const SFVEC3F &lookAtPos = m_camera.GetLookAtPos_T1();
glDisable( GL_LIGHTING ); glDisable( GL_LIGHTING );
glDisable( GL_DEPTH_TEST ); glDisable( GL_DEPTH_TEST );
@ -90,11 +90,11 @@ void EDA_3D_CANVAS::render_pivot( float t , float aScale )
// Set projection and modelview matrixes // Set projection and modelview matrixes
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
glMatrixMode( GL_PROJECTION ); glMatrixMode( GL_PROJECTION );
glLoadMatrixf( glm::value_ptr( m_settings.CameraGet().GetProjectionMatrix() ) ); glLoadMatrixf( glm::value_ptr( m_camera.GetProjectionMatrix() ) );
glMatrixMode( GL_MODELVIEW ); glMatrixMode( GL_MODELVIEW );
glLoadIdentity(); glLoadIdentity();
glLoadMatrixf( glm::value_ptr( m_settings.CameraGet().GetViewMatrix() ) ); glLoadMatrixf( glm::value_ptr( m_camera.GetViewMatrix() ) );
glEnable( GL_COLOR_MATERIAL ); glEnable( GL_COLOR_MATERIAL );
glColor4f( 0.0f, 1.0f, 0.0f, 0.75f - t * 0.75f ); glColor4f( 0.0f, 1.0f, 0.0f, 0.75f - t * 0.75f );

110
3d-viewer/3d_rendering/3d_render_ogl_legacy/c3d_render_createscene_ogl_legacy.cpp
View File

@ -141,7 +141,7 @@ void C3D_RENDER_OGL_LEGACY::add_object_to_triangle_layer( const CRING2D * aRing,
generate_ring_contour( center, generate_ring_contour( center,
inner, inner,
outer, outer,
m_settings.GetNrSegmentsCircle( outer * 2.0f ), m_boardAdapter.GetNrSegmentsCircle( outer * 2.0f ),
innerContour, innerContour,
outerContour, outerContour,
false ); false );
@ -318,7 +318,7 @@ CLAYERS_OGL_DISP_LISTS *C3D_RENDER_OGL_LEGACY::generate_holes_display_list(
layerTriangles->AddToMiddleContourns( aPoly, layerTriangles->AddToMiddleContourns( aPoly,
aZbot, aZbot,
aZtop, aZtop,
m_settings.BiuTo3Dunits(), m_boardAdapter.BiuTo3Dunits(),
aInvertFaces ); aInvertFaces );
} }
@ -348,14 +348,14 @@ void C3D_RENDER_OGL_LEGACY::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
unsigned stats_startReloadTime = GetRunningMicroSecs(); unsigned stats_startReloadTime = GetRunningMicroSecs();
m_settings.InitSettings( aStatusTextReporter, aWarningTextReporter ); m_boardAdapter.InitSettings( aStatusTextReporter, aWarningTextReporter );
#ifdef PRINT_STATISTICS_3D_VIEWER #ifdef PRINT_STATISTICS_3D_VIEWER
unsigned stats_endReloadTime = GetRunningMicroSecs(); unsigned stats_endReloadTime = GetRunningMicroSecs();
#endif #endif
SFVEC3F camera_pos = m_settings.GetBoardCenter3DU(); SFVEC3F camera_pos = m_boardAdapter.GetBoardCenter3DU();
m_settings.CameraGet().SetBoardLookAtPos( camera_pos ); m_camera.SetBoardLookAtPos( camera_pos );
#ifdef PRINT_STATISTICS_3D_VIEWER #ifdef PRINT_STATISTICS_3D_VIEWER
unsigned stats_start_OpenGL_Load_Time = GetRunningMicroSecs(); unsigned stats_start_OpenGL_Load_Time = GetRunningMicroSecs();
@ -368,11 +368,11 @@ void C3D_RENDER_OGL_LEGACY::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
CCONTAINER2D boardContainer; CCONTAINER2D boardContainer;
SHAPE_POLY_SET tmpBoard = m_settings.GetBoardPoly(); SHAPE_POLY_SET tmpBoard = m_boardAdapter.GetBoardPoly();
Convert_shape_line_polygon_to_triangles( tmpBoard, Convert_shape_line_polygon_to_triangles( tmpBoard,
boardContainer, boardContainer,
m_settings.BiuTo3Dunits(), m_boardAdapter.BiuTo3Dunits(),
(const BOARD_ITEM &)*m_settings.GetBoard() ); (const BOARD_ITEM &)*m_boardAdapter.GetBoard() );
const LIST_OBJECT2D &listBoardObject2d = boardContainer.GetList(); const LIST_OBJECT2D &listBoardObject2d = boardContainer.GetList();
@ -409,7 +409,7 @@ void C3D_RENDER_OGL_LEGACY::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
layer_z_bot ); layer_z_bot );
} }
const SHAPE_POLY_SET &boardPoly = m_settings.GetBoardPoly(); const SHAPE_POLY_SET &boardPoly = m_boardAdapter.GetBoardPoly();
wxASSERT( boardPoly.OutlineCount() > 0 ); wxASSERT( boardPoly.OutlineCount() > 0 );
@ -418,7 +418,7 @@ void C3D_RENDER_OGL_LEGACY::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
layerTriangles->AddToMiddleContourns( boardPoly, layerTriangles->AddToMiddleContourns( boardPoly,
layer_z_bot, layer_z_bot,
layer_z_top, layer_z_top,
m_settings.BiuTo3Dunits(), m_boardAdapter.BiuTo3Dunits(),
false ); false );
m_ogl_disp_list_board = new CLAYERS_OGL_DISP_LISTS( *layerTriangles, m_ogl_disp_list_board = new CLAYERS_OGL_DISP_LISTS( *layerTriangles,
@ -437,52 +437,52 @@ void C3D_RENDER_OGL_LEGACY::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
aStatusTextReporter->Report( _( "Load OpenGL: holes and vias" ) ); aStatusTextReporter->Report( _( "Load OpenGL: holes and vias" ) );
m_ogl_disp_list_through_holes_outer = generate_holes_display_list( m_ogl_disp_list_through_holes_outer = generate_holes_display_list(
m_settings.GetThroughHole_Outer().GetList(), m_boardAdapter.GetThroughHole_Outer().GetList(),
m_settings.GetThroughHole_Outer_poly(), m_boardAdapter.GetThroughHole_Outer_poly(),
1.0f, 1.0f,
0.0f, 0.0f,
false ); false );
SHAPE_POLY_SET bodyHoles = m_settings.GetThroughHole_Outer_poly(); SHAPE_POLY_SET bodyHoles = m_boardAdapter.GetThroughHole_Outer_poly();
bodyHoles.BooleanAdd( m_settings.GetThroughHole_Outer_poly_NPTH(), bodyHoles.BooleanAdd( m_boardAdapter.GetThroughHole_Outer_poly_NPTH(),
SHAPE_POLY_SET::PM_FAST ); SHAPE_POLY_SET::PM_FAST );
m_ogl_disp_list_through_holes_outer_with_npth = generate_holes_display_list( m_ogl_disp_list_through_holes_outer_with_npth = generate_holes_display_list(
m_settings.GetThroughHole_Outer().GetList(), m_boardAdapter.GetThroughHole_Outer().GetList(),
bodyHoles, bodyHoles,
1.0f, 1.0f,
0.0f, 0.0f,
false ); false );
m_ogl_disp_list_through_holes_inner = generate_holes_display_list( m_ogl_disp_list_through_holes_inner = generate_holes_display_list(
m_settings.GetThroughHole_Inner().GetList(), m_boardAdapter.GetThroughHole_Inner().GetList(),
m_settings.GetThroughHole_Inner_poly(), m_boardAdapter.GetThroughHole_Inner_poly(),
1.0f, 1.0f,
0.0f, 0.0f,
true ); true );
m_ogl_disp_list_through_holes_vias_outer = generate_holes_display_list( m_ogl_disp_list_through_holes_vias_outer = generate_holes_display_list(
m_settings.GetThroughHole_Vias_Outer().GetList(), m_boardAdapter.GetThroughHole_Vias_Outer().GetList(),
m_settings.GetThroughHole_Vias_Outer_poly(), m_boardAdapter.GetThroughHole_Vias_Outer_poly(),
1.0f, 1.0f,
0.0f, 0.0f,
false ); false );
// Not in use // Not in use
//m_ogl_disp_list_through_holes_vias_inner = generate_holes_display_list( //m_ogl_disp_list_through_holes_vias_inner = generate_holes_display_list(
// m_settings.GetThroughHole_Vias_Inner().GetList(), // m_boardAdapter.GetThroughHole_Vias_Inner().GetList(),
// m_settings.GetThroughHole_Vias_Inner_poly(), // m_boardAdapter.GetThroughHole_Vias_Inner_poly(),
// 1.0f, 0.0f, // 1.0f, 0.0f,
// false ); // false );
const MAP_POLY & innerMapHoles = m_settings.GetPolyMapHoles_Inner(); const MAP_POLY & innerMapHoles = m_boardAdapter.GetPolyMapHoles_Inner();
const MAP_POLY & outerMapHoles = m_settings.GetPolyMapHoles_Outer(); const MAP_POLY & outerMapHoles = m_boardAdapter.GetPolyMapHoles_Outer();
wxASSERT( innerMapHoles.size() == outerMapHoles.size() ); wxASSERT( innerMapHoles.size() == outerMapHoles.size() );
const MAP_CONTAINER_2D &map_holes = m_settings.GetMapLayersHoles(); const MAP_CONTAINER_2D &map_holes = m_boardAdapter.GetMapLayersHoles();
if( outerMapHoles.size() > 0 ) if( outerMapHoles.size() > 0 )
{ {
@ -526,13 +526,13 @@ void C3D_RENDER_OGL_LEGACY::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
if( aStatusTextReporter ) if( aStatusTextReporter )
aStatusTextReporter->Report( _( "Load OpenGL: layers" ) ); aStatusTextReporter->Report( _( "Load OpenGL: layers" ) );
for( MAP_CONTAINER_2D::const_iterator ii = m_settings.GetMapLayers().begin(); for( MAP_CONTAINER_2D::const_iterator ii = m_boardAdapter.GetMapLayers().begin();
ii != m_settings.GetMapLayers().end(); ii != m_boardAdapter.GetMapLayers().end();
++ii ) ++ii )
{ {
PCB_LAYER_ID layer_id = static_cast<PCB_LAYER_ID>(ii->first); PCB_LAYER_ID layer_id = static_cast<PCB_LAYER_ID>(ii->first);
if( !m_settings.Is3DLayerEnabled( layer_id ) ) if( !m_boardAdapter.Is3DLayerEnabled( layer_id ) )
continue; continue;
const CBVHCONTAINER2D *container2d = static_cast<const CBVHCONTAINER2D *>(ii->second); const CBVHCONTAINER2D *container2d = static_cast<const CBVHCONTAINER2D *>(ii->second);
@ -593,7 +593,7 @@ void C3D_RENDER_OGL_LEGACY::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
} }
} }
const MAP_POLY &map_poly = m_settings.GetPolyMap(); const MAP_POLY &map_poly = m_boardAdapter.GetPolyMap();
// Load the vertical (Z axis) component of shapes // Load the vertical (Z axis) component of shapes
if( map_poly.find( layer_id ) != map_poly.end() ) if( map_poly.find( layer_id ) != map_poly.end() )
@ -602,7 +602,7 @@ void C3D_RENDER_OGL_LEGACY::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
if( polyList->OutlineCount() > 0 ) if( polyList->OutlineCount() > 0 )
layerTriangles->AddToMiddleContourns( *polyList, layer_z_bot, layer_z_top, layerTriangles->AddToMiddleContourns( *polyList, layer_z_bot, layer_z_top,
m_settings.BiuTo3Dunits(), false ); m_boardAdapter.BiuTo3Dunits(), false );
} }
// Create display list // Create display list
@ -675,8 +675,8 @@ void C3D_RENDER_OGL_LEGACY::get_layer_z_pos ( PCB_LAYER_ID aLayerID,
float &aOutZtop, float &aOutZtop,
float &aOutZbot ) const float &aOutZbot ) const
{ {
aOutZbot = m_settings.GetLayerBottomZpos3DU( aLayerID ); aOutZbot = m_boardAdapter.GetLayerBottomZpos3DU( aLayerID );
aOutZtop = m_settings.GetLayerTopZpos3DU( aLayerID ); aOutZtop = m_boardAdapter.GetLayerTopZpos3DU( aLayerID );
if( aOutZtop < aOutZbot ) if( aOutZtop < aOutZbot )
{ {
@ -731,12 +731,12 @@ void C3D_RENDER_OGL_LEGACY::generate_cylinder( const SFVEC2F &aCenter,
void C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads() void C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads()
{ {
if( m_settings.GetStats_Nr_Vias() ) if( m_boardAdapter.GetStats_Nr_Vias() )
{ {
const unsigned int reserve_nr_triangles_estimation = const unsigned int reserve_nr_triangles_estimation =
m_settings.GetNrSegmentsCircle( m_settings.GetStats_Med_Via_Hole_Diameter3DU() ) * m_boardAdapter.GetNrSegmentsCircle( m_boardAdapter.GetStats_Med_Via_Hole_Diameter3DU() ) *
8 * 8 *
m_settings.GetStats_Nr_Vias(); m_boardAdapter.GetStats_Nr_Vias();
CLAYER_TRIANGLES *layerTriangleVIA = new CLAYER_TRIANGLES( reserve_nr_triangles_estimation ); CLAYER_TRIANGLES *layerTriangleVIA = new CLAYER_TRIANGLES( reserve_nr_triangles_estimation );
@ -744,20 +744,20 @@ void C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads()
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
// Insert vias holes (vertical cylinders) // Insert vias holes (vertical cylinders)
for( auto track : m_settings.GetBoard()->Tracks() ) for( auto track : m_boardAdapter.GetBoard()->Tracks() )
{ {
if( track->Type() == PCB_VIA_T ) if( track->Type() == PCB_VIA_T )
{ {
const VIA *via = static_cast<const VIA*>(track); const VIA *via = static_cast<const VIA*>(track);
const float holediameter = via->GetDrillValue() * m_settings.BiuTo3Dunits(); const float holediameter = via->GetDrillValue() * m_boardAdapter.BiuTo3Dunits();
const float thickness = m_settings.GetCopperThickness3DU(); const float thickness = m_boardAdapter.GetCopperThickness3DU();
const int nrSegments = m_settings.GetNrSegmentsCircle( via->GetDrillValue() ); const int nrSegments = m_boardAdapter.GetNrSegmentsCircle( via->GetDrillValue() );
const double correctionFactor = m_settings.GetCircleCorrectionFactor( nrSegments ); const double correctionFactor = m_boardAdapter.GetCircleCorrectionFactor( nrSegments );
const float hole_inner_radius = ( holediameter / 2.0f ) * correctionFactor; const float hole_inner_radius = ( holediameter / 2.0f ) * correctionFactor;
const SFVEC2F via_center( via->GetStart().x * m_settings.BiuTo3Dunits(), const SFVEC2F via_center( via->GetStart().x * m_boardAdapter.BiuTo3Dunits(),
-via->GetStart().y * m_settings.BiuTo3Dunits() ); -via->GetStart().y * m_boardAdapter.BiuTo3Dunits() );
PCB_LAYER_ID top_layer, bottom_layer; PCB_LAYER_ID top_layer, bottom_layer;
via->LayerPair( &top_layer, &bottom_layer ); via->LayerPair( &top_layer, &bottom_layer );
@ -788,7 +788,7 @@ void C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads()
} }
if( m_settings.GetStats_Nr_Holes() > 0 ) if( m_boardAdapter.GetStats_Nr_Holes() > 0 )
{ {
SHAPE_POLY_SET tht_outer_holes_poly; // Stores the outer poly of the copper holes (the pad) SHAPE_POLY_SET tht_outer_holes_poly; // Stores the outer poly of the copper holes (the pad)
SHAPE_POLY_SET tht_inner_holes_poly; // Stores the inner poly of the copper holes (the hole) SHAPE_POLY_SET tht_inner_holes_poly; // Stores the inner poly of the copper holes (the hole)
@ -797,7 +797,7 @@ void C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads()
tht_inner_holes_poly.RemoveAllContours(); tht_inner_holes_poly.RemoveAllContours();
// Insert pads holes (vertical cylinders) // Insert pads holes (vertical cylinders)
for( const auto module : m_settings.GetBoard()->Modules() ) for( const auto module : m_boardAdapter.GetBoard()->Modules() )
{ {
for( auto pad : module->Pads() ) for( auto pad : module->Pads() )
{ {
@ -812,10 +812,10 @@ void C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads()
// we use the hole diameter to calculate the seg count. // we use the hole diameter to calculate the seg count.
// for round holes, drillsize.x == drillsize.y // for round holes, drillsize.x == drillsize.y
// for slots, the diameter is the smaller of (drillsize.x, drillsize.y) // for slots, the diameter is the smaller of (drillsize.x, drillsize.y)
int copperThickness = m_settings.GetCopperThicknessBIU(); int copperThickness = m_boardAdapter.GetCopperThicknessBIU();
int radius = std::min( drillsize.x, drillsize.y ) / 2 + copperThickness; int radius = std::min( drillsize.x, drillsize.y ) / 2 + copperThickness;
int nrSegments = m_settings.GetNrSegmentsCircle( radius * 2 ); int nrSegments = m_boardAdapter.GetNrSegmentsCircle( radius * 2 );
double correctionFactor = m_settings.GetCircleCorrectionFactor( nrSegments ); double correctionFactor = m_boardAdapter.GetCircleCorrectionFactor( nrSegments );
int correction = radius * ( correctionFactor - 1 ); int correction = radius * ( correctionFactor - 1 );
pad->BuildPadDrillShapePolygon( pad->BuildPadDrillShapePolygon(
@ -834,8 +834,8 @@ void C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads()
Convert_shape_line_polygon_to_triangles( tht_outer_holes_poly, Convert_shape_line_polygon_to_triangles( tht_outer_holes_poly,
holesContainer, holesContainer,
m_settings.BiuTo3Dunits(), m_boardAdapter.BiuTo3Dunits(),
(const BOARD_ITEM &)*m_settings.GetBoard() ); (const BOARD_ITEM &)*m_boardAdapter.GetBoard() );
const LIST_OBJECT2D &listHolesObject2d = holesContainer.GetList(); const LIST_OBJECT2D &listHolesObject2d = holesContainer.GetList();
@ -873,7 +873,7 @@ void C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads()
{ {
layerTriangles->AddToMiddleContourns( tht_outer_holes_poly, layerTriangles->AddToMiddleContourns( tht_outer_holes_poly,
layer_z_bot, layer_z_top, layer_z_bot, layer_z_top,
m_settings.BiuTo3Dunits(), m_boardAdapter.BiuTo3Dunits(),
false ); false );
m_ogl_disp_list_pads_holes = new CLAYERS_OGL_DISP_LISTS( m_ogl_disp_list_pads_holes = new CLAYERS_OGL_DISP_LISTS(
@ -896,13 +896,13 @@ void C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads()
*/ */
void C3D_RENDER_OGL_LEGACY::load_3D_models( REPORTER *aStatusTextReporter ) void C3D_RENDER_OGL_LEGACY::load_3D_models( REPORTER *aStatusTextReporter )
{ {
if( (!m_settings.GetFlag( FL_MODULE_ATTRIBUTES_NORMAL )) && if((!m_boardAdapter.GetFlag( FL_MODULE_ATTRIBUTES_NORMAL )) &&
(!m_settings.GetFlag( FL_MODULE_ATTRIBUTES_NORMAL_INSERT )) && (!m_boardAdapter.GetFlag( FL_MODULE_ATTRIBUTES_NORMAL_INSERT )) &&
(!m_settings.GetFlag( FL_MODULE_ATTRIBUTES_VIRTUAL )) ) (!m_boardAdapter.GetFlag( FL_MODULE_ATTRIBUTES_VIRTUAL )) )
return; return;
// Go for all modules // Go for all modules
for( auto module : m_settings.GetBoard()->Modules() ) for( auto module : m_boardAdapter.GetBoard()->Modules() )
{ {
if( !module->Models().empty() ) if( !module->Models().empty() )
{ {
@ -930,14 +930,14 @@ void C3D_RENDER_OGL_LEGACY::load_3D_models( REPORTER *aStatusTextReporter )
{ {
// It is not present, try get it from cache // It is not present, try get it from cache
const S3DMODEL *modelPtr = const S3DMODEL *modelPtr =
m_settings.Get3DCacheManager()->GetModel( sM->m_Filename ); m_boardAdapter.Get3DCacheManager()->GetModel( sM->m_Filename );
// only add it if the return is not NULL // only add it if the return is not NULL
if( modelPtr ) if( modelPtr )
{ {
C_OGL_3DMODEL* ogl_model = C_OGL_3DMODEL* ogl_model =
new C_OGL_3DMODEL( *modelPtr, new C_OGL_3DMODEL( *modelPtr,
m_settings.MaterialModeGet() ); m_boardAdapter.MaterialModeGet() );
if( ogl_model ) if( ogl_model )
m_3dmodel_map[ sM->m_Filename ] = ogl_model; m_3dmodel_map[ sM->m_Filename ] = ogl_model;

198
3d-viewer/3d_rendering/3d_render_ogl_legacy/c3d_render_ogl_legacy.cpp
View File

@ -44,8 +44,8 @@
*/ */
#define UNITS3D_TO_UNITSPCB (IU_PER_MM) #define UNITS3D_TO_UNITSPCB (IU_PER_MM)
C3D_RENDER_OGL_LEGACY::C3D_RENDER_OGL_LEGACY( EDA_3D_SETTINGS &aSettings ) : C3D_RENDER_OGL_LEGACY::C3D_RENDER_OGL_LEGACY( BOARD_ADAPTER& aAdapter, CCAMERA& aCamera ) :
C3D_RENDER_BASE( aSettings ) C3D_RENDER_BASE( aAdapter, aCamera )
{ {
wxLogTrace( m_logTrace, wxT( "C3D_RENDER_OGL_LEGACY::C3D_RENDER_OGL_LEGACY" ) ); wxLogTrace( m_logTrace, wxT( "C3D_RENDER_OGL_LEGACY::C3D_RENDER_OGL_LEGACY" ) );
@ -148,8 +148,7 @@ void C3D_RENDER_OGL_LEGACY::render_3D_arrows()
glm::mat4(1.0f), glm::mat4(1.0f),
SFVEC3F( 0.0f, 0.0f, -(arrow_size * 2.75f) ) ); SFVEC3F( 0.0f, 0.0f, -(arrow_size * 2.75f) ) );
const glm::mat4 ViewMatrix = TranslationMatrix * const glm::mat4 ViewMatrix = TranslationMatrix * m_camera.GetRotationMatrix();
m_settings.CameraGet().GetRotationMatrix();
glLoadMatrixf( glm::value_ptr( ViewMatrix ) ); glLoadMatrixf( glm::value_ptr( ViewMatrix ) );
@ -178,23 +177,23 @@ void C3D_RENDER_OGL_LEGACY::setupMaterials()
{ {
m_materials = {}; m_materials = {};
if( m_settings.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
{ {
// http://devernay.free.fr/cours/opengl/materials.html // http://devernay.free.fr/cours/opengl/materials.html
// Copper material mixed with the copper color // Copper material mixed with the copper color
m_materials.m_Copper.m_Ambient = SFVEC3F( m_settings.m_CopperColor.r * 0.1f, m_materials.m_Copper.m_Ambient = SFVEC3F( m_boardAdapter.m_CopperColor.r * 0.1f,
m_settings.m_CopperColor.g * 0.1f, m_boardAdapter.m_CopperColor.g * 0.1f,
m_settings.m_CopperColor.b * 0.1f); m_boardAdapter.m_CopperColor.b * 0.1f);
m_materials.m_Copper.m_Specular = SFVEC3F( m_settings.m_CopperColor.r * 0.75f + 0.25f, m_materials.m_Copper.m_Specular = SFVEC3F( m_boardAdapter.m_CopperColor.r * 0.75f + 0.25f,
m_settings.m_CopperColor.g * 0.75f + 0.25f, m_boardAdapter.m_CopperColor.g * 0.75f + 0.25f,
m_settings.m_CopperColor.b * 0.75f + 0.25f ); m_boardAdapter.m_CopperColor.b * 0.75f + 0.25f );
// This guess the material type(ex: copper vs gold) to determine the // This guess the material type(ex: copper vs gold) to determine the
// shininess factor between 0.1 and 0.4 // shininess factor between 0.1 and 0.4
float shininessfactor = 0.40f - mapf( fabs( m_settings.m_CopperColor.r - float shininessfactor = 0.40f - mapf( fabs( m_boardAdapter.m_CopperColor.r -
m_settings.m_CopperColor.g ), m_boardAdapter.m_CopperColor.g ),
0.15f, 1.00f, 0.15f, 1.00f,
0.00f, 0.30f ); 0.00f, 0.30f );
@ -203,69 +202,73 @@ void C3D_RENDER_OGL_LEGACY::setupMaterials()
// Paste material mixed with paste color // Paste material mixed with paste color
m_materials.m_Paste.m_Ambient = SFVEC3F( m_settings.m_SolderPasteColor.r, m_materials.m_Paste.m_Ambient = SFVEC3F( m_boardAdapter.m_SolderPasteColor.r,
m_settings.m_SolderPasteColor.g, m_boardAdapter.m_SolderPasteColor.g,
m_settings.m_SolderPasteColor.b ); m_boardAdapter.m_SolderPasteColor.b );
m_materials.m_Paste.m_Specular = SFVEC3F( m_settings.m_SolderPasteColor.r * m_materials.m_Paste.m_Specular = SFVEC3F( m_boardAdapter.m_SolderPasteColor.r *
m_settings.m_SolderPasteColor.r, m_boardAdapter.m_SolderPasteColor.r,
m_settings.m_SolderPasteColor.g * m_boardAdapter.m_SolderPasteColor.g *
m_settings.m_SolderPasteColor.g, m_boardAdapter.m_SolderPasteColor.g,
m_settings.m_SolderPasteColor.b * m_boardAdapter.m_SolderPasteColor.b *
m_settings.m_SolderPasteColor.b ); m_boardAdapter.m_SolderPasteColor.b );
m_materials.m_Paste.m_Shininess = 0.1f * 128.0f; m_materials.m_Paste.m_Shininess = 0.1f * 128.0f;
m_materials.m_Paste.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f ); m_materials.m_Paste.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
// Silk screen material mixed with silk screen color // Silk screen material mixed with silk screen color
m_materials.m_SilkSTop.m_Ambient = SFVEC3F( m_settings.m_SilkScreenColorTop.r, m_materials.m_SilkSTop.m_Ambient = SFVEC3F( m_boardAdapter.m_SilkScreenColorTop.r,
m_settings.m_SilkScreenColorTop.g, m_settings.m_SilkScreenColorTop.b ); m_boardAdapter.m_SilkScreenColorTop.g,
m_boardAdapter.m_SilkScreenColorTop.b );
m_materials.m_SilkSTop.m_Specular = SFVEC3F( m_materials.m_SilkSTop.m_Specular = SFVEC3F(
m_settings.m_SilkScreenColorTop.r * m_settings.m_SilkScreenColorTop.r + 0.10f, m_boardAdapter.m_SilkScreenColorTop.r * m_boardAdapter.m_SilkScreenColorTop.r + 0.10f,
m_settings.m_SilkScreenColorTop.g * m_settings.m_SilkScreenColorTop.g + 0.10f, m_boardAdapter.m_SilkScreenColorTop.g * m_boardAdapter.m_SilkScreenColorTop.g + 0.10f,
m_settings.m_SilkScreenColorTop.b * m_settings.m_SilkScreenColorTop.b + 0.10f ); m_boardAdapter.m_SilkScreenColorTop.b * m_boardAdapter.m_SilkScreenColorTop.b + 0.10f );
m_materials.m_SilkSTop.m_Shininess = 0.078125f * 128.0f; m_materials.m_SilkSTop.m_Shininess = 0.078125f * 128.0f;
m_materials.m_SilkSTop.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f ); m_materials.m_SilkSTop.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
// Silk screen material mixed with silk screen color // Silk screen material mixed with silk screen color
m_materials.m_SilkSBot.m_Ambient = SFVEC3F( m_settings.m_SilkScreenColorBot.r, m_materials.m_SilkSBot.m_Ambient = SFVEC3F( m_boardAdapter.m_SilkScreenColorBot.r,
m_settings.m_SilkScreenColorBot.g, m_settings.m_SilkScreenColorBot.b ); m_boardAdapter.m_SilkScreenColorBot.g,
m_boardAdapter.m_SilkScreenColorBot.b );
m_materials.m_SilkSBot.m_Specular = SFVEC3F( m_materials.m_SilkSBot.m_Specular = SFVEC3F(
m_settings.m_SilkScreenColorBot.r * m_settings.m_SilkScreenColorBot.r + 0.10f, m_boardAdapter.m_SilkScreenColorBot.r * m_boardAdapter.m_SilkScreenColorBot.r + 0.10f,
m_settings.m_SilkScreenColorBot.g * m_settings.m_SilkScreenColorBot.g + 0.10f, m_boardAdapter.m_SilkScreenColorBot.g * m_boardAdapter.m_SilkScreenColorBot.g + 0.10f,
m_settings.m_SilkScreenColorBot.b * m_settings.m_SilkScreenColorBot.b + 0.10f ); m_boardAdapter.m_SilkScreenColorBot.b * m_boardAdapter.m_SilkScreenColorBot.b + 0.10f );
m_materials.m_SilkSBot.m_Shininess = 0.078125f * 128.0f; m_materials.m_SilkSBot.m_Shininess = 0.078125f * 128.0f;
m_materials.m_SilkSBot.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f ); m_materials.m_SilkSBot.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
// Solder mask material mixed with solder mask color // Solder mask material mixed with solder mask color
m_materials.m_SolderMaskTop.m_Ambient = SFVEC3F( m_settings.m_SolderMaskColorTop.r * 0.3f, m_materials.m_SolderMaskTop.m_Ambient = SFVEC3F(
m_settings.m_SolderMaskColorTop.g * 0.3f, m_boardAdapter.m_SolderMaskColorTop.r * 0.3f,
m_settings.m_SolderMaskColorTop.b * 0.3f ); m_boardAdapter.m_SolderMaskColorTop.g * 0.3f,
m_boardAdapter.m_SolderMaskColorTop.b * 0.3f );
m_materials.m_SolderMaskTop.m_Specular = m_materials.m_SolderMaskTop.m_Specular = SFVEC3F(
SFVEC3F( m_settings.m_SolderMaskColorTop.r * m_settings.m_SolderMaskColorTop.r, m_boardAdapter.m_SolderMaskColorTop.r * m_boardAdapter.m_SolderMaskColorTop.r,
m_settings.m_SolderMaskColorTop.g * m_settings.m_SolderMaskColorTop.g, m_boardAdapter.m_SolderMaskColorTop.g * m_boardAdapter.m_SolderMaskColorTop.g,
m_settings.m_SolderMaskColorTop.b * m_settings.m_SolderMaskColorTop.b ); m_boardAdapter.m_SolderMaskColorTop.b * m_boardAdapter.m_SolderMaskColorTop.b );
m_materials.m_SolderMaskTop.m_Shininess = 0.8f * 128.0f; m_materials.m_SolderMaskTop.m_Shininess = 0.8f * 128.0f;
m_materials.m_SolderMaskTop.m_Transparency = 0.17f; m_materials.m_SolderMaskTop.m_Transparency = 0.17f;
m_materials.m_SolderMaskTop.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f ); m_materials.m_SolderMaskTop.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
// Solder mask material mixed with solder mask color // Solder mask material mixed with solder mask color
m_materials.m_SolderMaskBot.m_Ambient = SFVEC3F( m_settings.m_SolderMaskColorBot.r * 0.3f, m_materials.m_SolderMaskBot.m_Ambient = SFVEC3F(
m_settings.m_SolderMaskColorBot.g * 0.3f, m_boardAdapter.m_SolderMaskColorBot.r * 0.3f,
m_settings.m_SolderMaskColorBot.b * 0.3f ); m_boardAdapter.m_SolderMaskColorBot.g * 0.3f,
m_boardAdapter.m_SolderMaskColorBot.b * 0.3f );
m_materials.m_SolderMaskBot.m_Specular = m_materials.m_SolderMaskBot.m_Specular = SFVEC3F(
SFVEC3F( m_settings.m_SolderMaskColorBot.r * m_settings.m_SolderMaskColorBot.r, m_boardAdapter.m_SolderMaskColorBot.r * m_boardAdapter.m_SolderMaskColorBot.r,
m_settings.m_SolderMaskColorBot.g * m_settings.m_SolderMaskColorBot.g, m_boardAdapter.m_SolderMaskColorBot.g * m_boardAdapter.m_SolderMaskColorBot.g,
m_settings.m_SolderMaskColorBot.b * m_settings.m_SolderMaskColorBot.b ); m_boardAdapter.m_SolderMaskColorBot.b * m_boardAdapter.m_SolderMaskColorBot.b );
m_materials.m_SolderMaskBot.m_Shininess = 0.8f * 128.0f; m_materials.m_SolderMaskBot.m_Shininess = 0.8f * 128.0f;
m_materials.m_SolderMaskBot.m_Transparency = 0.17f; m_materials.m_SolderMaskBot.m_Transparency = 0.17f;
@ -277,7 +280,7 @@ void C3D_RENDER_OGL_LEGACY::setupMaterials()
97.0f / 255.0f, 97.0f / 255.0f,
47.0f / 255.0f ); 47.0f / 255.0f );
m_materials.m_EpoxyBoard.m_Diffuse = m_settings.m_BoardBodyColor; m_materials.m_EpoxyBoard.m_Diffuse = m_boardAdapter.m_BoardBodyColor;
m_materials.m_EpoxyBoard.m_Specular = SFVEC3F( 18.0f / 255.0f, m_materials.m_EpoxyBoard.m_Specular = SFVEC3F( 18.0f / 255.0f,
3.0f / 255.0f, 3.0f / 255.0f,
@ -332,7 +335,7 @@ void C3D_RENDER_OGL_LEGACY::setupMaterials()
// Epoxy material // Epoxy material
m_materials.m_EpoxyBoard.m_Ambient = matAmbientColor; m_materials.m_EpoxyBoard.m_Ambient = matAmbientColor;
m_materials.m_EpoxyBoard.m_Diffuse = m_settings.m_BoardBodyColor; m_materials.m_EpoxyBoard.m_Diffuse = m_boardAdapter.m_BoardBodyColor;
m_materials.m_EpoxyBoard.m_Specular = matSpecularColor; m_materials.m_EpoxyBoard.m_Specular = matSpecularColor;
m_materials.m_EpoxyBoard.m_Shininess = matShininess; m_materials.m_EpoxyBoard.m_Shininess = matShininess;
m_materials.m_EpoxyBoard.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f ); m_materials.m_EpoxyBoard.m_Emissive = SFVEC3F( 0.0f, 0.0f, 0.0f );
@ -415,9 +418,9 @@ void C3D_RENDER_OGL_LEGACY::set_layer_material( PCB_LAYER_ID aLayerID )
SFVEC3F C3D_RENDER_OGL_LEGACY::get_layer_color( PCB_LAYER_ID aLayerID ) SFVEC3F C3D_RENDER_OGL_LEGACY::get_layer_color( PCB_LAYER_ID aLayerID )
{ {
SFVEC3F layerColor = m_settings.GetLayerColor( aLayerID ); SFVEC3F layerColor = m_boardAdapter.GetLayerColor( aLayerID );
if( m_settings.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
{ {
switch( aLayerID ) switch( aLayerID )
{ {
@ -426,22 +429,22 @@ SFVEC3F C3D_RENDER_OGL_LEGACY::get_layer_color( PCB_LAYER_ID aLayerID )
break; break;
case B_Mask: case B_Mask:
layerColor = m_settings.m_SolderMaskColorBot; layerColor = m_boardAdapter.m_SolderMaskColorBot;
break; break;
case F_Mask: case F_Mask:
layerColor = m_settings.m_SolderMaskColorTop; layerColor = m_boardAdapter.m_SolderMaskColorTop;
break; break;
case B_Paste: case B_Paste:
case F_Paste: case F_Paste:
layerColor = m_settings.m_SolderPasteColor; layerColor = m_boardAdapter.m_SolderPasteColor;
break; break;
case B_SilkS: case B_SilkS:
layerColor = m_settings.m_SilkScreenColorBot; layerColor = m_boardAdapter.m_SilkScreenColorBot;
break; break;
case F_SilkS: case F_SilkS:
layerColor = m_settings.m_SilkScreenColorTop; layerColor = m_boardAdapter.m_SilkScreenColorTop;
break; break;
case Dwgs_User: case Dwgs_User:
@ -461,7 +464,7 @@ SFVEC3F C3D_RENDER_OGL_LEGACY::get_layer_color( PCB_LAYER_ID aLayerID )
break; break;
default: default:
layerColor = m_settings.m_CopperColor; layerColor = m_boardAdapter.m_CopperColor;
break; break;
} }
} }
@ -539,16 +542,16 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
setupMaterials(); setupMaterials();
// generate a new 3D grid as the size of the board may had changed // generate a new 3D grid as the size of the board may had changed
m_last_grid_type = m_settings.GridGet(); m_last_grid_type = m_boardAdapter.GridGet();
generate_new_3DGrid( m_last_grid_type ); generate_new_3DGrid( m_last_grid_type );
} }
else else
{ {
// Check if grid was changed // Check if grid was changed
if( m_settings.GridGet() != m_last_grid_type ) if( m_boardAdapter.GridGet() != m_last_grid_type )
{ {
// and generate a new one // and generate a new one
m_last_grid_type = m_settings.GridGet(); m_last_grid_type = m_boardAdapter.GridGet();
generate_new_3DGrid( m_last_grid_type ); generate_new_3DGrid( m_last_grid_type );
} }
} }
@ -573,8 +576,8 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
// Draw the background ( rectangle with color gradient) // Draw the background ( rectangle with color gradient)
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
OGL_DrawBackground( SFVEC3F( m_settings.m_BgColorTop ), OGL_DrawBackground( SFVEC3F( m_boardAdapter.m_BgColorTop ),
SFVEC3F( m_settings.m_BgColorBot ) ); SFVEC3F( m_boardAdapter.m_BgColorBot ) );
glEnable( GL_DEPTH_TEST ); glEnable( GL_DEPTH_TEST );
@ -582,11 +585,11 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
// Set projection and modelview matrixes // Set projection and modelview matrixes
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
glMatrixMode( GL_PROJECTION ); glMatrixMode( GL_PROJECTION );
glLoadMatrixf( glm::value_ptr( m_settings.CameraGet().GetProjectionMatrix() ) ); glLoadMatrixf( glm::value_ptr( m_camera.GetProjectionMatrix() ) );
glMatrixMode( GL_MODELVIEW ); glMatrixMode( GL_MODELVIEW );
glLoadIdentity(); glLoadIdentity();
glLoadMatrixf( glm::value_ptr( m_settings.CameraGet().GetViewMatrix() ) ); glLoadMatrixf( glm::value_ptr( m_camera.GetViewMatrix() ) );
// Position the headlight // Position the headlight
@ -599,7 +602,7 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
glEnable( GL_LIGHTING ); glEnable( GL_LIGHTING );
{ {
const SFVEC3F &cameraPos = m_settings.CameraGet().GetPos(); const SFVEC3F &cameraPos = m_camera.GetPos();
// Place the light at a minimun Z so the diffuse factor will not drop // Place the light at a minimun Z so the diffuse factor will not drop
// and the board will still look with good light. // and the board will still look with good light.
@ -625,12 +628,12 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
// Display board body // Display board body
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
if( m_settings.GetFlag( FL_SHOW_BOARD_BODY ) ) if( m_boardAdapter.GetFlag( FL_SHOW_BOARD_BODY ) )
{ {
if( m_ogl_disp_list_board ) if( m_ogl_disp_list_board )
{ {
m_ogl_disp_list_board->ApplyScalePosition( -m_settings.GetEpoxyThickness3DU() / 2.0f, m_ogl_disp_list_board->ApplyScalePosition( -m_boardAdapter.GetEpoxyThickness3DU() / 2.0f,
m_settings.GetEpoxyThickness3DU() ); m_boardAdapter.GetEpoxyThickness3DU() );
OGL_SetMaterial( m_materials.m_EpoxyBoard ); OGL_SetMaterial( m_materials.m_EpoxyBoard );
@ -639,8 +642,8 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
if( m_ogl_disp_list_through_holes_outer_with_npth ) if( m_ogl_disp_list_through_holes_outer_with_npth )
{ {
m_ogl_disp_list_through_holes_outer_with_npth->ApplyScalePosition( m_ogl_disp_list_through_holes_outer_with_npth->ApplyScalePosition(
-m_settings.GetEpoxyThickness3DU() / 2.0f, -m_boardAdapter.GetEpoxyThickness3DU() / 2.0f,
m_settings.GetEpoxyThickness3DU() ); m_boardAdapter.GetEpoxyThickness3DU() );
m_ogl_disp_list_board->DrawAllCameraCulledSubtractLayer( m_ogl_disp_list_board->DrawAllCameraCulledSubtractLayer(
m_ogl_disp_list_through_holes_outer_with_npth, m_ogl_disp_list_through_holes_outer_with_npth,
@ -654,7 +657,7 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
} }
if( m_settings.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
{ {
// Draw vias and pad holes with copper material // Draw vias and pad holes with copper material
set_layer_material( B_Cu ); set_layer_material( B_Cu );
@ -689,7 +692,7 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
continue; continue;
// Do not show inner layers when it is displaying the board // Do not show inner layers when it is displaying the board
if( m_settings.GetFlag( FL_SHOW_BOARD_BODY ) ) if( m_boardAdapter.GetFlag( FL_SHOW_BOARD_BODY ) )
{ {
if( (layer_id > F_Cu) && (layer_id < B_Cu) ) if( (layer_id > F_Cu) && (layer_id < B_Cu) )
continue; continue;
@ -737,7 +740,7 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
} }
else else
{ {
if( m_settings.GetFlag( FL_SUBTRACT_MASK_FROM_SILK ) && if( m_boardAdapter.GetFlag( FL_SUBTRACT_MASK_FROM_SILK ) &&
( ( ( layer_id == B_SilkS ) && ( ( ( layer_id == B_SilkS ) &&
( m_ogl_disp_lists_layers.find( B_Mask ) != m_ogl_disp_lists_layers.end() ) ) || ( m_ogl_disp_lists_layers.find( B_Mask ) != m_ogl_disp_lists_layers.end() ) ) ||
( ( layer_id == F_SilkS ) && ( ( layer_id == F_SilkS ) &&
@ -767,8 +770,7 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
} }
else else
{ {
pLayerDispList->DrawAllCameraCulled( m_settings.CameraGet().GetPos().z, pLayerDispList->DrawAllCameraCulled( m_camera.GetPos().z, aIsMoving == false );
(aIsMoving == false) );
} }
} }
} }
@ -791,7 +793,7 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
// Display transparent mask layers // Display transparent mask layers
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
if( m_settings.GetFlag( FL_SOLDERMASK ) ) if( m_boardAdapter.GetFlag( FL_SOLDERMASK ) )
{ {
//setLight_Top( true ); //setLight_Top( true );
//setLight_Bottom( true ); //setLight_Bottom( true );
@ -801,20 +803,20 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
glEnable( GL_POLYGON_OFFSET_FILL ); glEnable( GL_POLYGON_OFFSET_FILL );
glPolygonOffset( 0.0f, -1.0f ); glPolygonOffset( 0.0f, -1.0f );
if( m_settings.CameraGet().GetPos().z > 0 ) if( m_camera.GetPos().z > 0 )
{ {
render_solder_mask_layer( B_Mask, m_settings.GetLayerTopZpos3DU( B_Mask ), render_solder_mask_layer( B_Mask, m_boardAdapter.GetLayerTopZpos3DU( B_Mask ),
aIsMoving ); aIsMoving );
render_solder_mask_layer( F_Mask, m_settings.GetLayerBottomZpos3DU( F_Mask ), render_solder_mask_layer( F_Mask, m_boardAdapter.GetLayerBottomZpos3DU( F_Mask ),
aIsMoving ); aIsMoving );
} }
else else
{ {
render_solder_mask_layer( F_Mask, m_settings.GetLayerBottomZpos3DU( F_Mask ), render_solder_mask_layer( F_Mask, m_boardAdapter.GetLayerBottomZpos3DU( F_Mask ),
aIsMoving ); aIsMoving );
render_solder_mask_layer( B_Mask, m_settings.GetLayerTopZpos3DU( B_Mask ), render_solder_mask_layer( B_Mask, m_boardAdapter.GetLayerTopZpos3DU( B_Mask ),
aIsMoving ); aIsMoving );
} }
@ -838,7 +840,7 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
// Render Grid // Render Grid
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
if( m_settings.GridGet() != GRID3D_TYPE::NONE ) if( m_boardAdapter.GridGet() != GRID3D_TYPE::NONE )
{ {
glDisable( GL_LIGHTING ); glDisable( GL_LIGHTING );
@ -851,7 +853,7 @@ bool C3D_RENDER_OGL_LEGACY::Redraw(
// Render 3D arrows // Render 3D arrows
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
if( m_settings.GetFlag( FL_AXIS ) ) if( m_boardAdapter.GetFlag( FL_AXIS ) )
render_3D_arrows(); render_3D_arrows();
// Return back to the original viewport (this is important if we want // Return back to the original viewport (this is important if we want
@ -1033,11 +1035,11 @@ void C3D_RENDER_OGL_LEGACY::render_solder_mask_layer( PCB_LAYER_ID aLayerID,
if( m_ogl_disp_list_through_holes_vias_outer ) if( m_ogl_disp_list_through_holes_vias_outer )
m_ogl_disp_list_through_holes_vias_outer->ApplyScalePosition( m_ogl_disp_list_through_holes_vias_outer->ApplyScalePosition(
aZPosition, aZPosition,
m_settings.GetNonCopperLayerThickness3DU() ); m_boardAdapter.GetNonCopperLayerThickness3DU() );
m_ogl_disp_list_board->ApplyScalePosition( m_ogl_disp_list_board->ApplyScalePosition(
aZPosition, aZPosition,
m_settings.GetNonCopperLayerThickness3DU() ); m_boardAdapter.GetNonCopperLayerThickness3DU() );
set_layer_material( aLayerID ); set_layer_material( aLayerID );
@ -1055,11 +1057,11 @@ void C3D_RENDER_OGL_LEGACY::render_solder_mask_layer( PCB_LAYER_ID aLayerID,
if( m_ogl_disp_list_through_holes_vias_outer ) if( m_ogl_disp_list_through_holes_vias_outer )
m_ogl_disp_list_through_holes_vias_outer->ApplyScalePosition( m_ogl_disp_list_through_holes_vias_outer->ApplyScalePosition(
aZPosition, aZPosition,
m_settings.GetNonCopperLayerThickness3DU() ); m_boardAdapter.GetNonCopperLayerThickness3DU() );
m_ogl_disp_list_board->ApplyScalePosition( m_ogl_disp_list_board->ApplyScalePosition(
aZPosition, aZPosition,
m_settings.GetNonCopperLayerThickness3DU() ); m_boardAdapter.GetNonCopperLayerThickness3DU() );
set_layer_material( aLayerID ); set_layer_material( aLayerID );
@ -1078,10 +1080,10 @@ void C3D_RENDER_OGL_LEGACY::render_3D_models( bool aRenderTopOrBot,
bool aRenderTransparentOnly ) bool aRenderTransparentOnly )
{ {
// Go for all modules // Go for all modules
for( auto module : m_settings.GetBoard()->Modules() ) for( auto module : m_boardAdapter.GetBoard()->Modules() )
{ {
if( !module->Models().empty() ) if( !module->Models().empty() )
if( m_settings.ShouldModuleBeDisplayed( (MODULE_ATTR_T) module->GetAttributes() ) ) if( m_boardAdapter.ShouldModuleBeDisplayed((MODULE_ATTR_T) module->GetAttributes() ) )
if( ( aRenderTopOrBot && !module->IsFlipped() ) if( ( aRenderTopOrBot && !module->IsFlipped() )
|| ( !aRenderTopOrBot && module->IsFlipped() ) ) || ( !aRenderTopOrBot && module->IsFlipped() ) )
render_3D_module( module, aRenderTransparentOnly ); render_3D_module( module, aRenderTransparentOnly );
@ -1094,14 +1096,14 @@ void C3D_RENDER_OGL_LEGACY::render_3D_module( const MODULE* module,
{ {
if( !module->Models().empty() ) if( !module->Models().empty() )
{ {
const double zpos = m_settings.GetModulesZcoord3DIU( module->IsFlipped() ); const double zpos = m_boardAdapter.GetModulesZcoord3DIU( module->IsFlipped() );
glPushMatrix(); glPushMatrix();
wxPoint pos = module->GetPosition(); wxPoint pos = module->GetPosition();
glTranslatef( pos.x * m_settings.BiuTo3Dunits(), glTranslatef( pos.x * m_boardAdapter.BiuTo3Dunits(),
-pos.y * m_settings.BiuTo3Dunits(), -pos.y * m_boardAdapter.BiuTo3Dunits(),
zpos ); zpos );
if( module->GetOrientation() ) if( module->GetOrientation() )
@ -1113,7 +1115,7 @@ void C3D_RENDER_OGL_LEGACY::render_3D_module( const MODULE* module,
glRotatef( 180.0f, 0.0f, 0.0f, 1.0f ); glRotatef( 180.0f, 0.0f, 0.0f, 1.0f );
} }
double modelunit_to_3d_units_factor = m_settings.BiuTo3Dunits() * UNITS3D_TO_UNITSPCB; double modelunit_to_3d_units_factor = m_boardAdapter.BiuTo3Dunits() * UNITS3D_TO_UNITSPCB;
glScaled( modelunit_to_3d_units_factor, glScaled( modelunit_to_3d_units_factor,
modelunit_to_3d_units_factor, modelunit_to_3d_units_factor,
@ -1153,7 +1155,7 @@ void C3D_RENDER_OGL_LEGACY::render_3D_module( const MODULE* module,
else else
modelPtr->Draw_opaque(); modelPtr->Draw_opaque();
if( m_settings.GetFlag( FL_RENDER_OPENGL_SHOW_MODEL_BBOX ) ) if( m_boardAdapter.GetFlag( FL_RENDER_OPENGL_SHOW_MODEL_BBOX ) )
{ {
glEnable( GL_BLEND ); glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
@ -1210,11 +1212,11 @@ void C3D_RENDER_OGL_LEGACY::generate_new_3DGrid( GRID3D_TYPE aGridType )
const double zpos = 0.0; const double zpos = 0.0;
// Color of grid lines // Color of grid lines
const SFVEC3F gridColor = m_settings.GetColor( DARKGRAY ); const SFVEC3F gridColor = m_boardAdapter.GetColor( DARKGRAY );
// Color of grid lines every 5 lines // Color of grid lines every 5 lines
const SFVEC3F gridColor_marker = m_settings.GetColor( LIGHTGRAY ); const SFVEC3F gridColor_marker = m_boardAdapter.GetColor( LIGHTGRAY );
const double scale = m_settings.BiuTo3Dunits(); const double scale = m_boardAdapter.BiuTo3Dunits();
const double transparency = 0.35; const double transparency = 0.35;
double griSizeMM = 0.0; double griSizeMM = 0.0;
@ -1240,8 +1242,8 @@ void C3D_RENDER_OGL_LEGACY::generate_new_3DGrid( GRID3D_TYPE aGridType )
glNormal3f( 0.0, 0.0, 1.0 ); glNormal3f( 0.0, 0.0, 1.0 );
const wxSize brd_size = m_settings.GetBoardSizeBIU(); const wxSize brd_size = m_boardAdapter.GetBoardSizeBIU();
wxPoint brd_center_pos = m_settings.GetBoardPosBIU(); wxPoint brd_center_pos = m_boardAdapter.GetBoardPosBIU();
brd_center_pos.y = -brd_center_pos.y; brd_center_pos.y = -brd_center_pos.y;

10
3d-viewer/3d_rendering/3d_render_ogl_legacy/c3d_render_ogl_legacy.h
View File

@ -59,7 +59,7 @@ typedef std::map< wxString, C_OGL_3DMODEL * > MAP_3DMODEL;
class C3D_RENDER_OGL_LEGACY : public C3D_RENDER_BASE class C3D_RENDER_OGL_LEGACY : public C3D_RENDER_BASE
{ {
public: public:
explicit C3D_RENDER_OGL_LEGACY( EDA_3D_SETTINGS &aSettings ); explicit C3D_RENDER_OGL_LEGACY( BOARD_ADAPTER& aAdapter, CCAMERA& aCamera );
~C3D_RENDER_OGL_LEGACY(); ~C3D_RENDER_OGL_LEGACY();
@ -108,9 +108,6 @@ private:
MAP_3DMODEL m_3dmodel_map; MAP_3DMODEL m_3dmodel_map;
private: private:
void generate_through_outer_holes();
void generate_through_inner_holes();
CLAYERS_OGL_DISP_LISTS *generate_holes_display_list( const LIST_OBJECT2D &aListHolesObject2d, CLAYERS_OGL_DISP_LISTS *generate_holes_display_list( const LIST_OBJECT2D &aListHolesObject2d,
const SHAPE_POLY_SET &aPoly, const SHAPE_POLY_SET &aPoly,
float aZtop, float aZtop,
@ -213,11 +210,6 @@ private:
void set_layer_material( PCB_LAYER_ID aLayerID ); void set_layer_material( PCB_LAYER_ID aLayerID );
SFVEC3F get_layer_color( PCB_LAYER_ID aLayerID ); SFVEC3F get_layer_color( PCB_LAYER_ID aLayerID );
public:
const MAP_OGL_DISP_LISTS &GetLayerDispListMap() const { return m_ogl_disp_lists_layers; }
const CLAYERS_OGL_DISP_LISTS *GetLayerDispList( PCB_LAYER_ID aLayerId ) const { return m_ogl_disp_lists_layers.at( aLayerId ); }
const CLAYERS_OGL_DISP_LISTS *GetBoardDispList() const { return m_ogl_disp_list_board; }
}; };
#endif // C3D_RENDER_OGL_LEGACY_H_ #endif // C3D_RENDER_OGL_LEGACY_H_

297
3d-viewer/3d_rendering/3d_render_raytracing/c3d_render_createscene.cpp
View File

@ -55,47 +55,48 @@
void C3D_RENDER_RAYTRACING::setupMaterials() void C3D_RENDER_RAYTRACING::setupMaterials()
{ {
double mmTo3Dunits = IU_PER_MM * m_boardAdapter.BiuTo3Dunits();
if( m_settings.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) ) if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) )
{ {
m_board_normal_perturbator = CBOARDNORMAL( 0.5f * IU_PER_MM * m_settings.BiuTo3Dunits() ); m_board_normal_perturbator = CBOARDNORMAL( 0.5f * mmTo3Dunits );
m_copper_normal_perturbator = CCOPPERNORMAL( 4.0f * IU_PER_MM * m_settings.BiuTo3Dunits(), m_copper_normal_perturbator = CCOPPERNORMAL( 4.0f * mmTo3Dunits,
&m_board_normal_perturbator ); &m_board_normal_perturbator );
m_solder_mask_normal_perturbator = CSOLDERMASKNORMAL( &m_board_normal_perturbator ); m_solder_mask_normal_perturbator = CSOLDERMASKNORMAL( &m_board_normal_perturbator );
m_plastic_normal_perturbator = CPLASTICNORMAL( 0.15f * IU_PER_MM * m_settings.BiuTo3Dunits() ); m_plastic_normal_perturbator = CPLASTICNORMAL( 0.15f * mmTo3Dunits );
m_plastic_shine_normal_perturbator = CPLASTICSHINENORMAL( 1.0f * IU_PER_MM * m_settings.BiuTo3Dunits() ); m_plastic_shine_normal_perturbator = CPLASTICSHINENORMAL( 1.0f * mmTo3Dunits );
m_brushed_metal_normal_perturbator = CMETALBRUSHEDNORMAL( 1.0f * IU_PER_MM * m_settings.BiuTo3Dunits() ); m_brushed_metal_normal_perturbator = CMETALBRUSHEDNORMAL( 1.0f * mmTo3Dunits );
} }
// http://devernay.free.fr/cours/opengl/materials.html // http://devernay.free.fr/cours/opengl/materials.html
// Copper // Copper
m_materials.m_Copper = CBLINN_PHONG_MATERIAL( m_materials.m_Copper = CBLINN_PHONG_MATERIAL(
ConvertSRGBToLinear( (SFVEC3F)m_settings.m_CopperColor ) * ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_CopperColor ) *
(SFVEC3F)(0.18f), // ambient (SFVEC3F)(0.18f), // ambient
SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive
glm::clamp( ((SFVEC3F)(1.0f) - glm::clamp( ((SFVEC3F)(1.0f) -
ConvertSRGBToLinear( (SFVEC3F)m_settings.m_CopperColor ) ), ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_CopperColor ) ),
SFVEC3F( 0.0f ), SFVEC3F( 0.0f ),
SFVEC3F( 0.35f ) ), // specular SFVEC3F( 0.35f ) ), // specular
0.4f * 128.0f, // shiness 0.4f * 128.0f, // shiness
0.0f, // transparency 0.0f, // transparency
0.0f ); 0.0f );
if( m_settings.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) ) if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) )
m_materials.m_Copper.SetNormalPerturbator( &m_copper_normal_perturbator ); m_materials.m_Copper.SetNormalPerturbator( &m_copper_normal_perturbator );
m_materials.m_Paste = CBLINN_PHONG_MATERIAL( m_materials.m_Paste = CBLINN_PHONG_MATERIAL(
ConvertSRGBToLinear( (SFVEC3F)m_settings.m_SolderPasteColor ) * ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_SolderPasteColor ) *
ConvertSRGBToLinear( (SFVEC3F)m_settings.m_SolderPasteColor ), // ambient ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_SolderPasteColor ), // ambient
SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive
ConvertSRGBToLinear( (SFVEC3F)m_settings.m_SolderPasteColor ) * ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_SolderPasteColor ) *
ConvertSRGBToLinear( (SFVEC3F)m_settings.m_SolderPasteColor ), // specular ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_SolderPasteColor ), // specular
0.10f * 128.0f, // shiness 0.10f * 128.0f, // shiness
0.0f, // transparency 0.0f, // transparency
0.0f ); 0.0f );
@ -104,7 +105,7 @@ void C3D_RENDER_RAYTRACING::setupMaterials()
SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive
glm::clamp( glm::clamp(
( ( SFVEC3F )( 1.0f ) ( ( SFVEC3F )( 1.0f )
- ConvertSRGBToLinear( (SFVEC3F) m_settings.m_SilkScreenColorTop ) ), - ConvertSRGBToLinear( (SFVEC3F) m_boardAdapter.m_SilkScreenColorTop ) ),
SFVEC3F( 0.0f ), SFVEC3F( 0.0f ),
SFVEC3F( 0.10f ) ), // specular SFVEC3F( 0.10f ) ), // specular
0.078125f * 128.0f, // shiness 0.078125f * 128.0f, // shiness
@ -112,18 +113,18 @@ void C3D_RENDER_RAYTRACING::setupMaterials()
0.0f ); 0.0f );
const float solderMaskTop_gray = const float solderMaskTop_gray =
( m_settings.m_SolderMaskColorTop.r + m_settings.m_SolderMaskColorTop.g ( m_boardAdapter.m_SolderMaskColorTop.r + m_boardAdapter.m_SolderMaskColorTop.g
+ m_settings.m_SolderMaskColorTop.b ) + m_boardAdapter.m_SolderMaskColorTop.b )
/ 3.0f; / 3.0f;
const float solderMaskTop_transparency = solderMaskTop_gray * 0.40f + 0.005f; const float solderMaskTop_transparency = solderMaskTop_gray * 0.40f + 0.005f;
m_materials.m_SolderMask = CBLINN_PHONG_MATERIAL( m_materials.m_SolderMask = CBLINN_PHONG_MATERIAL(
ConvertSRGBToLinear( (SFVEC3F) m_settings.m_SolderMaskColorTop ) * 0.10f, // ambient ConvertSRGBToLinear( (SFVEC3F) m_boardAdapter.m_SolderMaskColorTop ) * 0.10f, // ambient
SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive
glm::clamp( glm::clamp(
( ( SFVEC3F )( 1.0f ) ( ( SFVEC3F )( 1.0f )
- ConvertSRGBToLinear( (SFVEC3F) m_settings.m_SolderMaskColorTop ) ), - ConvertSRGBToLinear( (SFVEC3F) m_boardAdapter.m_SolderMaskColorTop ) ),
SFVEC3F( 0.0f ), SFVEC3F( 0.0f ),
SFVEC3F( solderMaskTop_gray * 2.0f ) ), // specular SFVEC3F( solderMaskTop_gray * 2.0f ) ), // specular
0.85f * 128.0f, // shiness 0.85f * 128.0f, // shiness
@ -131,18 +132,18 @@ void C3D_RENDER_RAYTRACING::setupMaterials()
0.16f ); // reflection 0.16f ); // reflection
const float solderMaskBot_gray = const float solderMaskBot_gray =
( m_settings.m_SolderMaskColorBot.r + m_settings.m_SolderMaskColorBot.g ( m_boardAdapter.m_SolderMaskColorBot.r + m_boardAdapter.m_SolderMaskColorBot.g
+ m_settings.m_SolderMaskColorBot.b ) + m_boardAdapter.m_SolderMaskColorBot.b )
/ 3.0f; / 3.0f;
const float solderMaskBot_transparency = solderMaskBot_gray * 0.40f + 0.005f; const float solderMaskBot_transparency = solderMaskBot_gray * 0.40f + 0.005f;
m_materials.m_SolderMask = CBLINN_PHONG_MATERIAL( m_materials.m_SolderMask = CBLINN_PHONG_MATERIAL(
ConvertSRGBToLinear( (SFVEC3F) m_settings.m_SolderMaskColorBot ) * 0.10f, // ambient ConvertSRGBToLinear( (SFVEC3F) m_boardAdapter.m_SolderMaskColorBot ) * 0.10f, // ambient
SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive
glm::clamp( glm::clamp(
( ( SFVEC3F )( 1.0f ) ( ( SFVEC3F )( 1.0f )
- ConvertSRGBToLinear( (SFVEC3F) m_settings.m_SolderMaskColorBot ) ), - ConvertSRGBToLinear( (SFVEC3F) m_boardAdapter.m_SolderMaskColorBot ) ),
SFVEC3F( 0.0f ), SFVEC3F( 0.0f ),
SFVEC3F( solderMaskBot_gray * 2.0f ) ), // specular SFVEC3F( solderMaskBot_gray * 2.0f ) ), // specular
0.85f * 128.0f, // shiness 0.85f * 128.0f, // shiness
@ -153,7 +154,7 @@ void C3D_RENDER_RAYTRACING::setupMaterials()
m_materials.m_SolderMask.SetNrRefractionsSamples( 1 ); m_materials.m_SolderMask.SetNrRefractionsSamples( 1 );
m_materials.m_SolderMask.SetNrReflectionsSamples( 2 ); m_materials.m_SolderMask.SetNrReflectionsSamples( 2 );
if( m_settings.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) ) if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) )
m_materials.m_SolderMask.SetNormalPerturbator( &m_solder_mask_normal_perturbator ); m_materials.m_SolderMask.SetNormalPerturbator( &m_solder_mask_normal_perturbator );
m_materials.m_EpoxyBoard = CBLINN_PHONG_MATERIAL( m_materials.m_EpoxyBoard = CBLINN_PHONG_MATERIAL(
@ -171,11 +172,11 @@ void C3D_RENDER_RAYTRACING::setupMaterials()
m_materials.m_EpoxyBoard.SetAbsorvance( 10.0f ); m_materials.m_EpoxyBoard.SetAbsorvance( 10.0f );
m_materials.m_EpoxyBoard.SetNrRefractionsSamples( 3 ); m_materials.m_EpoxyBoard.SetNrRefractionsSamples( 3 );
if( m_settings.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) ) if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) )
m_materials.m_EpoxyBoard.SetNormalPerturbator( &m_board_normal_perturbator ); m_materials.m_EpoxyBoard.SetNormalPerturbator( &m_board_normal_perturbator );
SFVEC3F bgTop = ConvertSRGBToLinear( (SFVEC3F)m_settings.m_BgColorTop ); SFVEC3F bgTop = ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_BgColorTop );
//SFVEC3F bgBot = (SFVEC3F)m_settings.m_BgColorBot; //SFVEC3F bgBot = (SFVEC3F)m_boardAdapter.m_BgColorBot;
m_materials.m_Floor = CBLINN_PHONG_MATERIAL( m_materials.m_Floor = CBLINN_PHONG_MATERIAL(
bgTop * 0.125f, // ambient bgTop * 0.125f, // ambient
@ -270,15 +271,15 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
unsigned stats_startReloadTime = GetRunningMicroSecs(); unsigned stats_startReloadTime = GetRunningMicroSecs();
m_settings.InitSettings( aStatusTextReporter, aWarningTextReporter ); m_boardAdapter.InitSettings( aStatusTextReporter, aWarningTextReporter );
#ifdef PRINT_STATISTICS_3D_VIEWER #ifdef PRINT_STATISTICS_3D_VIEWER
unsigned stats_endReloadTime = GetRunningMicroSecs(); unsigned stats_endReloadTime = GetRunningMicroSecs();
unsigned stats_startConvertTime = GetRunningMicroSecs(); unsigned stats_startConvertTime = GetRunningMicroSecs();
#endif #endif
SFVEC3F camera_pos = m_settings.GetBoardCenter3DU(); SFVEC3F camera_pos = m_boardAdapter.GetBoardCenter3DU();
m_settings.CameraGet().SetBoardLookAtPos( camera_pos ); m_camera.SetBoardLookAtPos( camera_pos );
m_object_container.Clear(); m_object_container.Clear();
m_containerWithObjectsToDelete.Clear(); m_containerWithObjectsToDelete.Clear();
@ -295,19 +296,19 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
m_outlineBoard2dObjects = new CCONTAINER2D; m_outlineBoard2dObjects = new CCONTAINER2D;
const int outlineCount = m_settings.GetBoardPoly().OutlineCount(); const int outlineCount = m_boardAdapter.GetBoardPoly().OutlineCount();
if( outlineCount > 0 ) if( outlineCount > 0 )
{ {
float divFactor = 0.0f; float divFactor = 0.0f;
if( m_settings.GetStats_Nr_Vias() ) if( m_boardAdapter.GetStats_Nr_Vias() )
divFactor = m_settings.GetStats_Med_Via_Hole_Diameter3DU() * 18.0f; divFactor = m_boardAdapter.GetStats_Med_Via_Hole_Diameter3DU() * 18.0f;
else else
if( m_settings.GetStats_Nr_Holes() ) if( m_boardAdapter.GetStats_Nr_Holes() )
divFactor = m_settings.GetStats_Med_Hole_Diameter3DU() * 8.0f; divFactor = m_boardAdapter.GetStats_Med_Hole_Diameter3DU() * 8.0f;
SHAPE_POLY_SET boardPolyCopy = m_settings.GetBoardPoly(); SHAPE_POLY_SET boardPolyCopy = m_boardAdapter.GetBoardPoly();
boardPolyCopy.Fracture( SHAPE_POLY_SET::PM_FAST ); boardPolyCopy.Fracture( SHAPE_POLY_SET::PM_FAST );
for( int iOutlinePolyIdx = 0; iOutlinePolyIdx < outlineCount; iOutlinePolyIdx++ ) for( int iOutlinePolyIdx = 0; iOutlinePolyIdx < outlineCount; iOutlinePolyIdx++ )
@ -315,13 +316,13 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
Convert_path_polygon_to_polygon_blocks_and_dummy_blocks( Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(
boardPolyCopy, boardPolyCopy,
*m_outlineBoard2dObjects, *m_outlineBoard2dObjects,
m_settings.BiuTo3Dunits(), m_boardAdapter.BiuTo3Dunits(),
divFactor, divFactor,
*dynamic_cast<const BOARD_ITEM*>( m_settings.GetBoard() ), *dynamic_cast<const BOARD_ITEM*>( m_boardAdapter.GetBoard() ),
iOutlinePolyIdx ); iOutlinePolyIdx );
} }
if( m_settings.GetFlag( FL_SHOW_BOARD_BODY ) ) if( m_boardAdapter.GetFlag( FL_SHOW_BOARD_BODY ) )
{ {
const LIST_OBJECT2D &listObjects = m_outlineBoard2dObjects->GetList(); const LIST_OBJECT2D &listObjects = m_outlineBoard2dObjects->GetList();
@ -334,11 +335,11 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
std::vector<const COBJECT2D *> *object2d_B = new std::vector<const COBJECT2D *>(); std::vector<const COBJECT2D *> *object2d_B = new std::vector<const COBJECT2D *>();
// Check if there are any THT that intersects this outline object part // Check if there are any THT that intersects this outline object part
if( !m_settings.GetThroughHole_Outer().GetList().empty() ) if( !m_boardAdapter.GetThroughHole_Outer().GetList().empty() )
{ {
CONST_LIST_OBJECT2D intersectionList; CONST_LIST_OBJECT2D intersectionList;
m_settings.GetThroughHole_Outer().GetListObjectsIntersects( m_boardAdapter.GetThroughHole_Outer().GetListObjectsIntersects(
object2d_A->GetBBox(), object2d_A->GetBBox(),
intersectionList ); intersectionList );
@ -367,17 +368,17 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
{ {
#if 0 #if 0
create_3d_object_from( m_object_container, object2d_A, create_3d_object_from( m_object_container, object2d_A,
m_settings.GetLayerBottomZpos3DU( F_Cu ), m_boardAdapter.GetLayerBottomZpos3DU( F_Cu ),
m_settings.GetLayerBottomZpos3DU( B_Cu ), m_boardAdapter.GetLayerBottomZpos3DU( B_Cu ),
&m_materials.m_EpoxyBoard, &m_materials.m_EpoxyBoard,
g_epoxyColor ); g_epoxyColor );
#else #else
CLAYERITEM *objPtr = new CLAYERITEM( object2d_A, CLAYERITEM *objPtr = new CLAYERITEM( object2d_A,
m_settings.GetLayerBottomZpos3DU( F_Cu ), m_boardAdapter.GetLayerBottomZpos3DU( F_Cu ),
m_settings.GetLayerBottomZpos3DU( B_Cu ) ); m_boardAdapter.GetLayerBottomZpos3DU( B_Cu ) );
objPtr->SetMaterial( &m_materials.m_EpoxyBoard ); objPtr->SetMaterial( &m_materials.m_EpoxyBoard );
objPtr->SetColor( ConvertSRGBToLinear( (SFVEC3F)m_settings.m_BoardBodyColor ) ); objPtr->SetColor( ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_BoardBodyColor ) );
m_object_container.Add( objPtr ); m_object_container.Add( objPtr );
#endif #endif
} }
@ -387,16 +388,16 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
object2d_A, object2d_A,
object2d_B, object2d_B,
CSGITEM_FULL, CSGITEM_FULL,
(const BOARD_ITEM &)*m_settings.GetBoard() ); (const BOARD_ITEM &)*m_boardAdapter.GetBoard() );
m_containerWithObjectsToDelete.Add( itemCSG2d ); m_containerWithObjectsToDelete.Add( itemCSG2d );
CLAYERITEM *objPtr = new CLAYERITEM( itemCSG2d, CLAYERITEM *objPtr = new CLAYERITEM( itemCSG2d,
m_settings.GetLayerBottomZpos3DU( F_Cu ), m_boardAdapter.GetLayerBottomZpos3DU( F_Cu ),
m_settings.GetLayerBottomZpos3DU( B_Cu ) ); m_boardAdapter.GetLayerBottomZpos3DU( B_Cu ) );
objPtr->SetMaterial( &m_materials.m_EpoxyBoard ); objPtr->SetMaterial( &m_materials.m_EpoxyBoard );
objPtr->SetColor( ConvertSRGBToLinear( (SFVEC3F)m_settings.m_BoardBodyColor ) ); objPtr->SetColor( ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_BoardBodyColor ) );
m_object_container.Add( objPtr ); m_object_container.Add( objPtr );
} }
} }
@ -408,9 +409,9 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
// So this will add a full hole. // So this will add a full hole.
// In fact, that is not need if the hole have copper. // In fact, that is not need if the hole have copper.
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
if( !m_settings.GetThroughHole_Outer().GetList().empty() ) if( !m_boardAdapter.GetThroughHole_Outer().GetList().empty() )
{ {
const LIST_OBJECT2D &holeList = m_settings.GetThroughHole_Outer().GetList(); const LIST_OBJECT2D &holeList = m_boardAdapter.GetThroughHole_Outer().GetList();
for( LIST_OBJECT2D::const_iterator hole = holeList.begin(); for( LIST_OBJECT2D::const_iterator hole = holeList.begin();
hole != holeList.end(); hole != holeList.end();
@ -426,12 +427,12 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
CVCYLINDER *objPtr = new CVCYLINDER( CVCYLINDER *objPtr = new CVCYLINDER(
hole2d->GetCentroid(), hole2d->GetCentroid(),
NextFloatDown( m_settings.GetLayerBottomZpos3DU( F_Cu ) ), NextFloatDown( m_boardAdapter.GetLayerBottomZpos3DU( F_Cu ) ),
NextFloatUp( m_settings.GetLayerBottomZpos3DU( B_Cu ) ), NextFloatUp( m_boardAdapter.GetLayerBottomZpos3DU( B_Cu ) ),
radius ); radius );
objPtr->SetMaterial( &m_materials.m_EpoxyBoard ); objPtr->SetMaterial( &m_materials.m_EpoxyBoard );
objPtr->SetColor( ConvertSRGBToLinear( (SFVEC3F)m_settings.m_BoardBodyColor ) ); objPtr->SetColor( ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_BoardBodyColor ) );
m_object_container.Add( objPtr ); m_object_container.Add( objPtr );
} }
@ -453,8 +454,8 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
printf("Add layers maps...\n"); printf("Add layers maps...\n");
#endif #endif
for( MAP_CONTAINER_2D::const_iterator ii = m_settings.GetMapLayers().begin(); for( MAP_CONTAINER_2D::const_iterator ii = m_boardAdapter.GetMapLayers().begin();
ii != m_settings.GetMapLayers().end(); ii != m_boardAdapter.GetMapLayers().end();
++ii ) ++ii )
{ {
PCB_LAYER_ID layer_id = static_cast<PCB_LAYER_ID>(ii->first); PCB_LAYER_ID layer_id = static_cast<PCB_LAYER_ID>(ii->first);
@ -476,27 +477,27 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
case F_Paste: case F_Paste:
materialLayer = &m_materials.m_Paste; materialLayer = &m_materials.m_Paste;
if( m_settings.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
layerColor = m_settings.m_SolderPasteColor; layerColor = m_boardAdapter.m_SolderPasteColor;
else else
layerColor = m_settings.GetLayerColor( layer_id ); layerColor = m_boardAdapter.GetLayerColor( layer_id );
break; break;
case B_SilkS: case B_SilkS:
materialLayer = &m_materials.m_SilkS; materialLayer = &m_materials.m_SilkS;
if( m_settings.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
layerColor = m_settings.m_SilkScreenColorBot; layerColor = m_boardAdapter.m_SilkScreenColorBot;
else else
layerColor = m_settings.GetLayerColor( layer_id ); layerColor = m_boardAdapter.GetLayerColor( layer_id );
break; break;
case F_SilkS: case F_SilkS:
materialLayer = &m_materials.m_SilkS; materialLayer = &m_materials.m_SilkS;
if( m_settings.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
layerColor = m_settings.m_SilkScreenColorTop; layerColor = m_boardAdapter.m_SilkScreenColorTop;
else else
layerColor = m_settings.GetLayerColor( layer_id ); layerColor = m_boardAdapter.GetLayerColor( layer_id );
break; break;
case Dwgs_User: case Dwgs_User:
@ -518,10 +519,10 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
default: default:
materialLayer = &m_materials.m_Copper; materialLayer = &m_materials.m_Copper;
if( m_settings.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
layerColor = m_settings.m_CopperColor; layerColor = m_boardAdapter.m_CopperColor;
else else
layerColor = m_settings.GetLayerColor( layer_id ); layerColor = m_boardAdapter.GetLayerColor( layer_id );
break; break;
} }
@ -548,7 +549,7 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
// Check if there are any layerhole that intersects this object // Check if there are any layerhole that intersects this object
// Eg: a segment is cutted by a via hole or THT hole. // Eg: a segment is cutted by a via hole or THT hole.
// ///////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////
const MAP_CONTAINER_2D &layerHolesMap = m_settings.GetMapLayersHoles(); const MAP_CONTAINER_2D &layerHolesMap = m_boardAdapter.GetMapLayersHoles();
if( layerHolesMap.find(layer_id) != layerHolesMap.end() ) if( layerHolesMap.find(layer_id) != layerHolesMap.end() )
{ {
@ -579,11 +580,11 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
// Check if there are any THT that intersects this object // Check if there are any THT that intersects this object
// ///////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////
if( !m_settings.GetThroughHole_Outer().GetList().empty() ) if( !m_boardAdapter.GetThroughHole_Outer().GetList().empty() )
{ {
CONST_LIST_OBJECT2D intersectionList; CONST_LIST_OBJECT2D intersectionList;
m_settings.GetThroughHole_Outer().GetListObjectsIntersects( m_boardAdapter.GetThroughHole_Outer().GetListObjectsIntersects(
object2d_A->GetBBox(), object2d_A->GetBBox(),
intersectionList ); intersectionList );
@ -604,9 +605,9 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
} }
const MAP_CONTAINER_2D& mapLayers = m_settings.GetMapLayers(); const MAP_CONTAINER_2D& mapLayers = m_boardAdapter.GetMapLayers();
if( m_settings.GetFlag( FL_SUBTRACT_MASK_FROM_SILK ) && if( m_boardAdapter.GetFlag( FL_SUBTRACT_MASK_FROM_SILK ) &&
( ( ( layer_id == B_SilkS ) && ( ( ( layer_id == B_SilkS ) &&
( mapLayers.find( B_Mask ) != mapLayers.end() ) ) || ( mapLayers.find( B_Mask ) != mapLayers.end() ) ) ||
( ( layer_id == F_SilkS ) && ( ( layer_id == F_SilkS ) &&
@ -647,14 +648,14 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
#if 0 #if 0
create_3d_object_from( m_object_container, create_3d_object_from( m_object_container,
object2d_A, object2d_A,
m_settings.GetLayerBottomZpos3DU( layer_id ), m_boardAdapter.GetLayerBottomZpos3DU( layer_id ),
m_settings.GetLayerTopZpos3DU( layer_id ), m_boardAdapter.GetLayerTopZpos3DU( layer_id ),
materialLayer, materialLayer,
layerColor ); layerColor );
#else #else
CLAYERITEM *objPtr = new CLAYERITEM( object2d_A, CLAYERITEM *objPtr = new CLAYERITEM( object2d_A,
m_settings.GetLayerBottomZpos3DU( layer_id ), m_boardAdapter.GetLayerBottomZpos3DU( layer_id ),
m_settings.GetLayerTopZpos3DU( layer_id ) ); m_boardAdapter.GetLayerTopZpos3DU( layer_id ) );
objPtr->SetMaterial( materialLayer ); objPtr->SetMaterial( materialLayer );
objPtr->SetColor( ConvertSRGBToLinear( layerColor ) ); objPtr->SetColor( ConvertSRGBToLinear( layerColor ) );
m_object_container.Add( objPtr ); m_object_container.Add( objPtr );
@ -670,8 +671,8 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
m_containerWithObjectsToDelete.Add( itemCSG2d ); m_containerWithObjectsToDelete.Add( itemCSG2d );
CLAYERITEM *objPtr = new CLAYERITEM( itemCSG2d, CLAYERITEM *objPtr = new CLAYERITEM( itemCSG2d,
m_settings.GetLayerBottomZpos3DU( layer_id ), m_boardAdapter.GetLayerBottomZpos3DU( layer_id ),
m_settings.GetLayerTopZpos3DU( layer_id ) ); m_boardAdapter.GetLayerTopZpos3DU( layer_id ) );
objPtr->SetMaterial( materialLayer ); objPtr->SetMaterial( materialLayer );
objPtr->SetColor( ConvertSRGBToLinear( layerColor ) ); objPtr->SetColor( ConvertSRGBToLinear( layerColor ) );
@ -690,13 +691,13 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
// We will check for all objects in the outline if it intersects any object // We will check for all objects in the outline if it intersects any object
// in the layer container and also any hole. // in the layer container and also any hole.
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
if( m_settings.GetFlag( FL_SOLDERMASK ) && if( m_boardAdapter.GetFlag( FL_SOLDERMASK ) &&
(m_outlineBoard2dObjects->GetList().size() >= 1) ) (m_outlineBoard2dObjects->GetList().size() >= 1) )
{ {
CMATERIAL *materialLayer = &m_materials.m_SolderMask; CMATERIAL *materialLayer = &m_materials.m_SolderMask;
for( MAP_CONTAINER_2D::const_iterator ii = m_settings.GetMapLayers().begin(); for( MAP_CONTAINER_2D::const_iterator ii = m_boardAdapter.GetMapLayers().begin();
ii != m_settings.GetMapLayers().end(); ii != m_boardAdapter.GetMapLayers().end();
++ii ) ++ii )
{ {
PCB_LAYER_ID layer_id = static_cast<PCB_LAYER_ID>(ii->first); PCB_LAYER_ID layer_id = static_cast<PCB_LAYER_ID>(ii->first);
@ -709,18 +710,18 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
continue; continue;
SFVEC3F layerColor; SFVEC3F layerColor;
if( m_settings.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
{ {
if( layer_id == B_Mask ) if( layer_id == B_Mask )
layerColor = m_settings.m_SolderMaskColorBot; layerColor = m_boardAdapter.m_SolderMaskColorBot;
else else
layerColor = m_settings.m_SolderMaskColorTop; layerColor = m_boardAdapter.m_SolderMaskColorTop;
} }
else else
layerColor = m_settings.GetLayerColor( layer_id ); layerColor = m_boardAdapter.GetLayerColor( layer_id );
const float zLayerMin = m_settings.GetLayerBottomZpos3DU( layer_id ); const float zLayerMin = m_boardAdapter.GetLayerBottomZpos3DU( layer_id );
const float zLayerMax = m_settings.GetLayerTopZpos3DU( layer_id ); const float zLayerMax = m_boardAdapter.GetLayerTopZpos3DU( layer_id );
// Get the outline board objects // Get the outline board objects
const LIST_OBJECT2D &listObjects = m_outlineBoard2dObjects->GetList(); const LIST_OBJECT2D &listObjects = m_outlineBoard2dObjects->GetList();
@ -734,12 +735,12 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
std::vector<const COBJECT2D *> *object2d_B = new std::vector<const COBJECT2D *>(); std::vector<const COBJECT2D *> *object2d_B = new std::vector<const COBJECT2D *>();
// Check if there are any THT that intersects this outline object part // Check if there are any THT that intersects this outline object part
if( !m_settings.GetThroughHole_Outer().GetList().empty() ) if( !m_boardAdapter.GetThroughHole_Outer().GetList().empty() )
{ {
CONST_LIST_OBJECT2D intersectionList; CONST_LIST_OBJECT2D intersectionList;
m_settings.GetThroughHole_Outer().GetListObjectsIntersects( m_boardAdapter.GetThroughHole_Outer().GetListObjectsIntersects(
object2d_A->GetBBox(), object2d_A->GetBBox(),
intersectionList ); intersectionList );
@ -846,9 +847,9 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
// Add floor // Add floor
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
if( m_settings.GetFlag( FL_RENDER_RAYTRACING_BACKFLOOR ) ) if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_BACKFLOOR ) )
{ {
CBBOX boardBBox = m_settings.GetBBox3DU(); CBBOX boardBBox = m_boardAdapter.GetBBox3DU();
if( boardBBox.IsInitialized() ) if( boardBBox.IsInitialized() )
{ {
@ -891,8 +892,8 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
newTriangle1->SetMaterial( (const CMATERIAL *)&m_materials.m_Floor ); newTriangle1->SetMaterial( (const CMATERIAL *)&m_materials.m_Floor );
newTriangle2->SetMaterial( (const CMATERIAL *)&m_materials.m_Floor ); newTriangle2->SetMaterial( (const CMATERIAL *)&m_materials.m_Floor );
newTriangle1->SetColor( ConvertSRGBToLinear( (SFVEC3F)m_settings.m_BgColorTop ) ); newTriangle1->SetColor( ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_BgColorTop ) );
newTriangle2->SetColor( ConvertSRGBToLinear( (SFVEC3F)m_settings.m_BgColorTop ) ); newTriangle2->SetColor( ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_BgColorTop ) );
} }
} }
} }
@ -915,7 +916,7 @@ void C3D_RENDER_RAYTRACING::reload( REPORTER* aStatusTextReporter, REPORTER* aWa
// Option 1 - using Point Lights // Option 1 - using Point Lights
const SFVEC3F &boarCenter = m_settings.GetBBox3DU().GetCenter(); const SFVEC3F &boarCenter = m_boardAdapter.GetBBox3DU().GetCenter();
m_lights.Add( new CPOINTLIGHT( SFVEC3F( boarCenter.x, boarCenter.y, +RANGE_SCALE_3D * 2.0f ), m_lights.Add( new CPOINTLIGHT( SFVEC3F( boarCenter.x, boarCenter.y, +RANGE_SCALE_3D * 2.0f ),
SFVEC3F( light_top_bottom ) ) ); SFVEC3F( light_top_bottom ) ) );
@ -1035,19 +1036,19 @@ void C3D_RENDER_RAYTRACING::insert3DViaHole( const VIA* aVia )
aVia->LayerPair( &top_layer, &bottom_layer ); aVia->LayerPair( &top_layer, &bottom_layer );
float topZ = m_settings.GetLayerBottomZpos3DU( top_layer ) + float topZ = m_boardAdapter.GetLayerBottomZpos3DU( top_layer ) +
m_settings.GetCopperThickness3DU(); m_boardAdapter.GetCopperThickness3DU();
float botZ = m_settings.GetLayerBottomZpos3DU( bottom_layer ) - float botZ = m_boardAdapter.GetLayerBottomZpos3DU( bottom_layer ) -
m_settings.GetCopperThickness3DU(); m_boardAdapter.GetCopperThickness3DU();
const SFVEC2F center = SFVEC2F( aVia->GetStart().x * m_settings.BiuTo3Dunits(), const SFVEC2F center = SFVEC2F( aVia->GetStart().x * m_boardAdapter.BiuTo3Dunits(),
-aVia->GetStart().y * m_settings.BiuTo3Dunits() ); -aVia->GetStart().y * m_boardAdapter.BiuTo3Dunits() );
CRING2D *ring = new CRING2D( center, CRING2D *ring = new CRING2D( center,
radiusBUI * m_settings.BiuTo3Dunits(), radiusBUI * m_boardAdapter.BiuTo3Dunits(),
( radiusBUI + m_settings.GetCopperThicknessBIU() ) * ( radiusBUI + m_boardAdapter.GetCopperThicknessBIU() ) *
m_settings.BiuTo3Dunits(), m_boardAdapter.BiuTo3Dunits(),
*aVia ); *aVia );
m_containerWithObjectsToDelete.Add( ring ); m_containerWithObjectsToDelete.Add( ring );
@ -1057,11 +1058,11 @@ void C3D_RENDER_RAYTRACING::insert3DViaHole( const VIA* aVia )
objPtr->SetMaterial( &m_materials.m_Copper ); objPtr->SetMaterial( &m_materials.m_Copper );
if( m_settings.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
objPtr->SetColor( ConvertSRGBToLinear( (SFVEC3F)m_settings.m_CopperColor ) ); objPtr->SetColor( ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_CopperColor ) );
else else
objPtr->SetColor( ConvertSRGBToLinear( objPtr->SetColor( ConvertSRGBToLinear(
m_settings.GetItemColor( LAYER_VIAS + static_cast<int>( aVia->GetViaType() ) ) ) ); m_boardAdapter.GetItemColor( LAYER_VIAS + static_cast<int>( aVia->GetViaType() ) ) ) );
m_object_container.Add( objPtr ); m_object_container.Add( objPtr );
} }
@ -1075,10 +1076,10 @@ void C3D_RENDER_RAYTRACING::insert3DPadHole( const D_PAD* aPad )
SFVEC3F objColor; SFVEC3F objColor;
if( m_settings.GetFlag( FL_USE_REALISTIC_MODE ) ) if( m_boardAdapter.GetFlag( FL_USE_REALISTIC_MODE ) )
objColor = (SFVEC3F)m_settings.m_CopperColor; objColor = (SFVEC3F)m_boardAdapter.m_CopperColor;
else else
objColor = m_settings.GetItemColor( LAYER_PADS_TH ); objColor = m_boardAdapter.GetItemColor( LAYER_PADS_TH );
const wxSize drillsize = aPad->GetDrillSize(); const wxSize drillsize = aPad->GetDrillSize();
const bool hasHole = drillsize.x && drillsize.y; const bool hasHole = drillsize.x && drillsize.y;
@ -1086,22 +1087,22 @@ void C3D_RENDER_RAYTRACING::insert3DPadHole( const D_PAD* aPad )
if( !hasHole ) if( !hasHole )
return; return;
const float topZ = m_settings.GetLayerBottomZpos3DU( F_Cu ) + const float topZ = m_boardAdapter.GetLayerBottomZpos3DU( F_Cu ) +
m_settings.GetCopperThickness3DU(); m_boardAdapter.GetCopperThickness3DU();
const float botZ = m_settings.GetLayerBottomZpos3DU( B_Cu ) - const float botZ = m_boardAdapter.GetLayerBottomZpos3DU( B_Cu ) -
m_settings.GetCopperThickness3DU(); m_boardAdapter.GetCopperThickness3DU();
if( drillsize.x == drillsize.y ) // usual round hole if( drillsize.x == drillsize.y ) // usual round hole
{ {
SFVEC2F center = SFVEC2F( aPad->GetPosition().x * m_settings.BiuTo3Dunits(), SFVEC2F center = SFVEC2F( aPad->GetPosition().x * m_boardAdapter.BiuTo3Dunits(),
-aPad->GetPosition().y * m_settings.BiuTo3Dunits() ); -aPad->GetPosition().y * m_boardAdapter.BiuTo3Dunits() );
CRING2D *ring = new CRING2D( center, CRING2D *ring = new CRING2D( center,
( drillsize.x / 2 ) * m_settings.BiuTo3Dunits(), ( drillsize.x / 2 ) * m_boardAdapter.BiuTo3Dunits(),
( ( drillsize.x / 2 ) + (( drillsize.x / 2 ) +
m_settings.GetCopperThicknessBIU() ) * m_boardAdapter.GetCopperThicknessBIU() ) *
m_settings.BiuTo3Dunits(), m_boardAdapter.BiuTo3Dunits(),
*aPad ); *aPad );
m_containerWithObjectsToDelete.Add( ring ); m_containerWithObjectsToDelete.Add( ring );
@ -1130,20 +1131,20 @@ void C3D_RENDER_RAYTRACING::insert3DPadHole( const D_PAD* aPad )
wxPoint end = aPad->GetPosition() - ends_offset; wxPoint end = aPad->GetPosition() - ends_offset;
CROUNDSEGMENT2D *innerSeg = new CROUNDSEGMENT2D( CROUNDSEGMENT2D *innerSeg = new CROUNDSEGMENT2D(
SFVEC2F( start.x * m_settings.BiuTo3Dunits(), SFVEC2F( start.x * m_boardAdapter.BiuTo3Dunits(),
-start.y * m_settings.BiuTo3Dunits() ), -start.y * m_boardAdapter.BiuTo3Dunits() ),
SFVEC2F( end.x * m_settings.BiuTo3Dunits(), SFVEC2F( end.x * m_boardAdapter.BiuTo3Dunits(),
-end.y * m_settings.BiuTo3Dunits() ), -end.y * m_boardAdapter.BiuTo3Dunits() ),
width * m_settings.BiuTo3Dunits(), width * m_boardAdapter.BiuTo3Dunits(),
*aPad ); *aPad );
CROUNDSEGMENT2D *outerSeg = new CROUNDSEGMENT2D( CROUNDSEGMENT2D *outerSeg = new CROUNDSEGMENT2D(
SFVEC2F( start.x * m_settings.BiuTo3Dunits(), SFVEC2F( start.x * m_boardAdapter.BiuTo3Dunits(),
-start.y * m_settings.BiuTo3Dunits() ), -start.y * m_boardAdapter.BiuTo3Dunits() ),
SFVEC2F( end.x * m_settings.BiuTo3Dunits(), SFVEC2F( end.x * m_boardAdapter.BiuTo3Dunits(),
-end.y * m_settings.BiuTo3Dunits() ), -end.y * m_boardAdapter.BiuTo3Dunits() ),
( width + m_settings.GetCopperThicknessBIU() * 2 ) * ( width + m_boardAdapter.GetCopperThicknessBIU() * 2 ) *
m_settings.BiuTo3Dunits(), m_boardAdapter.BiuTo3Dunits(),
*aPad ); *aPad );
// NOTE: the round segment width is the "diameter", so we double the thickness // NOTE: the round segment width is the "diameter", so we double the thickness
@ -1170,11 +1171,11 @@ void C3D_RENDER_RAYTRACING::insert3DPadHole( const D_PAD* aPad )
// Check if there are any other THT that intersects this hole // Check if there are any other THT that intersects this hole
// It will use the non inflated holes // It will use the non inflated holes
if( !m_settings.GetThroughHole_Inner().GetList().empty() ) if( !m_boardAdapter.GetThroughHole_Inner().GetList().empty() )
{ {
CONST_LIST_OBJECT2D intersectionList; CONST_LIST_OBJECT2D intersectionList;
m_settings.GetThroughHole_Inner().GetListObjectsIntersects( object2d_A->GetBBox(), m_boardAdapter.GetThroughHole_Inner().GetListObjectsIntersects( object2d_A->GetBBox(),
intersectionList ); intersectionList );
if( !intersectionList.empty() ) if( !intersectionList.empty() )
@ -1232,7 +1233,7 @@ void C3D_RENDER_RAYTRACING::add_3D_vias_and_pads_to_container()
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
// Insert vias holes (vertical cylinders) // Insert vias holes (vertical cylinders)
for( auto track : m_settings.GetBoard()->Tracks() ) for( auto track : m_boardAdapter.GetBoard()->Tracks() )
{ {
if( track->Type() == PCB_VIA_T ) if( track->Type() == PCB_VIA_T )
{ {
@ -1242,7 +1243,7 @@ void C3D_RENDER_RAYTRACING::add_3D_vias_and_pads_to_container()
} }
// Insert pads holes (vertical cylinders) // Insert pads holes (vertical cylinders)
for( auto module : m_settings.GetBoard()->Modules() ) for( auto module : m_boardAdapter.GetBoard()->Modules() )
{ {
for( auto pad : module->Pads() ) for( auto pad : module->Pads() )
if( pad->GetAttribute () != PAD_ATTRIB_HOLE_NOT_PLATED ) if( pad->GetAttribute () != PAD_ATTRIB_HOLE_NOT_PLATED )
@ -1256,20 +1257,20 @@ void C3D_RENDER_RAYTRACING::add_3D_vias_and_pads_to_container()
void C3D_RENDER_RAYTRACING::load_3D_models() void C3D_RENDER_RAYTRACING::load_3D_models()
{ {
// Go for all modules // Go for all modules
for( auto module : m_settings.GetBoard()->Modules() ) for( auto module : m_boardAdapter.GetBoard()->Modules() )
{ {
if( (!module->Models().empty() ) && if((!module->Models().empty() ) &&
m_settings.ShouldModuleBeDisplayed( (MODULE_ATTR_T)module->GetAttributes() ) ) m_boardAdapter.ShouldModuleBeDisplayed((MODULE_ATTR_T)module->GetAttributes() ) )
{ {
double zpos = m_settings.GetModulesZcoord3DIU( module->IsFlipped() ); double zpos = m_boardAdapter.GetModulesZcoord3DIU( module->IsFlipped() );
wxPoint pos = module->GetPosition(); wxPoint pos = module->GetPosition();
glm::mat4 moduleMatrix = glm::mat4( 1.0f ); glm::mat4 moduleMatrix = glm::mat4( 1.0f );
moduleMatrix = glm::translate( moduleMatrix, moduleMatrix = glm::translate( moduleMatrix,
SFVEC3F( pos.x * m_settings.BiuTo3Dunits(), SFVEC3F( pos.x * m_boardAdapter.BiuTo3Dunits(),
-pos.y * m_settings.BiuTo3Dunits(), -pos.y * m_boardAdapter.BiuTo3Dunits(),
zpos ) ); zpos ) );
if( module->GetOrientation() ) if( module->GetOrientation() )
@ -1292,7 +1293,7 @@ void C3D_RENDER_RAYTRACING::load_3D_models()
SFVEC3F( 0.0f, 0.0f, 1.0f ) ); SFVEC3F( 0.0f, 0.0f, 1.0f ) );
} }
const double modelunit_to_3d_units_factor = m_settings.BiuTo3Dunits() * const double modelunit_to_3d_units_factor = m_boardAdapter.BiuTo3Dunits() *
UNITS3D_TO_UNITSPCB; UNITS3D_TO_UNITSPCB;
moduleMatrix = glm::scale( moduleMatrix, moduleMatrix = glm::scale( moduleMatrix,
@ -1309,7 +1310,7 @@ void C3D_RENDER_RAYTRACING::load_3D_models()
{ {
// get it from cache // get it from cache
const S3DMODEL *modelPtr = const S3DMODEL *modelPtr =
m_settings.Get3DCacheManager()->GetModel( sM->m_Filename ); m_boardAdapter.Get3DCacheManager()->GetModel( sM->m_Filename );
// only add it if the return is not NULL // only add it if the return is not NULL
if( modelPtr ) if( modelPtr )
@ -1392,7 +1393,7 @@ void C3D_RENDER_RAYTRACING::add_3D_models( const S3DMODEL *a3DModel,
imat < a3DModel->m_MaterialsSize; imat < a3DModel->m_MaterialsSize;
++imat ) ++imat )
{ {
if( m_settings.MaterialModeGet() == MATERIAL_MODE::NORMAL ) if( m_boardAdapter.MaterialModeGet() == MATERIAL_MODE::NORMAL )
{ {
const SMATERIAL &material = a3DModel->m_Materials[imat]; const SMATERIAL &material = a3DModel->m_Materials[imat];
@ -1412,7 +1413,7 @@ void C3D_RENDER_RAYTRACING::add_3D_models( const S3DMODEL *a3DModel,
SFVEC3F ambient; SFVEC3F ambient;
if( m_settings.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) )
{ {
// apply a gain to the (dark) ambient colors // apply a gain to the (dark) ambient colors
@ -1440,7 +1441,7 @@ void C3D_RENDER_RAYTRACING::add_3D_models( const S3DMODEL *a3DModel,
material.m_Transparency, material.m_Transparency,
reflectionFactor ); reflectionFactor );
if( m_settings.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) ) if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ) )
{ {
// Guess material type and apply a normal perturbator // Guess material type and apply a normal perturbator
@ -1571,14 +1572,14 @@ void C3D_RENDER_RAYTRACING::add_3D_models( const S3DMODEL *a3DModel,
const SFVEC3F diffuseColor = const SFVEC3F diffuseColor =
a3DModel->m_Materials[mesh.m_MaterialIdx].m_Diffuse; a3DModel->m_Materials[mesh.m_MaterialIdx].m_Diffuse;
if( m_settings.MaterialModeGet() == MATERIAL_MODE::CAD_MODE ) if( m_boardAdapter.MaterialModeGet() == MATERIAL_MODE::CAD_MODE )
newTriangle->SetColor( ConvertSRGBToLinear( MaterialDiffuseToColorCAD( diffuseColor ) ) ); newTriangle->SetColor( ConvertSRGBToLinear( MaterialDiffuseToColorCAD( diffuseColor ) ) );
else else
newTriangle->SetColor( ConvertSRGBToLinear( diffuseColor ) ); newTriangle->SetColor( ConvertSRGBToLinear( diffuseColor ) );
} }
else else
{ {
if( m_settings.MaterialModeGet() == MATERIAL_MODE::CAD_MODE ) if( m_boardAdapter.MaterialModeGet() == MATERIAL_MODE::CAD_MODE )
newTriangle->SetColor( ConvertSRGBToLinear( MaterialDiffuseToColorCAD( mesh.m_Color[idx0] ) ), newTriangle->SetColor( ConvertSRGBToLinear( MaterialDiffuseToColorCAD( mesh.m_Color[idx0] ) ),
ConvertSRGBToLinear( MaterialDiffuseToColorCAD( mesh.m_Color[idx1] ) ), ConvertSRGBToLinear( MaterialDiffuseToColorCAD( mesh.m_Color[idx1] ) ),
ConvertSRGBToLinear( MaterialDiffuseToColorCAD( mesh.m_Color[idx2] ) ) ); ConvertSRGBToLinear( MaterialDiffuseToColorCAD( mesh.m_Color[idx2] ) ) );

103
3d-viewer/3d_rendering/3d_render_raytracing/c3d_render_raytracing.cpp
View File

@ -46,9 +46,9 @@
// convertLinearToSRGB // convertLinearToSRGB
//#include <glm/gtc/color_space.hpp> //#include <glm/gtc/color_space.hpp>
C3D_RENDER_RAYTRACING::C3D_RENDER_RAYTRACING( EDA_3D_SETTINGS &aSettings ) : C3D_RENDER_RAYTRACING::C3D_RENDER_RAYTRACING( BOARD_ADAPTER& aAdapter, CCAMERA& aCamera ) :
C3D_RENDER_BASE( aSettings ), C3D_RENDER_BASE( aAdapter, aCamera ),
m_postshader_ssao( aSettings.CameraGet() ) m_postshader_ssao( aCamera )
{ {
wxLogTrace( m_logTrace, wxT( "C3D_RENDER_RAYTRACING::C3D_RENDER_RAYTRACING" ) ); wxLogTrace( m_logTrace, wxT( "C3D_RENDER_RAYTRACING::C3D_RENDER_RAYTRACING" ) );
@ -213,7 +213,7 @@ bool C3D_RENDER_RAYTRACING::Redraw(
glDisable( GL_BLEND ); glDisable( GL_BLEND );
const bool was_camera_changed = m_settings.CameraGet().ParametersChanged(); const bool was_camera_changed = m_camera.ParametersChanged();
if( requestRedraw || aIsMoving || was_camera_changed ) if( requestRedraw || aIsMoving || was_camera_changed )
m_rt_render_state = RT_RENDER_STATE_MAX; // Set to an invalid state, m_rt_render_state = RT_RENDER_STATE_MAX; // Set to an invalid state,
@ -225,10 +225,10 @@ bool C3D_RENDER_RAYTRACING::Redraw(
{ {
// Set head light (camera view light) with the oposite direction of the camera // Set head light (camera view light) with the oposite direction of the camera
if( m_camera_light ) if( m_camera_light )
m_camera_light->SetDirection( -m_settings.CameraGet().GetDir() ); m_camera_light->SetDirection( -m_camera.GetDir() );
OGL_DrawBackground( SFVEC3F(m_settings.m_BgColorTop), OGL_DrawBackground( SFVEC3F( m_boardAdapter.m_BgColorTop),
SFVEC3F(m_settings.m_BgColorBot) ); SFVEC3F( m_boardAdapter.m_BgColorBot) );
// Bind PBO // Bind PBO
glBindBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, m_pboId ); glBindBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, m_pboId );
@ -274,8 +274,8 @@ bool C3D_RENDER_RAYTRACING::Redraw(
{ {
glClear( GL_COLOR_BUFFER_BIT ); glClear( GL_COLOR_BUFFER_BIT );
// Options if we want draw background instead // Options if we want draw background instead
//OGL_DrawBackground( SFVEC3F(m_settings.m_BgColorTop), //OGL_DrawBackground( SFVEC3F(m_boardAdapter.m_BgColorTop),
// SFVEC3F(m_settings.m_BgColorBot) ); // SFVEC3F(m_boardAdapter.m_BgColorBot) );
} }
glWindowPos2i( m_xoffset, m_yoffset ); glWindowPos2i( m_xoffset, m_yoffset );
@ -307,9 +307,9 @@ void C3D_RENDER_RAYTRACING::render( GLubyte *ptrPBO , REPORTER *aStatusTextRepor
restart_render_state(); restart_render_state();
if( m_camera_light ) if( m_camera_light )
m_camera_light->SetDirection( -m_settings.CameraGet().GetDir() ); m_camera_light->SetDirection( -m_camera.GetDir() );
if( m_settings.RenderEngineGet() == RENDER_ENGINE::OPENGL_LEGACY ) if( m_boardAdapter.RenderEngineGet() == RENDER_ENGINE::OPENGL_LEGACY )
{ {
// Set all pixels of PBO transparent (Alpha to 0) // Set all pixels of PBO transparent (Alpha to 0)
// This way it will draw the full buffer but only shows the updated ( // This way it will draw the full buffer but only shows the updated (
@ -325,8 +325,8 @@ void C3D_RENDER_RAYTRACING::render( GLubyte *ptrPBO , REPORTER *aStatusTextRepor
} }
} }
m_BgColorTop_LinearRGB = ConvertSRGBToLinear( (SFVEC3F)m_settings.m_BgColorTop ); m_BgColorTop_LinearRGB = ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_BgColorTop );
m_BgColorBot_LinearRGB = ConvertSRGBToLinear( (SFVEC3F)m_settings.m_BgColorBot ); m_BgColorBot_LinearRGB = ConvertSRGBToLinear( (SFVEC3F)m_boardAdapter.m_BgColorBot );
} }
switch( m_rt_render_state ) switch( m_rt_render_state )
@ -418,13 +418,11 @@ void C3D_RENDER_RAYTRACING::rt_render_tracing( GLubyte *ptrPBO ,
// or mark it as finished // or mark it as finished
if( m_nrBlocksRenderProgress >= m_blockPositions.size() ) if( m_nrBlocksRenderProgress >= m_blockPositions.size() )
{ {
if( m_settings.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) )
m_rt_render_state = RT_RENDER_STATE_POST_PROCESS_SHADE; m_rt_render_state = RT_RENDER_STATE_POST_PROCESS_SHADE;
else else
{
m_rt_render_state = RT_RENDER_STATE_FINISH; m_rt_render_state = RT_RENDER_STATE_FINISH;
} }
}
} }
#ifdef USE_SRGB_SPACE #ifdef USE_SRGB_SPACE
@ -462,8 +460,7 @@ SFVEC3F ConvertSRGBToLinear( const SFVEC3F &aSRGBcolor )
#endif #endif
void C3D_RENDER_RAYTRACING::rt_final_color( GLubyte *ptrPBO, void C3D_RENDER_RAYTRACING::rt_final_color( GLubyte *ptrPBO, const SFVEC3F &rgbColor,
const SFVEC3F &rgbColor,
bool applyColorSpaceConversion ) bool applyColorSpaceConversion )
{ {
@ -535,7 +532,7 @@ void C3D_RENDER_RAYTRACING::rt_trace_AA_packet( const SFVEC3F *aBgColorY,
const RAY *aRayPck, const RAY *aRayPck,
SFVEC3F *aOutHitColor ) SFVEC3F *aOutHitColor )
{ {
const bool is_testShadow = m_settings.GetFlag( FL_RENDER_RAYTRACING_SHADOWS ); const bool is_testShadow = m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_SHADOWS );
for( unsigned int y = 0, i = 0; y < RAYPACKET_DIM; ++y ) for( unsigned int y = 0, i = 0; y < RAYPACKET_DIM; ++y )
{ {
@ -665,10 +662,9 @@ void C3D_RENDER_RAYTRACING::rt_render_trace_block( GLubyte *ptrPBO ,
const SFVEC2I blockPosI = SFVEC2I( blockPos.x + m_xoffset, const SFVEC2I blockPosI = SFVEC2I( blockPos.x + m_xoffset,
blockPos.y + m_yoffset ); blockPos.y + m_yoffset );
RAYPACKET blockPacket( m_settings.CameraGet(), RAYPACKET blockPacket( m_camera, (SFVEC2F)blockPosI + SFVEC2F(DISP_FACTOR, DISP_FACTOR),
(SFVEC2F)blockPosI + SFVEC2F(DISP_FACTOR, DISP_FACTOR), SFVEC2F(DISP_FACTOR, DISP_FACTOR) /* Displacement random factor */ );
SFVEC2F(DISP_FACTOR, DISP_FACTOR) // Displacement random factor
);
HITINFO_PACKET hitPacket_X0Y0[RAYPACKET_RAYS_PER_PACKET]; HITINFO_PACKET hitPacket_X0Y0[RAYPACKET_RAYS_PER_PACKET];
@ -692,7 +688,7 @@ void C3D_RENDER_RAYTRACING::rt_render_trace_block( GLubyte *ptrPBO ,
{ {
// If block is empty then set shades and continue // If block is empty then set shades and continue
if( m_settings.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) )
{ {
for( unsigned int y = 0; y < RAYPACKET_DIM; ++y ) for( unsigned int y = 0; y < RAYPACKET_DIM; ++y )
{ {
@ -718,14 +714,13 @@ void C3D_RENDER_RAYTRACING::rt_render_trace_block( GLubyte *ptrPBO ,
// (as the final color will be computed on post processing) // (as the final color will be computed on post processing)
// but it is used for report progress // but it is used for report progress
const bool isFinalColor = !m_settings.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ); const bool isFinalColor = !m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING );
for( unsigned int y = 0; y < RAYPACKET_DIM; ++y ) for( unsigned int y = 0; y < RAYPACKET_DIM; ++y )
{ {
const SFVEC3F &outColor = bgColor[y]; const SFVEC3F &outColor = bgColor[y];
const unsigned int yConst = blockPos.x + const unsigned int yConst = blockPos.x + ( (y + blockPos.y) * m_realBufferSize.x);
( (y + blockPos.y) * m_realBufferSize.x);
for( unsigned int x = 0; x < RAYPACKET_DIM; ++x ) for( unsigned int x = 0; x < RAYPACKET_DIM; ++x )
{ {
@ -748,10 +743,10 @@ void C3D_RENDER_RAYTRACING::rt_render_trace_block( GLubyte *ptrPBO ,
rt_shades_packet( bgColor, rt_shades_packet( bgColor,
blockPacket.m_ray, blockPacket.m_ray,
hitPacket_X0Y0, hitPacket_X0Y0,
m_settings.GetFlag( FL_RENDER_RAYTRACING_SHADOWS ), m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_SHADOWS ),
hitColor_X0Y0 ); hitColor_X0Y0 );
if( m_settings.GetFlag( FL_RENDER_RAYTRACING_ANTI_ALIASING ) ) if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_ANTI_ALIASING ) )
{ {
SFVEC3F hitColor_AA_X1Y1[RAYPACKET_RAYS_PER_PACKET]; SFVEC3F hitColor_AA_X1Y1[RAYPACKET_RAYS_PER_PACKET];
@ -761,10 +756,8 @@ void C3D_RENDER_RAYTRACING::rt_render_trace_block( GLubyte *ptrPBO ,
HITINFO_PACKET hitPacket_AA_X1Y1[RAYPACKET_RAYS_PER_PACKET]; HITINFO_PACKET hitPacket_AA_X1Y1[RAYPACKET_RAYS_PER_PACKET];
HITINFO_PACKET_init( hitPacket_AA_X1Y1 ); HITINFO_PACKET_init( hitPacket_AA_X1Y1 );
RAYPACKET blockPacket_AA_X1Y1( m_settings.CameraGet(), RAYPACKET blockPacket_AA_X1Y1( m_camera, (SFVEC2F)blockPosI + SFVEC2F(0.5f, 0.5f),
(SFVEC2F)blockPosI + SFVEC2F(0.5f, 0.5f), SFVEC2F(DISP_FACTOR, DISP_FACTOR) );
SFVEC2F(DISP_FACTOR, DISP_FACTOR) // Displacement random factor
);
if( !m_accelerator->Intersect( blockPacket_AA_X1Y1, hitPacket_AA_X1Y1 ) ) if( !m_accelerator->Intersect( blockPacket_AA_X1Y1, hitPacket_AA_X1Y1 ) )
{ {
@ -784,7 +777,7 @@ void C3D_RENDER_RAYTRACING::rt_render_trace_block( GLubyte *ptrPBO ,
rt_shades_packet( bgColor, rt_shades_packet( bgColor,
blockPacket_AA_X1Y1.m_ray, blockPacket_AA_X1Y1.m_ray,
hitPacket_AA_X1Y1, hitPacket_AA_X1Y1,
m_settings.GetFlag( FL_RENDER_RAYTRACING_SHADOWS ), m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_SHADOWS ),
hitColor_AA_X1Y1 hitColor_AA_X1Y1
); );
} }
@ -807,17 +800,17 @@ void C3D_RENDER_RAYTRACING::rt_render_trace_block( GLubyte *ptrPBO ,
RAY blockRayPck_AA_X0Y1[RAYPACKET_RAYS_PER_PACKET]; RAY blockRayPck_AA_X0Y1[RAYPACKET_RAYS_PER_PACKET];
RAY blockRayPck_AA_X1Y1_half[RAYPACKET_RAYS_PER_PACKET]; RAY blockRayPck_AA_X1Y1_half[RAYPACKET_RAYS_PER_PACKET];
RAYPACKET_InitRays_with2DDisplacement( m_settings.CameraGet(), RAYPACKET_InitRays_with2DDisplacement( m_camera,
(SFVEC2F)blockPosI + SFVEC2F(0.5f - DISP_FACTOR, DISP_FACTOR), (SFVEC2F)blockPosI + SFVEC2F(0.5f - DISP_FACTOR, DISP_FACTOR),
SFVEC2F(DISP_FACTOR, DISP_FACTOR), // Displacement random factor SFVEC2F(DISP_FACTOR, DISP_FACTOR), // Displacement random factor
blockRayPck_AA_X1Y0 ); blockRayPck_AA_X1Y0 );
RAYPACKET_InitRays_with2DDisplacement( m_settings.CameraGet(), RAYPACKET_InitRays_with2DDisplacement( m_camera,
(SFVEC2F)blockPosI + SFVEC2F(DISP_FACTOR, 0.5f - DISP_FACTOR), (SFVEC2F)blockPosI + SFVEC2F(DISP_FACTOR, 0.5f - DISP_FACTOR),
SFVEC2F(DISP_FACTOR, DISP_FACTOR), // Displacement random factor SFVEC2F(DISP_FACTOR, DISP_FACTOR), // Displacement random factor
blockRayPck_AA_X0Y1 ); blockRayPck_AA_X0Y1 );
RAYPACKET_InitRays_with2DDisplacement( m_settings.CameraGet(), RAYPACKET_InitRays_with2DDisplacement( m_camera,
(SFVEC2F)blockPosI + SFVEC2F(0.25f - DISP_FACTOR, 0.25f - DISP_FACTOR), (SFVEC2F)blockPosI + SFVEC2F(0.25f - DISP_FACTOR, 0.25f - DISP_FACTOR),
SFVEC2F(DISP_FACTOR, DISP_FACTOR), // Displacement random factor SFVEC2F(DISP_FACTOR, DISP_FACTOR), // Displacement random factor
blockRayPck_AA_X1Y1_half ); blockRayPck_AA_X1Y1_half );
@ -858,7 +851,7 @@ void C3D_RENDER_RAYTRACING::rt_render_trace_block( GLubyte *ptrPBO ,
const uint32_t ptrInc = (m_realBufferSize.x - RAYPACKET_DIM) * 4; const uint32_t ptrInc = (m_realBufferSize.x - RAYPACKET_DIM) * 4;
if( m_settings.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) )
{ {
SFVEC2I bPos; SFVEC2I bPos;
bPos.y = blockPos.y; bPos.y = blockPos.y;
@ -918,7 +911,7 @@ void C3D_RENDER_RAYTRACING::rt_render_post_process_shade( GLubyte *ptrPBO,
{ {
(void)ptrPBO; // unused (void)ptrPBO; // unused
if( m_settings.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) )
{ {
if( aStatusTextReporter ) if( aStatusTextReporter )
aStatusTextReporter->Report( _("Rendering: Post processing shader") ); aStatusTextReporter->Report( _("Rendering: Post processing shader") );
@ -969,7 +962,7 @@ void C3D_RENDER_RAYTRACING::rt_render_post_process_blur_finish( GLubyte *ptrPBO,
{ {
(void)aStatusTextReporter; //unused (void)aStatusTextReporter; //unused
if( m_settings.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) if( m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) )
{ {
// Now blurs the shader result and compute the final color // Now blurs the shader result and compute the final color
std::atomic<size_t> nextBlock( 0 ); std::atomic<size_t> nextBlock( 0 );
@ -1105,16 +1098,16 @@ void C3D_RENDER_RAYTRACING::render_preview( GLubyte *ptrPBO )
const SFVEC2I windowsPos = SFVEC2I( windowPosUI.x + m_xoffset, const SFVEC2I windowsPos = SFVEC2I( windowPosUI.x + m_xoffset,
windowPosUI.y + m_yoffset ); windowPosUI.y + m_yoffset );
RAYPACKET blockPacket( m_settings.CameraGet(), windowsPos, 4 ); RAYPACKET blockPacket( m_camera, windowsPos, 4 );
HITINFO_PACKET hitPacket[RAYPACKET_RAYS_PER_PACKET]; HITINFO_PACKET hitPacket[RAYPACKET_RAYS_PER_PACKET];
// Initialize hitPacket with a "not hit" information // Initialize hitPacket with a "not hit" information
for( unsigned int i = 0; i < RAYPACKET_RAYS_PER_PACKET; ++i ) for( HITINFO_PACKET& packet : hitPacket )
{ {
hitPacket[i].m_HitInfo.m_tHit = std::numeric_limits<float>::infinity(); packet.m_HitInfo.m_tHit = std::numeric_limits<float>::infinity();
hitPacket[i].m_HitInfo.m_acc_node_info = 0; packet.m_HitInfo.m_acc_node_info = 0;
hitPacket[i].m_hitresult = false; packet.m_hitresult = false;
} }
// Intersect packet block // Intersect packet block
@ -1129,8 +1122,8 @@ void C3D_RENDER_RAYTRACING::render_preview( GLubyte *ptrPBO )
{ {
const float posYfactor = (float)(windowsPos.y + y * 4.0f) / (float)m_windowSize.y; const float posYfactor = (float)(windowsPos.y + y * 4.0f) / (float)m_windowSize.y;
bgColor[y] = (SFVEC3F)m_settings.m_BgColorTop * SFVEC3F(posYfactor) + bgColor[y] = (SFVEC3F)m_boardAdapter.m_BgColorTop * SFVEC3F( posYfactor) +
(SFVEC3F)m_settings.m_BgColorBot * ( SFVEC3F(1.0f) - SFVEC3F(posYfactor) ); (SFVEC3F)m_boardAdapter.m_BgColorBot * ( SFVEC3F( 1.0f) - SFVEC3F( posYfactor) );
} }
CCOLORRGB hitColorShading[RAYPACKET_RAYS_PER_PACKET]; CCOLORRGB hitColorShading[RAYPACKET_RAYS_PER_PACKET];
@ -1728,7 +1721,7 @@ SFVEC3F C3D_RENDER_RAYTRACING::shadeHit( const SFVEC3F &aBgColor,
SFVEC3F hitPoint = aHitInfo.m_HitPoint; SFVEC3F hitPoint = aHitInfo.m_HitPoint;
if( !m_isPreview ) if( !m_isPreview )
hitPoint += aHitInfo.m_HitNormal * m_settings.GetNonCopperLayerThickness3DU() * 1.2f; hitPoint += aHitInfo.m_HitNormal * m_boardAdapter.GetNonCopperLayerThickness3DU() * 1.2f;
const CMATERIAL *objMaterial = aHitInfo.pHitObject->GetMaterial(); const CMATERIAL *objMaterial = aHitInfo.pHitObject->GetMaterial();
wxASSERT( objMaterial != NULL ); wxASSERT( objMaterial != NULL );
@ -1740,7 +1733,7 @@ SFVEC3F C3D_RENDER_RAYTRACING::shadeHit( const SFVEC3F &aBgColor,
const LIST_LIGHT &lightList = m_lights.GetList(); const LIST_LIGHT &lightList = m_lights.GetList();
#if USE_EXPERIMENTAL_SOFT_SHADOWS #if USE_EXPERIMENTAL_SOFT_SHADOWS
const bool is_aa_enabled = m_settings.GetFlag( FL_RENDER_RAYTRACING_ANTI_ALIASING ) && const bool is_aa_enabled = m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_ANTI_ALIASING ) &&
(!m_isPreview); (!m_isPreview);
#endif #endif
@ -1766,7 +1759,7 @@ SFVEC3F C3D_RENDER_RAYTRACING::shadeHit( const SFVEC3F &aBgColor,
/* /*
if( (!m_isPreview) && if( (!m_isPreview) &&
// Little hack to make randomness to the shading and shadows // Little hack to make randomness to the shading and shadows
m_settings.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) )
vectorToLight = glm::normalize( vectorToLight + vectorToLight = glm::normalize( vectorToLight +
UniformRandomHemisphereDirection() * 0.1f ); UniformRandomHemisphereDirection() * 0.1f );
*/ */
@ -1789,7 +1782,7 @@ SFVEC3F C3D_RENDER_RAYTRACING::shadeHit( const SFVEC3F &aBgColor,
(aRecursiveLevel > 0) || (aRecursiveLevel > 0) ||
// Only use soft shadows if using post processing // Only use soft shadows if using post processing
(!m_settings.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) (!m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) )
) )
{ {
#endif #endif
@ -1835,7 +1828,7 @@ SFVEC3F C3D_RENDER_RAYTRACING::shadeHit( const SFVEC3F &aBgColor,
shadow_att_factor_sum += shadow_att_factor_light; shadow_att_factor_sum += shadow_att_factor_light;
} }
if( !m_settings.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) ) if( !m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) )
{ {
outColor += objMaterial->Shade( aRay, outColor += objMaterial->Shade( aRay,
aHitInfo, aHitInfo,
@ -1894,7 +1887,7 @@ SFVEC3F C3D_RENDER_RAYTRACING::shadeHit( const SFVEC3F &aBgColor,
if( !aIsInsideObject && if( !aIsInsideObject &&
(objMaterial->GetReflection() > 0.0f) && (objMaterial->GetReflection() > 0.0f) &&
m_settings.GetFlag( FL_RENDER_RAYTRACING_REFLECTIONS ) ) m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_REFLECTIONS ) )
{ {
const unsigned int reflection_number_of_samples = objMaterial->GetNrReflectionsSamples(); const unsigned int reflection_number_of_samples = objMaterial->GetNrReflectionsSamples();
@ -1941,8 +1934,8 @@ SFVEC3F C3D_RENDER_RAYTRACING::shadeHit( const SFVEC3F &aBgColor,
// Refractions // Refractions
// ///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
if( (objMaterial->GetTransparency() > 0.0f) && if((objMaterial->GetTransparency() > 0.0f) &&
m_settings.GetFlag( FL_RENDER_RAYTRACING_REFRACTIONS ) ) m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_REFRACTIONS ) )
{ {
const float airIndex = 1.000293f; const float airIndex = 1.000293f;
const float glassIndex = 1.49f; const float glassIndex = 1.49f;

2
3d-viewer/3d_rendering/3d_render_raytracing/c3d_render_raytracing.h
View File

@ -59,7 +59,7 @@ typedef enum
class C3D_RENDER_RAYTRACING : public C3D_RENDER_BASE class C3D_RENDER_RAYTRACING : public C3D_RENDER_BASE
{ {
public: public:
explicit C3D_RENDER_RAYTRACING( EDA_3D_SETTINGS &aSettings ); explicit C3D_RENDER_RAYTRACING( BOARD_ADAPTER& aAdapter, CCAMERA& aCamera );
~C3D_RENDER_RAYTRACING(); ~C3D_RENDER_RAYTRACING();

5
3d-viewer/3d_rendering/c3d_render_base.cpp
View File

@ -40,8 +40,9 @@
const wxChar * C3D_RENDER_BASE::m_logTrace = wxT( "KI_TRACE_3D_RENDER" ); const wxChar * C3D_RENDER_BASE::m_logTrace = wxT( "KI_TRACE_3D_RENDER" );
C3D_RENDER_BASE::C3D_RENDER_BASE( EDA_3D_SETTINGS &aSettings) : C3D_RENDER_BASE::C3D_RENDER_BASE( BOARD_ADAPTER& aBoardAdapter, CCAMERA& aCamera ) :
m_settings( aSettings ) m_boardAdapter( aBoardAdapter ),
m_camera( aCamera )
{ {
wxLogTrace( m_logTrace, wxT( "C3D_RENDER_BASE::C3D_RENDER_BASE" ) ); wxLogTrace( m_logTrace, wxT( "C3D_RENDER_BASE::C3D_RENDER_BASE" ) );
m_is_opengl_initialized = false; m_is_opengl_initialized = false;

8
3d-viewer/3d_rendering/c3d_render_base.h
View File

@ -32,7 +32,7 @@
#include <pcb_base_frame.h> #include <pcb_base_frame.h>
#include "3d_canvas/3d_settings.h" #include "3d_canvas/board_adapter.h"
#include <reporter.h> #include <reporter.h>
#include <widgets/busy_indicator.h> #include <widgets/busy_indicator.h>
@ -47,7 +47,7 @@ class C3D_RENDER_BASE
// Operations // Operations
public: public:
explicit C3D_RENDER_BASE( EDA_3D_SETTINGS &aSettings ); explicit C3D_RENDER_BASE( BOARD_ADAPTER& aBoardAdapter, CCAMERA& aCamera );
virtual ~C3D_RENDER_BASE() = 0; virtual ~C3D_RENDER_BASE() = 0;
@ -107,7 +107,9 @@ protected:
std::unique_ptr<BUSY_INDICATOR> CreateBusyIndicator() const; std::unique_ptr<BUSY_INDICATOR> CreateBusyIndicator() const;
/// settings refrence in use for this render /// settings refrence in use for this render
EDA_3D_SETTINGS &m_settings; BOARD_ADAPTER& m_boardAdapter;
CCAMERA& m_camera;
/// flag if the opengl specific for this render was already initialized /// flag if the opengl specific for this render was already initialized
bool m_is_opengl_initialized; bool m_is_opengl_initialized;

38
3d-viewer/3d_viewer/3d_menubar.cpp
View File

@ -103,72 +103,72 @@ void EDA_3D_VIEWER::CreateMenuBar()
//clang-format off //clang-format off
auto raytracingCondition = [this]( const SELECTION& aSel ) auto raytracingCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.RenderEngineGet() != RENDER_ENGINE::OPENGL_LEGACY; return m_boardAdapter.RenderEngineGet() != RENDER_ENGINE::OPENGL_LEGACY;
}; };
auto NormalModeCondition = [this]( const SELECTION& aSel ) auto NormalModeCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.MaterialModeGet() == MATERIAL_MODE::NORMAL; return m_boardAdapter.MaterialModeGet() == MATERIAL_MODE::NORMAL;
}; };
auto DiffuseModeCondition = [this]( const SELECTION& aSel ) auto DiffuseModeCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.MaterialModeGet() == MATERIAL_MODE::DIFFUSE_ONLY; return m_boardAdapter.MaterialModeGet() == MATERIAL_MODE::DIFFUSE_ONLY;
}; };
auto CADModeCondition = [this]( const SELECTION& aSel ) auto CADModeCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.MaterialModeGet() == MATERIAL_MODE::CAD_MODE; return m_boardAdapter.MaterialModeGet() == MATERIAL_MODE::CAD_MODE;
}; };
auto copperThicknessCondition = [this]( const SELECTION& aSel ) auto copperThicknessCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS ); return m_boardAdapter.GetFlag( FL_RENDER_OPENGL_COPPER_THICKNESS );
}; };
auto boundingBoxesCondition = [this]( const SELECTION& aSel ) auto boundingBoxesCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GetFlag( FL_RENDER_OPENGL_SHOW_MODEL_BBOX ); return m_boardAdapter.GetFlag( FL_RENDER_OPENGL_SHOW_MODEL_BBOX );
}; };
auto renderShadowsCondition = [this]( const SELECTION& aSel ) auto renderShadowsCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GetFlag( FL_RENDER_RAYTRACING_SHADOWS ); return m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_SHADOWS );
}; };
auto proceduralTexturesCondition = [this]( const SELECTION& aSel ) auto proceduralTexturesCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES ); return m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES );
}; };
auto showFloorCondition = [this]( const SELECTION& aSel ) auto showFloorCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GetFlag( FL_RENDER_RAYTRACING_BACKFLOOR ); return m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_BACKFLOOR );
}; };
auto useRefractionsCondition = [this]( const SELECTION& aSel ) auto useRefractionsCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GetFlag( FL_RENDER_RAYTRACING_REFRACTIONS ); return m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_REFRACTIONS );
}; };
auto useReflectionsCondition = [this]( const SELECTION& aSel ) auto useReflectionsCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GetFlag( FL_RENDER_RAYTRACING_REFLECTIONS ); return m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_REFLECTIONS );
}; };
auto antiAliasingCondition = [this]( const SELECTION& aSel ) auto antiAliasingCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GetFlag( FL_RENDER_RAYTRACING_ANTI_ALIASING ); return m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_ANTI_ALIASING );
}; };
auto postProcessCondition = [this]( const SELECTION& aSel ) auto postProcessCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ); return m_boardAdapter.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING );
}; };
auto showAxesCondition = [this]( const SELECTION& aSel ) auto showAxesCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GetFlag( FL_AXIS ); return m_boardAdapter.GetFlag( FL_AXIS );
}; };
//clang-format on //clang-format on
@ -272,27 +272,27 @@ void EDA_3D_VIEWER::CreateMenuBar()
//clang-format off //clang-format off
auto noGridCondition = [this]( const SELECTION& aSel ) auto noGridCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GridGet() == GRID3D_TYPE::NONE; return m_boardAdapter.GridGet() == GRID3D_TYPE::NONE;
}; };
auto grid10mmCondition = [this]( const SELECTION& aSel ) auto grid10mmCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GridGet() == GRID3D_TYPE::GRID_10MM; return m_boardAdapter.GridGet() == GRID3D_TYPE::GRID_10MM;
}; };
auto grid5mmCondition = [this]( const SELECTION& aSel ) auto grid5mmCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GridGet() == GRID3D_TYPE::GRID_5MM; return m_boardAdapter.GridGet() == GRID3D_TYPE::GRID_5MM;
}; };
auto grid2p5mmCondition = [this]( const SELECTION& aSel ) auto grid2p5mmCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GridGet() == GRID3D_TYPE::GRID_2P5MM; return m_boardAdapter.GridGet() == GRID3D_TYPE::GRID_2P5MM;
}; };
auto grid_1mmCondition = [this]( const SELECTION& aSel ) auto grid_1mmCondition = [this]( const SELECTION& aSel )
{ {
return m_settings.GridGet() == GRID3D_TYPE::GRID_1MM; return m_boardAdapter.GridGet() == GRID3D_TYPE::GRID_1MM;
}; };
//clang-format on //clang-format on

2
3d-viewer/3d_viewer/3d_toolbar.cpp
View File

@ -102,7 +102,7 @@ void EDA_3D_VIEWER::ReCreateMainToolbar()
void EDA_3D_VIEWER::SyncToolbars() void EDA_3D_VIEWER::SyncToolbars()
{ {
bool isOrtho = m_settings.CameraGet().GetProjection() == PROJECTION_TYPE::ORTHO; bool isOrtho = m_currentCamera.GetProjection() == PROJECTION_TYPE::ORTHO;
m_mainToolBar->Toggle( EDA_3D_ACTIONS::toggleOrtho, isOrtho ); m_mainToolBar->Toggle( EDA_3D_ACTIONS::toggleOrtho, isOrtho );
m_mainToolBar->Refresh(); m_mainToolBar->Refresh();

12
3d-viewer/3d_viewer/dialogs/dialog_3D_view_option.cpp
View File

@ -24,7 +24,7 @@
#include "dialog_3D_view_option_base.h" #include "dialog_3D_view_option_base.h"
#include <3d_viewer/eda_3d_viewer.h> #include <3d_viewer/eda_3d_viewer.h>
#include <3d_canvas/3d_settings.h> #include <3d_canvas/board_adapter.h>
#include <bitmaps.h> #include <bitmaps.h>
class DIALOG_3D_VIEW_OPTIONS : public DIALOG_3D_VIEW_OPTIONS_BASE class DIALOG_3D_VIEW_OPTIONS : public DIALOG_3D_VIEW_OPTIONS_BASE
@ -34,7 +34,7 @@ public:
private: private:
EDA_3D_VIEWER* m_parent; EDA_3D_VIEWER* m_parent;
EDA_3D_SETTINGS& m_settings; BOARD_ADAPTER& m_settings;
void initDialog(); void initDialog();
@ -57,11 +57,11 @@ void EDA_3D_VIEWER::Install3DViewOptionDialog( wxCommandEvent& event )
} }
DIALOG_3D_VIEW_OPTIONS::DIALOG_3D_VIEW_OPTIONS( EDA_3D_VIEWER* parent ) DIALOG_3D_VIEW_OPTIONS::DIALOG_3D_VIEW_OPTIONS( EDA_3D_VIEWER* parent ) :
: DIALOG_3D_VIEW_OPTIONS_BASE( parent ), m_settings( *parent->GetSettings() ) DIALOG_3D_VIEW_OPTIONS_BASE( parent ),
m_parent( parent ),
m_settings( parent->GetAdapter() )
{ {
m_parent = parent;
initDialog(); initDialog();
m_sdbSizerOK->SetDefault(); m_sdbSizerOK->SetDefault();

131
3d-viewer/3d_viewer/eda_3d_viewer.cpp
View File

@ -89,6 +89,8 @@ EDA_3D_VIEWER::EDA_3D_VIEWER( KIWAY *aKiway, PCB_BASE_FRAME *aParent, const wxSt
wxDefaultSize, style, QUALIFIED_VIEWER3D_FRAMENAME( aParent ) ), wxDefaultSize, style, QUALIFIED_VIEWER3D_FRAMENAME( aParent ) ),
m_mainToolBar( nullptr ), m_mainToolBar( nullptr ),
m_canvas( nullptr ), m_canvas( nullptr ),
m_currentCamera( m_trackBallCamera ),
m_trackBallCamera( RANGE_SCALE_3D ),
m_toolDispatcher( nullptr ) m_toolDispatcher( nullptr )
{ {
wxLogTrace( m_logTrace, "EDA_3D_VIEWER::EDA_3D_VIEWER %s", aTitle ); wxLogTrace( m_logTrace, "EDA_3D_VIEWER::EDA_3D_VIEWER %s", aTitle );
@ -112,7 +114,8 @@ EDA_3D_VIEWER::EDA_3D_VIEWER( KIWAY *aKiway, PCB_BASE_FRAME *aParent, const wxSt
SetStatusWidths( arrayDim( status_dims ), status_dims ); SetStatusWidths( arrayDim( status_dims ), status_dims );
m_canvas = new EDA_3D_CANVAS( this, COGL_ATT_LIST::GetAttributesList( true ), m_canvas = new EDA_3D_CANVAS( this, COGL_ATT_LIST::GetAttributesList( true ),
aParent->GetBoard(), m_settings, Prj().Get3DCacheManager() ); aParent->GetBoard(), m_boardAdapter, m_currentCamera,
Prj().Get3DCacheManager() );
if( m_canvas ) if( m_canvas )
m_canvas->SetStatusBar( status_bar ); m_canvas->SetStatusBar( status_bar );
@ -236,10 +239,10 @@ void EDA_3D_VIEWER::Process_Special_Functions( wxCommandEvent &event )
return; return;
case ID_MENU3D_BGCOLOR_BOTTOM: case ID_MENU3D_BGCOLOR_BOTTOM:
if( Set3DColorFromUser( m_settings.m_BgColorBot, _( "Background Color, Bottom" ), if( Set3DColorFromUser( m_boardAdapter.m_BgColorBot, _( "Background Color, Bottom" ),
nullptr ) ) nullptr ) )
{ {
if( m_settings.RenderEngineGet() == RENDER_ENGINE::OPENGL_LEGACY ) if( m_boardAdapter.RenderEngineGet() == RENDER_ENGINE::OPENGL_LEGACY )
m_canvas->Request_refresh(); m_canvas->Request_refresh();
else else
NewDisplay( true ); NewDisplay( true );
@ -247,9 +250,9 @@ void EDA_3D_VIEWER::Process_Special_Functions( wxCommandEvent &event )
return; return;
case ID_MENU3D_BGCOLOR_TOP: case ID_MENU3D_BGCOLOR_TOP:
if( Set3DColorFromUser( m_settings.m_BgColorTop, _( "Background Color, Top" ), nullptr ) ) if( Set3DColorFromUser( m_boardAdapter.m_BgColorTop, _( "Background Color, Top" ), nullptr ) )
{ {
if( m_settings.RenderEngineGet() == RENDER_ENGINE::OPENGL_LEGACY ) if( m_boardAdapter.RenderEngineGet() == RENDER_ENGINE::OPENGL_LEGACY )
m_canvas->Request_refresh(); m_canvas->Request_refresh();
else else
NewDisplay( true ); NewDisplay( true );
@ -282,17 +285,17 @@ void EDA_3D_VIEWER::Process_Special_Functions( wxCommandEvent &event )
break; break;
case ID_MENU3D_FL_RENDER_MATERIAL_MODE_NORMAL: case ID_MENU3D_FL_RENDER_MATERIAL_MODE_NORMAL:
m_settings.MaterialModeSet( MATERIAL_MODE::NORMAL ); m_boardAdapter.MaterialModeSet( MATERIAL_MODE::NORMAL );
NewDisplay( true ); NewDisplay( true );
return; return;
case ID_MENU3D_FL_RENDER_MATERIAL_MODE_DIFFUSE_ONLY: case ID_MENU3D_FL_RENDER_MATERIAL_MODE_DIFFUSE_ONLY:
m_settings.MaterialModeSet( MATERIAL_MODE::DIFFUSE_ONLY ); m_boardAdapter.MaterialModeSet( MATERIAL_MODE::DIFFUSE_ONLY );
NewDisplay( true ); NewDisplay( true );
return; return;
case ID_MENU3D_FL_RENDER_MATERIAL_MODE_CAD_MODE: case ID_MENU3D_FL_RENDER_MATERIAL_MODE_CAD_MODE:
m_settings.MaterialModeSet( MATERIAL_MODE::CAD_MODE ); m_boardAdapter.MaterialModeSet( MATERIAL_MODE::CAD_MODE );
NewDisplay( true ); NewDisplay( true );
return; return;
@ -318,18 +321,18 @@ void EDA_3D_VIEWER::Process_Special_Functions( wxCommandEvent &event )
void EDA_3D_VIEWER::OnRenderEngineSelection( wxCommandEvent &event ) void EDA_3D_VIEWER::OnRenderEngineSelection( wxCommandEvent &event )
{ {
const RENDER_ENGINE old_engine = m_settings.RenderEngineGet(); const RENDER_ENGINE old_engine = m_boardAdapter.RenderEngineGet();
if( old_engine == RENDER_ENGINE::OPENGL_LEGACY ) if( old_engine == RENDER_ENGINE::OPENGL_LEGACY )
m_settings.RenderEngineSet( RENDER_ENGINE::RAYTRACING ); m_boardAdapter.RenderEngineSet( RENDER_ENGINE::RAYTRACING );
else else
m_settings.RenderEngineSet( RENDER_ENGINE::OPENGL_LEGACY ); m_boardAdapter.RenderEngineSet( RENDER_ENGINE::OPENGL_LEGACY );
wxLogTrace( m_logTrace, "EDA_3D_VIEWER::OnRenderEngineSelection type %s ", wxLogTrace( m_logTrace, "EDA_3D_VIEWER::OnRenderEngineSelection type %s ",
( m_settings.RenderEngineGet() == RENDER_ENGINE::RAYTRACING ) ? "Ray Trace" : ( m_boardAdapter.RenderEngineGet() == RENDER_ENGINE::RAYTRACING ) ? "Ray Trace" :
"OpenGL Legacy" ); "OpenGL Legacy" );
if( old_engine != m_settings.RenderEngineGet() ) if( old_engine != m_boardAdapter.RenderEngineGet() )
RenderEngineChanged(); RenderEngineChanged();
} }
@ -339,7 +342,7 @@ void EDA_3D_VIEWER::OnDisableRayTracing( wxCommandEvent& aEvent )
wxLogTrace( m_logTrace, "EDA_3D_VIEWER::%s disabling ray tracing.", __WXFUNCTION__ ); wxLogTrace( m_logTrace, "EDA_3D_VIEWER::%s disabling ray tracing.", __WXFUNCTION__ );
m_disable_ray_tracing = true; m_disable_ray_tracing = true;
m_settings.RenderEngineSet( RENDER_ENGINE::OPENGL_LEGACY ); m_boardAdapter.RenderEngineSet( RENDER_ENGINE::OPENGL_LEGACY );
} }
@ -390,19 +393,19 @@ void EDA_3D_VIEWER::LoadSettings( APP_SETTINGS_BASE *aCfg )
aTarget.b = aColor.b; aTarget.b = aColor.b;
}; };
set_color( colors->GetColor( LAYER_3D_BACKGROUND_BOTTOM ), m_settings.m_BgColorBot ); set_color( colors->GetColor( LAYER_3D_BACKGROUND_BOTTOM ), m_boardAdapter.m_BgColorBot );
set_color( colors->GetColor( LAYER_3D_BACKGROUND_TOP ), m_settings.m_BgColorTop ); set_color( colors->GetColor( LAYER_3D_BACKGROUND_TOP ), m_boardAdapter.m_BgColorTop );
set_color( colors->GetColor( LAYER_3D_BOARD ), m_settings.m_BoardBodyColor ); set_color( colors->GetColor( LAYER_3D_BOARD ), m_boardAdapter.m_BoardBodyColor );
set_color( colors->GetColor( LAYER_3D_COPPER ), m_settings.m_CopperColor ); set_color( colors->GetColor( LAYER_3D_COPPER ), m_boardAdapter.m_CopperColor );
set_color( colors->GetColor( LAYER_3D_SILKSCREEN_BOTTOM ), m_settings.m_SilkScreenColorBot ); set_color( colors->GetColor( LAYER_3D_SILKSCREEN_BOTTOM ), m_boardAdapter.m_SilkScreenColorBot );
set_color( colors->GetColor( LAYER_3D_SILKSCREEN_TOP ), m_settings.m_SilkScreenColorTop ); set_color( colors->GetColor( LAYER_3D_SILKSCREEN_TOP ), m_boardAdapter.m_SilkScreenColorTop );
set_color( colors->GetColor( LAYER_3D_SOLDERMASK ), m_settings.m_SolderMaskColorBot ); set_color( colors->GetColor( LAYER_3D_SOLDERMASK ), m_boardAdapter.m_SolderMaskColorBot );
set_color( colors->GetColor( LAYER_3D_SOLDERMASK ), m_settings.m_SolderMaskColorTop ); set_color( colors->GetColor( LAYER_3D_SOLDERMASK ), m_boardAdapter.m_SolderMaskColorTop );
set_color( colors->GetColor( LAYER_3D_SOLDERPASTE ), m_settings.m_SolderPasteColor ); set_color( colors->GetColor( LAYER_3D_SOLDERPASTE ), m_boardAdapter.m_SolderPasteColor );
if( cfg ) if( cfg )
{ {
#define TRANSER_SETTING( flag, field ) m_settings.SetFlag( flag, cfg->m_Render.field ) #define TRANSER_SETTING( flag, field ) m_boardAdapter.SetFlag( flag, cfg->m_Render.field )
TRANSER_SETTING( FL_USE_REALISTIC_MODE, realistic ); TRANSER_SETTING( FL_USE_REALISTIC_MODE, realistic );
TRANSER_SETTING( FL_SUBTRACT_MASK_FROM_SILK, subtract_mask_from_silk ); TRANSER_SETTING( FL_SUBTRACT_MASK_FROM_SILK, subtract_mask_from_silk );
@ -433,15 +436,15 @@ void EDA_3D_VIEWER::LoadSettings( APP_SETTINGS_BASE *aCfg )
TRANSER_SETTING( FL_ECO, show_eco ); TRANSER_SETTING( FL_ECO, show_eco );
TRANSER_SETTING( FL_SHOW_BOARD_BODY, show_board_body ); TRANSER_SETTING( FL_SHOW_BOARD_BODY, show_board_body );
m_settings.GridSet( static_cast<GRID3D_TYPE>( cfg->m_Render.grid_type ) ); m_boardAdapter.GridSet( static_cast<GRID3D_TYPE>( cfg->m_Render.grid_type ) );
RENDER_ENGINE engine = static_cast<RENDER_ENGINE>( cfg->m_Render.engine ); RENDER_ENGINE engine = static_cast<RENDER_ENGINE>( cfg->m_Render.engine );
wxLogTrace( m_logTrace, engine == RENDER_ENGINE::RAYTRACING ? wxLogTrace( m_logTrace, engine == RENDER_ENGINE::RAYTRACING ?
"EDA_3D_VIEWER::LoadSettings render setting Ray Trace" : "EDA_3D_VIEWER::LoadSettings render setting Ray Trace" :
"EDA_3D_VIEWER::LoadSettings render setting OpenGL" ); "EDA_3D_VIEWER::LoadSettings render setting OpenGL" );
m_settings.RenderEngineSet( engine ); m_boardAdapter.RenderEngineSet( engine );
m_settings.MaterialModeSet( static_cast<MATERIAL_MODE>( cfg->m_Render.material_mode ) ); m_boardAdapter.MaterialModeSet( static_cast<MATERIAL_MODE>( cfg->m_Render.material_mode ) );
#undef TRANSFER_SETTING #undef TRANSFER_SETTING
} }
@ -463,26 +466,26 @@ void EDA_3D_VIEWER::SaveSettings( APP_SETTINGS_BASE *aCfg )
colors->SetColor( aTarget, COLOR4D( aSource.r, aSource.g, aSource.b, 1.0 ) ); colors->SetColor( aTarget, COLOR4D( aSource.r, aSource.g, aSource.b, 1.0 ) );
}; };
save_color( m_settings.m_BgColorBot, LAYER_3D_BACKGROUND_BOTTOM ); save_color( m_boardAdapter.m_BgColorBot, LAYER_3D_BACKGROUND_BOTTOM );
save_color( m_settings.m_BgColorTop, LAYER_3D_BACKGROUND_TOP ); save_color( m_boardAdapter.m_BgColorTop, LAYER_3D_BACKGROUND_TOP );
save_color( m_settings.m_BoardBodyColor, LAYER_3D_BOARD ); save_color( m_boardAdapter.m_BoardBodyColor, LAYER_3D_BOARD );
save_color( m_settings.m_CopperColor, LAYER_3D_COPPER ); save_color( m_boardAdapter.m_CopperColor, LAYER_3D_COPPER );
save_color( m_settings.m_SilkScreenColorBot, LAYER_3D_SILKSCREEN_BOTTOM ); save_color( m_boardAdapter.m_SilkScreenColorBot, LAYER_3D_SILKSCREEN_BOTTOM );
save_color( m_settings.m_SilkScreenColorTop, LAYER_3D_SILKSCREEN_TOP ); save_color( m_boardAdapter.m_SilkScreenColorTop, LAYER_3D_SILKSCREEN_TOP );
save_color( m_settings.m_SolderMaskColorTop, LAYER_3D_SOLDERMASK ); save_color( m_boardAdapter.m_SolderMaskColorTop, LAYER_3D_SOLDERMASK );
save_color( m_settings.m_SolderPasteColor, LAYER_3D_SOLDERPASTE ); save_color( m_boardAdapter.m_SolderPasteColor, LAYER_3D_SOLDERPASTE );
wxLogTrace( m_logTrace, m_settings.RenderEngineGet() == RENDER_ENGINE::RAYTRACING ? wxLogTrace( m_logTrace, m_boardAdapter.RenderEngineGet() == RENDER_ENGINE::RAYTRACING ?
"EDA_3D_VIEWER::SaveSettings render setting Ray Trace" : "EDA_3D_VIEWER::SaveSettings render setting Ray Trace" :
"EDA_3D_VIEWER::SaveSettings render setting OpenGL" ); "EDA_3D_VIEWER::SaveSettings render setting OpenGL" );
if( cfg ) if( cfg )
{ {
#define TRANSFER_SETTING( field, flag ) cfg->m_Render.field = m_settings.GetFlag( flag ) #define TRANSFER_SETTING( field, flag ) cfg->m_Render.field = m_boardAdapter.GetFlag( flag )
cfg->m_Render.engine = static_cast<int>( m_settings.RenderEngineGet() ); cfg->m_Render.engine = static_cast<int>( m_boardAdapter.RenderEngineGet() );
cfg->m_Render.grid_type = static_cast<int>( m_settings.GridGet() ); cfg->m_Render.grid_type = static_cast<int>( m_boardAdapter.GridGet() );
cfg->m_Render.material_mode = static_cast<int>( m_settings.MaterialModeGet() ); cfg->m_Render.material_mode = static_cast<int>( m_boardAdapter.MaterialModeGet() );
TRANSFER_SETTING( opengl_copper_thickness, FL_RENDER_OPENGL_COPPER_THICKNESS ); 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_show_model_bbox, FL_RENDER_OPENGL_SHOW_MODEL_BBOX );
@ -548,24 +551,24 @@ void EDA_3D_VIEWER::SynchroniseColoursWithBoard()
switch( stckpItem->GetBrdLayerId() ) switch( stckpItem->GetBrdLayerId() )
{ {
case F_SilkS: case F_SilkS:
m_settings.m_SilkScreenColorTop.r = color.Red() / 255.0; m_boardAdapter.m_SilkScreenColorTop.r = color.Red() / 255.0;
m_settings.m_SilkScreenColorTop.g = color.Green() / 255.0; m_boardAdapter.m_SilkScreenColorTop.g = color.Green() / 255.0;
m_settings.m_SilkScreenColorTop.b = color.Blue() / 255.0; m_boardAdapter.m_SilkScreenColorTop.b = color.Blue() / 255.0;
break; break;
case B_SilkS: case B_SilkS:
m_settings.m_SilkScreenColorBot.r = color.Red() / 255.0; m_boardAdapter.m_SilkScreenColorBot.r = color.Red() / 255.0;
m_settings.m_SilkScreenColorBot.g = color.Green() / 255.0; m_boardAdapter.m_SilkScreenColorBot.g = color.Green() / 255.0;
m_settings.m_SilkScreenColorBot.b = color.Blue() / 255.0; m_boardAdapter.m_SilkScreenColorBot.b = color.Blue() / 255.0;
break; break;
case F_Mask: case F_Mask:
m_settings.m_SolderMaskColorTop.r = color.Red() / 255.0; m_boardAdapter.m_SolderMaskColorTop.r = color.Red() / 255.0;
m_settings.m_SolderMaskColorTop.g = color.Green() / 255.0; m_boardAdapter.m_SolderMaskColorTop.g = color.Green() / 255.0;
m_settings.m_SolderMaskColorTop.b = color.Blue() / 255.0; m_boardAdapter.m_SolderMaskColorTop.b = color.Blue() / 255.0;
break; break;
case B_Mask: case B_Mask:
m_settings.m_SolderMaskColorBot.r = color.Red() / 255.0; m_boardAdapter.m_SolderMaskColorBot.r = color.Red() / 255.0;
m_settings.m_SolderMaskColorBot.g = color.Green() / 255.0; m_boardAdapter.m_SolderMaskColorBot.g = color.Green() / 255.0;
m_settings.m_SolderMaskColorBot.b = color.Blue() / 255.0; m_boardAdapter.m_SolderMaskColorBot.b = color.Blue() / 255.0;
break; break;
default: default:
break; break;
@ -724,9 +727,9 @@ bool EDA_3D_VIEWER::Set3DSilkScreenColorFromUser()
colors.push_back( CUSTOM_COLOR_ITEM( 241.0/255.0, 241.0/255.0, 241.0/255.0, "White" ) ); colors.push_back( CUSTOM_COLOR_ITEM( 241.0/255.0, 241.0/255.0, 241.0/255.0, "White" ) );
colors.push_back( CUSTOM_COLOR_ITEM( 4.0/255.0, 18.0/255.0, 21.0/255.0, "Dark" ) ); colors.push_back( CUSTOM_COLOR_ITEM( 4.0/255.0, 18.0/255.0, 21.0/255.0, "Dark" ) );
if( Set3DColorFromUser( m_settings.m_SilkScreenColorTop, _( "Silkscreen Color" ), &colors ) ) if( Set3DColorFromUser( m_boardAdapter.m_SilkScreenColorTop, _( "Silkscreen Color" ), &colors ) )
{ {
m_settings.m_SilkScreenColorBot = m_settings.m_SilkScreenColorTop; m_boardAdapter.m_SilkScreenColorBot = m_boardAdapter.m_SilkScreenColorTop;
NewDisplay( true ); NewDisplay( true );
return true; return true;
} }
@ -754,9 +757,9 @@ bool EDA_3D_VIEWER::Set3DSolderMaskColorFromUser()
colors.push_back( CUSTOM_COLOR_ITEM( 119/255.0, 31/255.0, 91/255.0, "Purple" ) ); colors.push_back( CUSTOM_COLOR_ITEM( 119/255.0, 31/255.0, 91/255.0, "Purple" ) );
colors.push_back( CUSTOM_COLOR_ITEM( 32/255.0, 2/255.0, 53/255.0, "Purple Dark" ) ); colors.push_back( CUSTOM_COLOR_ITEM( 32/255.0, 2/255.0, 53/255.0, "Purple Dark" ) );
if( Set3DColorFromUser( m_settings.m_SolderMaskColorTop, _( "Solder Mask Color" ), &colors ) ) if( Set3DColorFromUser( m_boardAdapter.m_SolderMaskColorTop, _( "Solder Mask Color" ), &colors ) )
{ {
m_settings.m_SolderMaskColorBot = m_settings.m_SolderMaskColorTop; m_boardAdapter.m_SolderMaskColorBot = m_boardAdapter.m_SolderMaskColorTop;
NewDisplay( true ); NewDisplay( true );
return true; return true;
} }
@ -774,7 +777,7 @@ bool EDA_3D_VIEWER::Set3DCopperColorFromUser()
colors.push_back( CUSTOM_COLOR_ITEM( 213/255.0, 213/255.0, 213/255.0, "Silver" ) ); colors.push_back( CUSTOM_COLOR_ITEM( 213/255.0, 213/255.0, 213/255.0, "Silver" ) );
colors.push_back( CUSTOM_COLOR_ITEM( 160/255.0, 160/255.0, 160/255.0, "Tin" ) ); colors.push_back( CUSTOM_COLOR_ITEM( 160/255.0, 160/255.0, 160/255.0, "Tin" ) );
if( Set3DColorFromUser( m_settings.m_CopperColor, _( "Copper Color" ), &colors ) ) if( Set3DColorFromUser( m_boardAdapter.m_CopperColor, _( "Copper Color" ), &colors ) )
{ {
NewDisplay( true ); NewDisplay( true );
return true; return true;
@ -797,7 +800,7 @@ bool EDA_3D_VIEWER::Set3DBoardBodyColorFromUser()
colors.push_back( CUSTOM_COLOR_ITEM( 63/255.0, 126/255.0, 71/255.0, "green 1" ) ); colors.push_back( CUSTOM_COLOR_ITEM( 63/255.0, 126/255.0, 71/255.0, "green 1" ) );
colors.push_back( CUSTOM_COLOR_ITEM( 117/255.0, 122/255.0, 90/255.0, "green 2" ) ); colors.push_back( CUSTOM_COLOR_ITEM( 117/255.0, 122/255.0, 90/255.0, "green 2" ) );
if( Set3DColorFromUser( m_settings.m_BoardBodyColor, _( "Board Body Color" ), &colors ) ) if( Set3DColorFromUser( m_boardAdapter.m_BoardBodyColor, _( "Board Body Color" ), &colors ) )
{ {
NewDisplay( true ); NewDisplay( true );
return true; return true;
@ -815,7 +818,7 @@ bool EDA_3D_VIEWER::Set3DSolderPasteColorFromUser()
colors.push_back( CUSTOM_COLOR_ITEM( 213/255.0, 213/255.0, 213/255.0, "Silver" ) ); colors.push_back( CUSTOM_COLOR_ITEM( 213/255.0, 213/255.0, 213/255.0, "Silver" ) );
colors.push_back( CUSTOM_COLOR_ITEM( 90/255.0, 90/255.0, 90/255.0, "grey 2" ) ); colors.push_back( CUSTOM_COLOR_ITEM( 90/255.0, 90/255.0, 90/255.0, "grey 2" ) );
if( Set3DColorFromUser( m_settings.m_SolderPasteColor, _( "Solder Paste Color" ), &colors ) ) if( Set3DColorFromUser( m_boardAdapter.m_SolderPasteColor, _( "Solder Paste Color" ), &colors ) )
{ {
NewDisplay( true ); NewDisplay( true );
return true; return true;
@ -827,7 +830,7 @@ bool EDA_3D_VIEWER::Set3DSolderPasteColorFromUser()
void EDA_3D_VIEWER::OnUpdateUIEngine( wxUpdateUIEvent& aEvent ) void EDA_3D_VIEWER::OnUpdateUIEngine( wxUpdateUIEvent& aEvent )
{ {
aEvent.Check( m_settings.RenderEngineGet() != RENDER_ENGINE::OPENGL_LEGACY ); aEvent.Check( m_boardAdapter.RenderEngineGet() != RENDER_ENGINE::OPENGL_LEGACY );
} }
@ -837,15 +840,15 @@ void EDA_3D_VIEWER::OnUpdateUIMaterial( wxUpdateUIEvent& aEvent )
switch( aEvent.GetId() ) switch( aEvent.GetId() )
{ {
case ID_MENU3D_FL_RENDER_MATERIAL_MODE_NORMAL: case ID_MENU3D_FL_RENDER_MATERIAL_MODE_NORMAL:
aEvent.Check( m_settings.MaterialModeGet() == MATERIAL_MODE::NORMAL ); aEvent.Check( m_boardAdapter.MaterialModeGet() == MATERIAL_MODE::NORMAL );
break; break;
case ID_MENU3D_FL_RENDER_MATERIAL_MODE_DIFFUSE_ONLY: case ID_MENU3D_FL_RENDER_MATERIAL_MODE_DIFFUSE_ONLY:
aEvent.Check( m_settings.MaterialModeGet() == MATERIAL_MODE::DIFFUSE_ONLY ); aEvent.Check( m_boardAdapter.MaterialModeGet() == MATERIAL_MODE::DIFFUSE_ONLY );
break; break;
case ID_MENU3D_FL_RENDER_MATERIAL_MODE_CAD_MODE: case ID_MENU3D_FL_RENDER_MATERIAL_MODE_CAD_MODE:
aEvent.Check( m_settings.MaterialModeGet() == MATERIAL_MODE::CAD_MODE ); aEvent.Check( m_boardAdapter.MaterialModeGet() == MATERIAL_MODE::CAD_MODE );
break; break;
default: default:
@ -862,5 +865,5 @@ void EDA_3D_VIEWER::loadCommonSettings()
const DPI_SCALING dpi{ settings, this }; const DPI_SCALING dpi{ settings, this };
m_canvas->SetScaleFactor( dpi.GetScaleFactor() ); m_canvas->SetScaleFactor( dpi.GetScaleFactor() );
m_settings.SetFlag( FL_MOUSEWHEEL_PANNING, settings->m_Input.mousewheel_pan ); m_boardAdapter.SetFlag( FL_MOUSEWHEEL_PANNING, settings->m_Input.mousewheel_pan );
} }

19
3d-viewer/3d_viewer/eda_3d_viewer.h
View File

@ -32,8 +32,9 @@
#ifndef EDA_3D_VIEWER_H #ifndef EDA_3D_VIEWER_H
#define EDA_3D_VIEWER_H #define EDA_3D_VIEWER_H
#include "3d_canvas/3d_settings.h" #include "3d_canvas/board_adapter.h"
#include "../3d_canvas/eda_3d_canvas.h" #include "3d_canvas/eda_3d_canvas.h"
#include "3d_rendering/ctrack_ball.h"
#include <kiway_player.h> #include <kiway_player.h>
#include <wx/colourdata.h> #include <wx/colourdata.h>
#include <../common/dialogs/dialog_color_picker.h> // for CUSTOM_COLORS_LIST definition #include <../common/dialogs/dialog_color_picker.h> // for CUSTOM_COLORS_LIST definition
@ -62,7 +63,7 @@ enum EDA_3D_VIEWER_STATUSBAR
/** /**
* Create and handle a window for the 3d viewer connected to a Kiway and a pcbboard * Create and handle a window for the 3d viewer connected to a Kiway and a pcbboard
*/ */
class EDA_3D_VIEWER : public EDA_3D_SETTINGS_HOLDER, public KIWAY_PLAYER class EDA_3D_VIEWER : public EDA_3D_BOARD_HOLDER, public KIWAY_PLAYER
{ {
public: public:
@ -101,10 +102,8 @@ class EDA_3D_VIEWER : public EDA_3D_SETTINGS_HOLDER, public KIWAY_PLAYER
*/ */
void NewDisplay( bool aForceImmediateRedraw = false ); void NewDisplay( bool aForceImmediateRedraw = false );
/** BOARD_ADAPTER& GetAdapter() override { return m_boardAdapter; }
* @return current settings CCAMERA& GetCurrentCamera() override { return m_currentCamera; }
*/
EDA_3D_SETTINGS* GetSettings() override { return &m_settings; }
/** /**
* Get a SFVEC3D from a wx colour dialog * Get a SFVEC3D from a wx colour dialog
@ -155,7 +154,7 @@ class EDA_3D_VIEWER : public EDA_3D_SETTINGS_HOLDER, public KIWAY_PLAYER
void CommonSettingsChanged( bool aEnvVarsChanged ) override; void CommonSettingsChanged( bool aEnvVarsChanged ) override;
void SynchroniseColoursWithBoard( void ); void SynchroniseColoursWithBoard();
private: private:
/// Called when user press the File->Exit /// Called when user press the File->Exit
@ -209,7 +208,9 @@ private:
ACTION_TOOLBAR* m_mainToolBar; ACTION_TOOLBAR* m_mainToolBar;
EDA_3D_CANVAS* m_canvas; EDA_3D_CANVAS* m_canvas;
EDA_3D_SETTINGS m_settings; BOARD_ADAPTER m_boardAdapter;
CCAMERA& m_currentCamera;
CTRACK_BALL m_trackBallCamera;
TOOL_DISPATCHER* m_toolDispatcher; TOOL_DISPATCHER* m_toolDispatcher;

28
3d-viewer/3d_viewer/tools/3d_controller.cpp
View File

@ -68,12 +68,14 @@ void EDA_3D_CONTROLLER::Reset( RESET_REASON aReason )
if( holder ) if( holder )
{ {
m_canvas = dynamic_cast<EDA_3D_CANVAS*>( holder->GetToolCanvas() ); m_canvas = dynamic_cast<EDA_3D_CANVAS*>( holder->GetToolCanvas() );
m_settings = dynamic_cast<EDA_3D_SETTINGS_HOLDER*>( holder )->GetSettings(); m_boardAdapter = &dynamic_cast<EDA_3D_BOARD_HOLDER*>( holder )->GetAdapter();
m_camera = &dynamic_cast<EDA_3D_BOARD_HOLDER*>( holder )->GetCurrentCamera();
} }
else else
{ {
m_canvas = nullptr; m_canvas = nullptr;
m_settings = nullptr; m_boardAdapter = nullptr;
m_camera = nullptr;
} }
} }
@ -138,16 +140,16 @@ int EDA_3D_CONTROLLER::RotateView( const TOOL_EVENT& aEvent )
{ {
switch( aEvent.Parameter<intptr_t>() ) switch( aEvent.Parameter<intptr_t>() )
{ {
case ID_ROTATE3D_X_NEG: m_settings->CameraGet().RotateX( -glm::radians( ROT_ANGLE ) ); break; case ID_ROTATE3D_X_NEG: m_camera->RotateX( -glm::radians( ROT_ANGLE ) ); break;
case ID_ROTATE3D_X_POS: m_settings->CameraGet().RotateX( glm::radians( ROT_ANGLE ) ); break; case ID_ROTATE3D_X_POS: m_camera->RotateX( glm::radians( ROT_ANGLE ) ); break;
case ID_ROTATE3D_Y_NEG: m_settings->CameraGet().RotateY( -glm::radians( ROT_ANGLE ) ); break; case ID_ROTATE3D_Y_NEG: m_camera->RotateY( -glm::radians( ROT_ANGLE ) ); break;
case ID_ROTATE3D_Y_POS: m_settings->CameraGet().RotateY( glm::radians( ROT_ANGLE ) ); break; case ID_ROTATE3D_Y_POS: m_camera->RotateY( glm::radians( ROT_ANGLE ) ); break;
case ID_ROTATE3D_Z_NEG: m_settings->CameraGet().RotateZ( -glm::radians( ROT_ANGLE ) ); break; case ID_ROTATE3D_Z_NEG: m_camera->RotateZ( -glm::radians( ROT_ANGLE ) ); break;
case ID_ROTATE3D_Z_POS: m_settings->CameraGet().RotateZ( glm::radians( ROT_ANGLE ) ); break; case ID_ROTATE3D_Z_POS: m_camera->RotateZ( glm::radians( ROT_ANGLE ) ); break;
default: wxFAIL; break; default: wxFAIL; break;
} }
if( m_settings->RenderEngineGet() == RENDER_ENGINE::OPENGL_LEGACY ) if( m_boardAdapter->RenderEngineGet() == RENDER_ENGINE::OPENGL_LEGACY )
m_canvas->Request_refresh(); m_canvas->Request_refresh();
else else
m_canvas->RenderRaytracingRequest(); m_canvas->RenderRaytracingRequest();
@ -158,9 +160,9 @@ int EDA_3D_CONTROLLER::RotateView( const TOOL_EVENT& aEvent )
int EDA_3D_CONTROLLER::ToggleOrtho( const TOOL_EVENT& aEvent ) int EDA_3D_CONTROLLER::ToggleOrtho( const TOOL_EVENT& aEvent )
{ {
m_settings->CameraGet().ToggleProjection(); m_camera->ToggleProjection();
if( m_settings->RenderEngineGet() == RENDER_ENGINE::OPENGL_LEGACY ) if( m_boardAdapter->RenderEngineGet() == RENDER_ENGINE::OPENGL_LEGACY )
m_canvas->Request_refresh(); m_canvas->Request_refresh();
else else
m_canvas->RenderRaytracingRequest(); m_canvas->RenderRaytracingRequest();
@ -173,7 +175,7 @@ int EDA_3D_CONTROLLER::ToggleVisibility( const TOOL_EVENT& aEvent )
{ {
DISPLAY3D_FLG flag = aEvent.Parameter<DISPLAY3D_FLG>(); DISPLAY3D_FLG flag = aEvent.Parameter<DISPLAY3D_FLG>();
m_settings->SetFlag( flag, !m_settings->GetFlag( flag ) ); m_boardAdapter->SetFlag( flag, !m_boardAdapter->GetFlag( flag ) );
switch( flag ) switch( flag )
{ {
@ -205,7 +207,7 @@ int EDA_3D_CONTROLLER::ToggleVisibility( const TOOL_EVENT& aEvent )
int EDA_3D_CONTROLLER::On3DGridSelection( const TOOL_EVENT& aEvent ) int EDA_3D_CONTROLLER::On3DGridSelection( const TOOL_EVENT& aEvent )
{ {
GRID3D_TYPE grid = aEvent.Parameter<GRID3D_TYPE>(); GRID3D_TYPE grid = aEvent.Parameter<GRID3D_TYPE>();
m_settings->GridSet( grid ); m_boardAdapter->GridSet( grid );
if( m_canvas ) if( m_canvas )
m_canvas->Request_refresh(); m_canvas->Request_refresh();

8
3d-viewer/3d_viewer/tools/3d_controller.h
View File

@ -27,7 +27,7 @@
#include <tool/tool_interactive.h> #include <tool/tool_interactive.h>
class EDA_3D_VIEWER; class EDA_3D_VIEWER;
class EDA_3D_SETTINGS; class BOARD_ADAPTER;
/** /**
@ -42,7 +42,8 @@ public:
EDA_3D_CONTROLLER() : EDA_3D_CONTROLLER() :
TOOL_INTERACTIVE( "3DViewer.Control" ), TOOL_INTERACTIVE( "3DViewer.Control" ),
m_canvas( nullptr ), m_canvas( nullptr ),
m_settings( nullptr ) m_boardAdapter( nullptr ),
m_camera( nullptr )
{ } { }
~EDA_3D_CONTROLLER() override { } ~EDA_3D_CONTROLLER() override { }
@ -80,7 +81,8 @@ private:
private: private:
EDA_3D_CANVAS* m_canvas; EDA_3D_CANVAS* m_canvas;
EDA_3D_SETTINGS* m_settings; BOARD_ADAPTER* m_boardAdapter;
CCAMERA* m_camera;
}; };
#endif #endif

2
3d-viewer/CMakeLists.txt
View File

@ -35,7 +35,7 @@ set(3D-VIEWER_SRCS
${DIR_DLG}/dlg_select_3dmodel.cpp ${DIR_DLG}/dlg_select_3dmodel.cpp
${DIR_DLG}/panel_prev_3d_base.cpp ${DIR_DLG}/panel_prev_3d_base.cpp
${DIR_DLG}/panel_prev_3d.cpp ${DIR_DLG}/panel_prev_3d.cpp
3d_canvas/3d_settings.cpp 3d_canvas/board_adapter.cpp
3d_canvas/create_layer_items.cpp 3d_canvas/create_layer_items.cpp
3d_canvas/create_3Dgraphic_brd_items.cpp 3d_canvas/create_3Dgraphic_brd_items.cpp
3d_canvas/create_layer_poly.cpp 3d_canvas/create_layer_poly.cpp

2
eeschema/sch_painter.h
View File

@ -128,7 +128,7 @@ public:
m_schSettings = *static_cast<const SCH_RENDER_SETTINGS*>( aSettings ); m_schSettings = *static_cast<const SCH_RENDER_SETTINGS*>( aSettings );
} }
/// @copydoc PAINTER::GetSettings() /// @copydoc PAINTER::GetAdapter()
virtual SCH_RENDER_SETTINGS* GetSettings() override virtual SCH_RENDER_SETTINGS* GetSettings() override
{ {
return &m_schSettings; return &m_schSettings;

2
eeschema/sim/sim_plot_frame_base.fbp
View File

@ -268,7 +268,7 @@
<property name="id">ID_MENU_SET_SIMUL</property> <property name="id">ID_MENU_SET_SIMUL</property>
<property name="kind">wxITEM_NORMAL</property> <property name="kind">wxITEM_NORMAL</property>
<property name="label">Settings...</property> <property name="label">Settings...</property>
<property name="name">m_settings</property> <property name="name">m_boardAdapter</property>
<property name="permission">protected</property> <property name="permission">protected</property>
<property name="shortcut"></property> <property name="shortcut"></property>
<property name="unchecked_bitmap"></property> <property name="unchecked_bitmap"></property>

2
eeschema/tools/backannotate.h
View File

@ -127,7 +127,7 @@ private:
wxString getTextFromField( const SCH_REFERENCE& aRef, const NumFieldType aField ); wxString getTextFromField( const SCH_REFERENCE& aRef, const NumFieldType aField );
/** /**
* @brief Check if modules has different data. Check only if corresponding \ref m_settings * @brief Check if modules has different data. Check only if corresponding \ref m_boardAdapter
* flag is rised * flag is rised
* @param aFirst first module to compare * @param aFirst first module to compare
* @param aSecond second module to compare * @param aSecond second module to compare

2
gerbview/gerbview_painter.h
View File

@ -175,7 +175,7 @@ public:
m_gerbviewSettings = *static_cast<const GERBVIEW_RENDER_SETTINGS*>( aSettings ); m_gerbviewSettings = *static_cast<const GERBVIEW_RENDER_SETTINGS*>( aSettings );
} }
/// @copydoc PAINTER::GetSettings() /// @copydoc PAINTER::GetAdapter()
virtual GERBVIEW_RENDER_SETTINGS* GetSettings() override virtual GERBVIEW_RENDER_SETTINGS* GetSettings() override
{ {
return &m_gerbviewSettings; return &m_gerbviewSettings;

2
include/painter.h
View File

@ -338,7 +338,7 @@ public:
virtual void ApplySettings( const RENDER_SETTINGS* aSettings ) = 0; virtual void ApplySettings( const RENDER_SETTINGS* aSettings ) = 0;
/** /**
* Function GetSettings * Function GetAdapter
* Returns pointer to current settings that are going to be used when drawing items. * Returns pointer to current settings that are going to be used when drawing items.
* @return Current rendering settings. * @return Current rendering settings.
*/ */

2
include/tool/tool_base.h
View File

@ -145,7 +145,7 @@ public:
return m_toolMgr; return m_toolMgr;
} }
//TOOL_SETTINGS& GetSettings(); //TOOL_SETTINGS& GetAdapter();
bool IsToolActive() const; bool IsToolActive() const;

2
include/ws_painter.h
View File

@ -114,7 +114,7 @@ public:
m_renderSettings = *static_cast<const WS_RENDER_SETTINGS*>( aSettings ); m_renderSettings = *static_cast<const WS_RENDER_SETTINGS*>( aSettings );
} }
/// @copydoc PAINTER::GetSettings() /// @copydoc PAINTER::GetAdapter()
virtual RENDER_SETTINGS* GetSettings() override { return &m_renderSettings; } virtual RENDER_SETTINGS* GetSettings() override { return &m_renderSettings; }
private: private:

2
pcbnew/pcb_painter.h
View File

@ -232,7 +232,7 @@ public:
m_pcbSettings = *static_cast<const PCB_RENDER_SETTINGS*>( aSettings ); m_pcbSettings = *static_cast<const PCB_RENDER_SETTINGS*>( aSettings );
} }
/// @copydoc PAINTER::GetSettings() /// @copydoc PAINTER::GetAdapter()
virtual PCB_RENDER_SETTINGS* GetSettings() override virtual PCB_RENDER_SETTINGS* GetSettings() override
{ {
return &m_pcbSettings; return &m_pcbSettings;