KiCad PCB EDA Suite
C3D_RENDER_RAYTRACING Class Reference

#include <c3d_render_raytracing.h>

Inheritance diagram for C3D_RENDER_RAYTRACING:
C3D_RENDER_BASE

Public Member Functions

 C3D_RENDER_RAYTRACING (CINFO3D_VISU &aSettings)
 
 ~C3D_RENDER_RAYTRACING ()
 
void SetCurWindowSize (const wxSize &aSize) override
 SetCurWindowSize - Before each render, the canvas will tell the render what is the size of its windows, so render can take actions if it changed. More...
 
bool Redraw (bool aIsMoving, REPORTER *aStatusTextReporter) override
 Redraw - Ask to redraw the view. More...
 
int GetWaitForEditingTimeOut () override
 GetWaitForEditingTimeOut - Give the interface the time (in ms) that it should wait for editing or movements before (this works for display preview mode) More...
 
void ReloadRequest ()
 ReloadRequest - !TODO: this must be reviewed to add flags to improve specific render. More...
 
bool IsReloadRequestPending () const
 IsReloadRequestPending - Query if there is a pending reload request. More...
 

Protected Attributes

CINFO3D_VISUm_settings
 settings refrence in use for this render More...
 
bool m_is_opengl_initialized
 flag if the opengl specific for this render was already initialized More...
 
bool m_reloadRequested
 !TODO: this must be reviewed in order to flag change types More...
 
wxSize m_windowSize
 The window size that this camera is working. More...
 

Static Protected Attributes

static const wxChar * m_logTrace = wxT( "KI_TRACE_3D_RENDER" )
 Trace mask used to enable or disable the trace output of this class. More...
 

Private Member Functions

bool initializeOpenGL ()
 
void initializeNewWindowSize ()
 
void opengl_init_pbo ()
 
void opengl_delete_pbo ()
 
void reload (REPORTER *aStatusTextReporter)
 
void restart_render_state ()
 
void rt_render_tracing (GLubyte *ptrPBO, REPORTER *aStatusTextReporter)
 
void rt_render_post_process_shade (GLubyte *ptrPBO, REPORTER *aStatusTextReporter)
 
void rt_render_post_process_blur_finish (GLubyte *ptrPBO, REPORTER *aStatusTextReporter)
 
void rt_render_trace_block (GLubyte *ptrPBO, signed int iBlock)
 
void rt_final_color (GLubyte *ptrPBO, const SFVEC3F &rgbColor, bool applyColorSpaceConversion)
 
void rt_shades_packet (const SFVEC3F *bgColorY, const RAY *aRayPkt, HITINFO_PACKET *aHitPacket, bool is_testShadow, SFVEC3F *aOutHitColor)
 
void rt_trace_AA_packet (const SFVEC3F *aBgColorY, const HITINFO_PACKET *aHitPck_X0Y0, const HITINFO_PACKET *aHitPck_AA_X1Y1, const RAY *aRayPck, SFVEC3F *aOutHitColor)
 
void setupMaterials ()
 
SFVEC3F shadeHit (const SFVEC3F &aBgColor, const RAY &aRay, HITINFO &aHitInfo, bool aIsInsideObject, unsigned int aRecursiveLevel, bool is_testShadow) const
 
void create_3d_object_from (CCONTAINER &aDstContainer, const COBJECT2D *aObject2D, float aZMin, float aZMax, const CMATERIAL *aMaterial, const SFVEC3F &aObjColor)
 Function create_3d_object_from. More...
 
void add_3D_vias_and_pads_to_container ()
 
void insert3DViaHole (const VIA *aVia)
 
void insert3DPadHole (const D_PAD *aPad)
 
void load_3D_models ()
 
void add_3D_models (const S3DMODEL *a3DModel, const glm::mat4 &aModelMatrix)
 
void initialize_block_positions ()
 
void render (GLubyte *ptrPBO, REPORTER *aStatusTextReporter)
 
void render_preview (GLubyte *ptrPBO)
 

Private Attributes

struct {
   CBLINN_PHONG_MATERIAL   m_Paste
 
   CBLINN_PHONG_MATERIAL   m_SilkS
 
   CBLINN_PHONG_MATERIAL   m_SolderMask
 
   CBLINN_PHONG_MATERIAL   m_EpoxyBoard
 
   CBLINN_PHONG_MATERIAL   m_Copper
 
   CBLINN_PHONG_MATERIAL   m_Floor
 
m_materials
 
CBOARDNORMAL m_board_normal_perturbator
 
CCOPPERNORMAL m_copper_normal_perturbator
 
CSOLDERMASKNORMAL m_solder_mask_normal_perturbator
 
CPLASTICNORMAL m_plastic_normal_perturbator
 
CPLASTICSHINENORMAL m_plastic_shine_normal_perturbator
 
CMETALBRUSHEDNORMAL m_brushed_metal_normal_perturbator
 
bool m_isPreview
 
RT_RENDER_STATE m_rt_render_state
 State used on quality render. More...
 
unsigned long int m_stats_start_rendering_time
 Time that the render starts. More...
 
long m_nrBlocksRenderProgress
 Save the number of blocks progress of the render. More...
 
CPOSTSHADER_SSAO m_postshader_ssao
 
CLIGHTCONTAINER m_lights
 
CDIRECTIONALLIGHTm_camera_light
 
bool m_opengl_support_vertex_buffer_object
 
GLuint m_pboId
 
GLuint m_pboDataSize
 
CCONTAINER m_object_container
 
CCONTAINER2D m_containerWithObjectsToDelete
 This will store the list of created objects special for RT, that will be clear in the end. More...
 
CCONTAINER2Dm_outlineBoard2dObjects
 
CGENERICACCELERATORm_accelerator
 
SFVEC3F m_BgColorTop_LinearRGB
 
SFVEC3F m_BgColorBot_LinearRGB
 
wxSize m_oldWindowsSize
 used to see if the windows size changed More...
 
std::vector< SFVEC2UIm_blockPositions
 this encodes the Morton code positions More...
 
std::vector< bool > m_blockPositionsWasProcessed
 this flags if a position was already processed (cleared each new render) More...
 
std::vector< SFVEC2UIm_blockPositionsFast
 this encodes the Morton code positions (on fast preview mode) More...
 
SFVEC2UI m_realBufferSize
 
SFVEC2UI m_fastPreviewModeSize
 
HITINFO_PACKETm_firstHitinfo
 
SFVEC3Fm_shaderBuffer
 
unsigned int m_xoffset
 
unsigned int m_yoffset
 
unsigned int m_stats_converted_dummy_to_plane
 
unsigned int m_stats_converted_roundsegment2d_to_roundsegment
 
MAP_MODEL_MATERIALS m_model_materials
 Stores materials of the 3D models. More...
 

Detailed Description

Definition at line 59 of file c3d_render_raytracing.h.

Constructor & Destructor Documentation

C3D_RENDER_RAYTRACING::C3D_RENDER_RAYTRACING ( CINFO3D_VISU aSettings)
explicit

Definition at line 49 of file c3d_render_raytracing.cpp.

References m_accelerator, m_camera_light, m_firstHitinfo, m_isPreview, C3D_RENDER_BASE::m_logTrace, m_nrBlocksRenderProgress, m_oldWindowsSize, m_opengl_support_vertex_buffer_object, m_outlineBoard2dObjects, m_pboDataSize, m_pboId, m_rt_render_state, m_shaderBuffer, m_stats_converted_dummy_to_plane, m_stats_converted_roundsegment2d_to_roundsegment, m_stats_start_rendering_time, m_xoffset, m_yoffset, and RT_RENDER_STATE_MAX.

49  :
50  C3D_RENDER_BASE( aSettings ),
51  m_postshader_ssao( aSettings.CameraGet() )
52 {
53  wxLogTrace( m_logTrace, wxT( "C3D_RENDER_RAYTRACING::C3D_RENDER_RAYTRACING" ) );
54 
56  m_pboId = GL_NONE;
57  m_pboDataSize = 0;
58  m_accelerator = NULL;
61  m_oldWindowsSize.x = 0;
62  m_oldWindowsSize.y = 0;
64  m_firstHitinfo = NULL;
65  m_shaderBuffer = NULL;
66  m_camera_light = NULL;
67 
68  m_xoffset = 0;
69  m_yoffset = 0;
70 
71  m_isPreview = false;
72  m_rt_render_state = RT_RENDER_STATE_MAX; // Set to an initial invalid state
75 }
long m_nrBlocksRenderProgress
Save the number of blocks progress of the render.
CPOSTSHADER_SSAO m_postshader_ssao
wxSize m_oldWindowsSize
used to see if the windows size changed
HITINFO_PACKET * m_firstHitinfo
unsigned int m_stats_converted_dummy_to_plane
CGENERICACCELERATOR * m_accelerator
C3D_RENDER_BASE(CINFO3D_VISU &aSettings)
RT_RENDER_STATE m_rt_render_state
State used on quality render.
unsigned int m_stats_converted_roundsegment2d_to_roundsegment
CDIRECTIONALLIGHT * m_camera_light
CCAMERA & CameraGet() const
CameraGet - get current camera in use.
Definition: cinfo3d_visu.h:210
unsigned long int m_stats_start_rendering_time
Time that the render starts.
CCONTAINER2D * m_outlineBoard2dObjects
static const wxChar * m_logTrace
Trace mask used to enable or disable the trace output of this class.
C3D_RENDER_RAYTRACING::~C3D_RENDER_RAYTRACING ( )

Definition at line 78 of file c3d_render_raytracing.cpp.

References m_accelerator, C3D_RENDER_BASE::m_logTrace, m_outlineBoard2dObjects, m_shaderBuffer, and opengl_delete_pbo().

79 {
80  wxLogTrace( m_logTrace, wxT( "C3D_RENDER_RAYTRACING::~C3D_RENDER_RAYTRACING" ) );
81 
82  delete m_accelerator;
83  m_accelerator = NULL;
84 
87 
88  delete[] m_shaderBuffer;
89  m_shaderBuffer = NULL;
90 
92 }
CGENERICACCELERATOR * m_accelerator
CCONTAINER2D * m_outlineBoard2dObjects
static const wxChar * m_logTrace
Trace mask used to enable or disable the trace output of this class.

Member Function Documentation

void C3D_RENDER_RAYTRACING::add_3D_models ( const S3DMODEL a3DModel,
const glm::mat4 &  aModelMatrix 
)
private

Definition at line 1300 of file c3d_render_createscene.cpp.

References abs, CGENERICCONTAINER::Add(), ConvertSRGBToLinear(), FL_RENDER_RAYTRACING_POST_PROCESSING, FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES, CINFO3D_VISU::GetFlag(), SMATERIAL::m_Ambient, m_brushed_metal_normal_perturbator, SMESH::m_Color, SMATERIAL::m_Diffuse, SMATERIAL::m_Emissive, SMESH::m_FaceIdx, SMESH::m_FaceIdxSize, SMESH::m_MaterialIdx, S3DMODEL::m_Materials, S3DMODEL::m_MaterialsSize, S3DMODEL::m_Meshes, S3DMODEL::m_MeshesSize, m_model_materials, SMESH::m_Normals, m_object_container, m_plastic_normal_perturbator, m_plastic_shine_normal_perturbator, SMESH::m_Positions, C3D_RENDER_BASE::m_settings, SMATERIAL::m_Shininess, SMATERIAL::m_Specular, SMATERIAL::m_Transparency, SMESH::m_VertexSize, MATERIAL_MODE_CAD_MODE, MATERIAL_MODE_NORMAL, MaterialDiffuseToColorCAD(), CINFO3D_VISU::MaterialModeGet(), RGBtoGray(), CTRIANGLE::SetColor(), COBJECT::SetMaterial(), and CMATERIAL::SetNormalPerturbator().

Referenced by load_3D_models().

1302 {
1303 
1304  // Validate a3DModel pointers
1305  wxASSERT( a3DModel != NULL );
1306 
1307  if( a3DModel == NULL )
1308  return;
1309 
1310  wxASSERT( a3DModel->m_Materials != NULL );
1311  wxASSERT( a3DModel->m_Meshes != NULL );
1312  wxASSERT( a3DModel->m_MaterialsSize > 0 );
1313  wxASSERT( a3DModel->m_MeshesSize > 0 );
1314 
1315  if( (a3DModel->m_Materials != NULL) && (a3DModel->m_Meshes != NULL) &&
1316  (a3DModel->m_MaterialsSize > 0) && (a3DModel->m_MeshesSize > 0) )
1317  {
1318 
1319  MODEL_MATERIALS *materialVector;
1320 
1321  // Try find if the materials already exists in the map list
1322  if( m_model_materials.find( a3DModel ) != m_model_materials.end() )
1323  {
1324  // Found it, so get the pointer
1325  materialVector = &m_model_materials[a3DModel];
1326  }
1327  else
1328  {
1329  // Materials was not found in the map, so it will create a new for
1330  // this model.
1331 
1332  m_model_materials[a3DModel] = MODEL_MATERIALS();
1333  materialVector = &m_model_materials[a3DModel];
1334 
1335  materialVector->resize( a3DModel->m_MaterialsSize );
1336 
1337  for( unsigned int imat = 0;
1338  imat < a3DModel->m_MaterialsSize;
1339  ++imat )
1340  {
1342  {
1343  const SMATERIAL &material = a3DModel->m_Materials[imat];
1344 
1345  // http://www.fooplot.com/#W3sidHlwZSI6MCwiZXEiOiJtaW4oc3FydCh4LTAuMzUpKjAuNDAtMC4wNSwxLjApIiwiY29sb3IiOiIjMDAwMDAwIn0seyJ0eXBlIjoxMDAwLCJ3aW5kb3ciOlsiMC4wNzA3NzM2NzMyMzY1OTAxMiIsIjEuNTY5NTcxNjI5MjI1NDY5OCIsIi0wLjI3NDYzNTMyMTc1OTkyOTMiLCIwLjY0NzcwMTg4MTkyNTUzNjIiXSwic2l6ZSI6WzY0NCwzOTRdfV0-
1346 
1347  float reflectionFactor = 0.0f;
1348 
1349  if( (material.m_Shininess - 0.35f) > FLT_EPSILON )
1350  {
1351  reflectionFactor = glm::clamp( glm::sqrt( (material.m_Shininess - 0.35f) ) *
1352  0.40f - 0.05f,
1353  0.0f,
1354  0.5f );
1355  }
1356 
1357  CBLINN_PHONG_MATERIAL &blinnMaterial = (*materialVector)[imat];
1358 
1359  SFVEC3F ambient;
1360 
1362  {
1363  // apply a gain to the (dark) ambient colors
1364 
1365  // http://www.fooplot.com/#W3sidHlwZSI6MCwiZXEiOiIoKHgrMC4yMCleKDEvMi4wMCkpLTAuMzUiLCJjb2xvciI6IiMwMDAwMDAifSx7InR5cGUiOjAsImVxIjoieCIsImNvbG9yIjoiIzAwMDAwMCJ9LHsidHlwZSI6MTAwMCwid2luZG93IjpbIi0xLjI0OTUwNTMzOTIyMzYyIiwiMS42Nzc4MzQ0MTg1NjcxODQzIiwiLTAuNDM1NTA0NjQyODEwOTMwMjYiLCIxLjM2NTkzNTIwODEzNzI1OCJdLCJzaXplIjpbNjQ5LDM5OV19XQ--
1366  // ambient = glm::max( (glm::pow((material.m_Ambient + 0.20f), SFVEC3F(1.0f / 2.00f)) - SFVEC3F(0.35f)), material.m_Ambient );
1367 
1368  // http://www.fooplot.com/#W3sidHlwZSI6MCwiZXEiOiIoKHgrMC4yMCleKDEvMS41OCkpLTAuMzUiLCJjb2xvciI6IiMwMDAwMDAifSx7InR5cGUiOjAsImVxIjoieCIsImNvbG9yIjoiIzAwMDAwMCJ9LHsidHlwZSI6MTAwMCwid2luZG93IjpbIi0xLjI0OTUwNTMzOTIyMzYyIiwiMS42Nzc4MzQ0MTg1NjcxODQzIiwiLTAuNDM1NTA0NjQyODEwOTMwMjYiLCIxLjM2NTkzNTIwODEzNzI1OCJdLCJzaXplIjpbNjQ5LDM5OV19XQ--
1369  //ambient = glm::max( (glm::pow((material.m_Ambient + 0.20f), SFVEC3F(1.0f / 1.58f)) - SFVEC3F(0.35f)), material.m_Ambient );
1370 
1371  // http://www.fooplot.com/#W3sidHlwZSI6MCwiZXEiOiIoKHgrMC4yMCleKDEvMS41NCkpLTAuMzQiLCJjb2xvciI6IiMwMDAwMDAifSx7InR5cGUiOjAsImVxIjoieCIsImNvbG9yIjoiIzAwMDAwMCJ9LHsidHlwZSI6MTAwMCwid2luZG93IjpbIi0yLjcyMTA5NTg0MjA1MDYwNSIsIjEuODUyODcyNTI5NDk3NTIyMyIsIi0xLjQyMTM3NjAxOTkyOTA4MDYiLCIxLjM5MzM3Mzc0NzE3NzQ2MTIiXSwic2l6ZSI6WzY0OSwzOTldfV0-
1372  ambient = ConvertSRGBToLinear(
1373  glm::pow((material.m_Ambient + 0.30f), SFVEC3F(1.0f / 1.54f)) - SFVEC3F(0.34f) );
1374  }
1375  else
1376  {
1377  ambient = ConvertSRGBToLinear( material.m_Ambient );
1378  }
1379 
1380 
1381  blinnMaterial = CBLINN_PHONG_MATERIAL(
1382  ambient,
1383  ConvertSRGBToLinear( material.m_Emissive ),
1384  ConvertSRGBToLinear( material.m_Specular ),
1385  material.m_Shininess * 180.0f,
1386  material.m_Transparency,
1387  reflectionFactor );
1388 
1390  {
1391  // Guess material type and apply a normal perturbator
1392 
1393  if( ( RGBtoGray(material.m_Diffuse) < 0.3f ) &&
1394  ( material.m_Shininess < 0.36f ) &&
1395  ( material.m_Transparency == 0.0f ) &&
1396  ( (glm::abs( material.m_Diffuse.r - material.m_Diffuse.g ) < 0.15f) &&
1397  (glm::abs( material.m_Diffuse.b - material.m_Diffuse.g ) < 0.15f) &&
1398  (glm::abs( material.m_Diffuse.r - material.m_Diffuse.b ) < 0.15f) ) )
1399  {
1400  // This may be a black plastic..
1401 
1402  if( material.m_Shininess < 0.26f )
1404  else
1406  }
1407  else
1408  {
1409  if( ( RGBtoGray(material.m_Diffuse) > 0.3f ) &&
1410  ( material.m_Shininess < 0.30f ) &&
1411  ( material.m_Transparency == 0.0f ) &&
1412  ( (glm::abs( material.m_Diffuse.r - material.m_Diffuse.g ) > 0.25f) ||
1413  (glm::abs( material.m_Diffuse.b - material.m_Diffuse.g ) > 0.25f) ||
1414  (glm::abs( material.m_Diffuse.r - material.m_Diffuse.b ) > 0.25f) ) )
1415  {
1416  // This may be a color plastic ...
1418  }
1419  else
1420  {
1421  if( ( RGBtoGray(material.m_Diffuse) > 0.6f ) &&
1422  ( material.m_Shininess > 0.35f ) &&
1423  ( material.m_Transparency == 0.0f ) &&
1424  ( (glm::abs( material.m_Diffuse.r - material.m_Diffuse.g ) < 0.40f) &&
1425  (glm::abs( material.m_Diffuse.b - material.m_Diffuse.g ) < 0.40f) &&
1426  (glm::abs( material.m_Diffuse.r - material.m_Diffuse.b ) < 0.40f) ) )
1427  {
1428  // This may be a brushed metal
1430  }
1431  }
1432  }
1433  }
1434  }
1435  else
1436  {
1437  (*materialVector)[imat] = CBLINN_PHONG_MATERIAL( SFVEC3F( 0.2f ),
1438  SFVEC3F( 0.0f ),
1439  SFVEC3F( 0.0f ),
1440  0.0f,
1441  0.0f,
1442  0.0f );
1443  }
1444  }
1445  }
1446 
1447  const glm::mat3 normalMatrix = glm::transpose( glm::inverse( glm::mat3( aModelMatrix ) ) );
1448 
1449  for( unsigned int mesh_i = 0;
1450  mesh_i < a3DModel->m_MeshesSize;
1451  ++mesh_i )
1452  {
1453  const SMESH &mesh = a3DModel->m_Meshes[mesh_i];
1454 
1455  // Validate the mesh pointers
1456  wxASSERT( mesh.m_Positions != NULL );
1457  wxASSERT( mesh.m_FaceIdx != NULL );
1458  wxASSERT( mesh.m_Normals != NULL );
1459  wxASSERT( mesh.m_FaceIdxSize > 0 );
1460  wxASSERT( (mesh.m_FaceIdxSize % 3) == 0 );
1461 
1462 
1463  if( (mesh.m_Positions != NULL) &&
1464  (mesh.m_Normals != NULL) &&
1465  (mesh.m_FaceIdx != NULL) &&
1466  (mesh.m_FaceIdxSize > 0) &&
1467  (mesh.m_VertexSize > 0) &&
1468  ((mesh.m_FaceIdxSize % 3) == 0) &&
1469  (mesh.m_MaterialIdx < a3DModel->m_MaterialsSize) )
1470  {
1471  const CBLINN_PHONG_MATERIAL &blinn_material = (*materialVector)[mesh.m_MaterialIdx];
1472 
1473  // Add all face triangles
1474  for( unsigned int faceIdx = 0;
1475  faceIdx < mesh.m_FaceIdxSize;
1476  faceIdx += 3 )
1477  {
1478  const unsigned int idx0 = mesh.m_FaceIdx[faceIdx + 0];
1479  const unsigned int idx1 = mesh.m_FaceIdx[faceIdx + 1];
1480  const unsigned int idx2 = mesh.m_FaceIdx[faceIdx + 2];
1481 
1482  wxASSERT( idx0 < mesh.m_VertexSize );
1483  wxASSERT( idx1 < mesh.m_VertexSize );
1484  wxASSERT( idx2 < mesh.m_VertexSize );
1485 
1486  if( ( idx0 < mesh.m_VertexSize ) &&
1487  ( idx1 < mesh.m_VertexSize ) &&
1488  ( idx2 < mesh.m_VertexSize ) )
1489  {
1490  const SFVEC3F &v0 = mesh.m_Positions[idx0];
1491  const SFVEC3F &v1 = mesh.m_Positions[idx1];
1492  const SFVEC3F &v2 = mesh.m_Positions[idx2];
1493 
1494  const SFVEC3F &n0 = mesh.m_Normals[idx0];
1495  const SFVEC3F &n1 = mesh.m_Normals[idx1];
1496  const SFVEC3F &n2 = mesh.m_Normals[idx2];
1497 
1498  // Transform vertex with the model matrix
1499  const SFVEC3F vt0 = SFVEC3F( aModelMatrix * glm::vec4( v0, 1.0f) );
1500  const SFVEC3F vt1 = SFVEC3F( aModelMatrix * glm::vec4( v1, 1.0f) );
1501  const SFVEC3F vt2 = SFVEC3F( aModelMatrix * glm::vec4( v2, 1.0f) );
1502 
1503  const SFVEC3F nt0 = glm::normalize( SFVEC3F( normalMatrix * n0 ) );
1504  const SFVEC3F nt1 = glm::normalize( SFVEC3F( normalMatrix * n1 ) );
1505  const SFVEC3F nt2 = glm::normalize( SFVEC3F( normalMatrix * n2 ) );
1506 
1507  CTRIANGLE *newTriangle = new CTRIANGLE( vt0, vt2, vt1,
1508  nt0, nt2, nt1 );
1509 
1510 
1511 
1512  m_object_container.Add( newTriangle );
1513  newTriangle->SetMaterial( (const CMATERIAL *)&blinn_material );
1514 
1515  if( mesh.m_Color == NULL )
1516  {
1517  const SFVEC3F diffuseColor =
1518  a3DModel->m_Materials[mesh.m_MaterialIdx].m_Diffuse;
1519 
1521  newTriangle->SetColor( ConvertSRGBToLinear( MaterialDiffuseToColorCAD( diffuseColor ) ) );
1522  else
1523  newTriangle->SetColor( ConvertSRGBToLinear( diffuseColor ) );
1524  }
1525  else
1526  {
1528  newTriangle->SetColor( ConvertSRGBToLinear( MaterialDiffuseToColorCAD( mesh.m_Color[idx0] ) ),
1531  else
1532  newTriangle->SetColor( ConvertSRGBToLinear( mesh.m_Color[idx0] ),
1533  ConvertSRGBToLinear( mesh.m_Color[idx1] ),
1534  ConvertSRGBToLinear( mesh.m_Color[idx2] ) );
1535  }
1536  }
1537  }
1538  }
1539  }
1540  }
1541 }
SFVEC3F * m_Normals
Vertex normals array.
Definition: c3dmodel.h:80
float RGBtoGray(const SFVEC3F &aColor)
Definition: 3d_math.h:147
SFVEC3F m_Ambient
Definition: c3dmodel.h:39
CPLASTICNORMAL m_plastic_normal_perturbator
SFVEC3F ConvertSRGBToLinear(const SFVEC3F &aSRGBcolor)
MATERIAL_MODE MaterialModeGet() const
MaterialModeGet.
Definition: cinfo3d_visu.h:246
A base material class that can be used to derive a material implementation.
Definition: cmaterial.h:167
void SetMaterial(const CMATERIAL *aMaterial)
Definition: cobject.h:62
CPLASTICSHINENORMAL m_plastic_shine_normal_perturbator
float m_Transparency
1.0 is completely transparent, 0.0 completely opaque
Definition: c3dmodel.h:44
void SetNormalPerturbator(const CPROCEDURALGENERATOR *aPerturbator)
Definition: cmaterial.h:220
SFVEC3F * m_Positions
Vertex position array.
Definition: c3dmodel.h:79
CMETALBRUSHEDNORMAL m_brushed_metal_normal_perturbator
CINFO3D_VISU & m_settings
settings refrence in use for this render
#define abs(a)
Definition: auxiliary.h:84
Per-vertex normal/color/texcoors structure.
Definition: c3dmodel.h:76
SMESH * m_Meshes
The meshes list of this model.
Definition: c3dmodel.h:93
unsigned int m_FaceIdxSize
Number of elements of the m_FaceIdx array.
Definition: c3dmodel.h:83
std::vector< CBLINN_PHONG_MATERIAL > MODEL_MATERIALS
Vector of materials.
void SetColor(const SFVEC3F &aColor)
Definition: ctriangle.cpp:161
unsigned int m_VertexSize
Number of vertex in the arrays.
Definition: c3dmodel.h:78
Blinn Phong based material https://en.wikipedia.org/wiki/Blinn%E2%80%93Phong_shading_model.
Definition: cmaterial.h:248
SFVEC3F * m_Color
Vertex color array, can be NULL.
Definition: c3dmodel.h:82
Use a gray shading based on diffuse material.
Definition: 3d_enums.h:94
float m_Shininess
Definition: c3dmodel.h:43
unsigned int m_MaterialsSize
Number of materials in the material array.
Definition: c3dmodel.h:95
A triangle object.
Definition: ctriangle.h:42
void Add(COBJECT *aObject)
Definition: ccontainer.h:52
Use all material properties from model file.
Definition: 3d_enums.h:92
bool GetFlag(DISPLAY3D_FLG aFlag) const
GetFlag - get a configuration status of a flag.
SFVEC3F MaterialDiffuseToColorCAD(const SFVEC3F &aDiffuseColor)
Definition: 3d_math.h:154
SFVEC3F m_Emissive
Definition: c3dmodel.h:41
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
unsigned int m_MaterialIdx
Material Index to be used in this mesh (must be < m_MaterialsSize )
Definition: c3dmodel.h:85
SMATERIAL * m_Materials
The materials list of this model.
Definition: c3dmodel.h:96
SFVEC3F m_Diffuse
Default diffuse color if m_Color is NULL.
Definition: c3dmodel.h:40
unsigned int * m_FaceIdx
Triangle Face Indexes.
Definition: c3dmodel.h:84
unsigned int m_MeshesSize
Number of meshes in the array.
Definition: c3dmodel.h:92
MAP_MODEL_MATERIALS m_model_materials
Stores materials of the 3D models.
SFVEC3F m_Specular
Definition: c3dmodel.h:42
void C3D_RENDER_RAYTRACING::add_3D_vias_and_pads_to_container ( )
private

Definition at line 1169 of file c3d_render_createscene.cpp.

References CINFO3D_VISU::GetBoard(), insert3DPadHole(), insert3DViaHole(), BOARD::m_Modules, C3D_RENDER_BASE::m_settings, BOARD::m_Track, TRACK::Next(), MODULE::Next(), D_PAD::Next(), PAD_ATTRIB_HOLE_NOT_PLATED, and PCB_VIA_T.

Referenced by reload().

1170 {
1171  // Insert plated vertical holes inside the board
1172  // /////////////////////////////////////////////////////////////////////////
1173 
1174  // Insert vias holes (vertical cylinders)
1175  for( const TRACK* track = m_settings.GetBoard()->m_Track;
1176  track;
1177  track = track->Next() )
1178  {
1179  if( track->Type() == PCB_VIA_T )
1180  {
1181  const VIA *via = static_cast<const VIA*>(track);
1182  insert3DViaHole( via );
1183  }
1184  }
1185 
1186  // Insert pads holes (vertical cylinders)
1187  for( const MODULE* module = m_settings.GetBoard()->m_Modules;
1188  module;
1189  module = module->Next() )
1190  {
1191  for( const D_PAD* pad = module->PadsList(); pad; pad = pad->Next() )
1192  if( pad->GetAttribute () != PAD_ATTRIB_HOLE_NOT_PLATED )
1193  {
1194  insert3DPadHole( pad );
1195  }
1196  }
1197 }
like PAD_STANDARD, but not plated mechanical use only, no connection allowed
Definition: pad_shapes.h:65
MODULE * Next() const
Definition: class_module.h:121
void insert3DViaHole(const VIA *aVia)
CINFO3D_VISU & m_settings
settings refrence in use for this render
D_PAD * Next() const
Definition: class_pad.h:160
TRACK * Next() const
Definition: class_track.h:99
DLIST< MODULE > m_Modules
Definition: class_board.h:245
class VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
DLIST< TRACK > m_Track
Definition: class_board.h:246
void insert3DPadHole(const D_PAD *aPad)
const BOARD * GetBoard() const
GetBoard - Get current board to be rendered.
Definition: cinfo3d_visu.h:128
void C3D_RENDER_RAYTRACING::create_3d_object_from ( CCONTAINER aDstContainer,
const COBJECT2D aObject2D,
float  aZMin,
float  aZMax,
const CMATERIAL aMaterial,
const SFVEC3F aObjColor 
)
private

Function create_3d_object_from.

Creates on or more 3D objects form a 2D object and Z positions. It try optimize some types of objects that will be faster to trace than the CLAYERITEM object.

Parameters
aObject2D
aZMin
aZMax

Definition at line 179 of file c3d_render_createscene.cpp.

References CGENERICCONTAINER::Add(), ConvertSRGBToLinear(), COBJECT2D::GetBBox(), COBJECT2D::GetObjectType(), m_stats_converted_dummy_to_plane, m_stats_converted_roundsegment2d_to_roundsegment, CBBOX2D::Max(), CBBOX2D::Min(), OBJ2D_DUMMYBLOCK, OBJ2D_ROUNDSEG, CLAYERITEM::SetColor(), CROUNDSEG::SetColor(), CXYPLANE::SetColor(), and COBJECT::SetMaterial().

Referenced by reload().

184 {
185  switch( aObject2D->GetObjectType() )
186  {
187  case OBJ2D_DUMMYBLOCK:
188  {
190 #if 1
191  CXYPLANE *objPtr;
192  objPtr = new CXYPLANE( CBBOX ( SFVEC3F( aObject2D->GetBBox().Min().x,
193  aObject2D->GetBBox().Min().y,
194  aZMin ),
195  SFVEC3F( aObject2D->GetBBox().Max().x,
196  aObject2D->GetBBox().Max().y,
197  aZMin ) ) );
198  objPtr->SetMaterial( aMaterial );
199  objPtr->SetColor( ConvertSRGBToLinear( aObjColor ) );
200  aDstContainer.Add( objPtr );
201 
202  objPtr = new CXYPLANE( CBBOX ( SFVEC3F( aObject2D->GetBBox().Min().x,
203  aObject2D->GetBBox().Min().y,
204  aZMax ),
205  SFVEC3F( aObject2D->GetBBox().Max().x,
206  aObject2D->GetBBox().Max().y,
207  aZMax ) ) );
208  objPtr->SetMaterial( aMaterial );
209  objPtr->SetColor( ConvertSRGBToLinear( aObjColor ) );
210  aDstContainer.Add( objPtr );
211 #else
212  objPtr = new CDUMMYBLOCK( CBBOX ( SFVEC3F( aObject2D->GetBBox().Min().x,
213  aObject2D->GetBBox().Min().y,
214  aZMin ),
215  SFVEC3F( aObject2D->GetBBox().Max().x,
216  aObject2D->GetBBox().Max().y,
217  aZMax ) ) );
218  objPtr->SetMaterial( aMaterial );
219  aDstContainer.Add( objPtr );
220 #endif
221  }
222  break;
223 
224  case OBJ2D_ROUNDSEG:
225  {
227 
228  const CROUNDSEGMENT2D *aRoundSeg2D = static_cast<const CROUNDSEGMENT2D *>( aObject2D );
229  CROUNDSEG *objPtr = new CROUNDSEG( *aRoundSeg2D, aZMin, aZMax );
230  objPtr->SetMaterial( aMaterial );
231  objPtr->SetColor( ConvertSRGBToLinear( aObjColor ) );
232  aDstContainer.Add( objPtr );
233  }
234  break;
235 
236 
237  default:
238  {
239  CLAYERITEM *objPtr = new CLAYERITEM( aObject2D, aZMin, aZMax );
240  objPtr->SetMaterial( aMaterial );
241  objPtr->SetColor( ConvertSRGBToLinear( aObjColor ) );
242  aDstContainer.Add( objPtr );
243  }
244  break;
245  }
246 }
SFVEC3F ConvertSRGBToLinear(const SFVEC3F &aSRGBcolor)
void SetMaterial(const CMATERIAL *aMaterial)
Definition: cobject.h:62
A dummy block is used to fill the polygons.
Definition: cdummyblock.h:39
void SetColor(SFVEC3F aObjColor)
Definition: croundseg.h:48
A plane that is parallel to XY plane.
Definition: cplane.h:38
unsigned int m_stats_converted_dummy_to_plane
void SetColor(SFVEC3F aObjColor)
Definition: cplane.h:52
OBJECT2D_TYPE GetObjectType() const
Definition: cobject2d.h:125
unsigned int m_stats_converted_roundsegment2d_to_roundsegment
void SetColor(SFVEC3F aObjColor)
Definition: clayeritem.h:46
void Add(COBJECT *aObject)
Definition: ccontainer.h:52
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
const CBBOX2D & GetBBox() const
Definition: cobject2d.h:121
const SFVEC2F & Min() const
Function Min return the minimun vertex pointer.
Definition: cbbox2d.h:176
Class CBBOX manages a bounding box defined by two SFVEC3F min max points.
Definition: cbbox.h:40
const SFVEC2F & Max() const
Function Max return the maximum vertex pointer.
Definition: cbbox2d.h:183
int C3D_RENDER_RAYTRACING::GetWaitForEditingTimeOut ( )
overridevirtual

GetWaitForEditingTimeOut - Give the interface the time (in ms) that it should wait for editing or movements before (this works for display preview mode)

Returns
a value in miliseconds

Implements C3D_RENDER_BASE.

Definition at line 95 of file c3d_render_raytracing.cpp.

96 {
97  return 1000; // ms
98 }
void C3D_RENDER_RAYTRACING::initialize_block_positions ( )
private

Definition at line 2067 of file c3d_render_raytracing.cpp.

References DecodeMorton2X(), DecodeMorton2Y(), m_blockPositions, m_blockPositionsFast, m_fastPreviewModeSize, m_postshader_ssao, m_realBufferSize, m_shaderBuffer, C3D_RENDER_BASE::m_windowSize, m_xoffset, m_yoffset, opengl_init_pbo(), RAYPACKET_DIM, RAYPACKET_INVMASK, and CPOSTSHADER::UpdateSize().

Referenced by Redraw().

2068 {
2069 
2071 
2072  // Calc block positions for fast preview mode
2073  // /////////////////////////////////////////////////////////////////////
2074  m_blockPositionsFast.clear();
2075 
2076  unsigned int i = 0;
2077 
2078  while(1)
2079  {
2080  const unsigned int mX = DecodeMorton2X(i);
2081  const unsigned int mY = DecodeMorton2Y(i);
2082 
2083  i++;
2084 
2085  const SFVEC2UI blockPos( mX * 4 * RAYPACKET_DIM - mX * 4,
2086  mY * 4 * RAYPACKET_DIM - mY * 4);
2087 
2088  if( ( blockPos.x >= ( (unsigned int)m_windowSize.x - ( 4 * RAYPACKET_DIM + 4 ) ) ) &&
2089  ( blockPos.y >= ( (unsigned int)m_windowSize.y - ( 4 * RAYPACKET_DIM + 4 ) ) ) )
2090  break;
2091 
2092  if( ( blockPos.x < ( (unsigned int)m_windowSize.x - ( 4 * RAYPACKET_DIM + 4) ) ) &&
2093  ( blockPos.y < ( (unsigned int)m_windowSize.y - ( 4 * RAYPACKET_DIM + 4) ) ) )
2094  {
2095  m_blockPositionsFast.push_back( blockPos );
2096 
2097  if( blockPos.x > m_realBufferSize.x )
2098  m_realBufferSize.x = blockPos.x;
2099 
2100  if( blockPos.y > m_realBufferSize.y )
2101  m_realBufferSize.y = blockPos.y;
2102  }
2103  }
2104 
2106 
2109 
2110  m_xoffset = (m_windowSize.x - m_realBufferSize.x) / 2;
2111  m_yoffset = (m_windowSize.y - m_realBufferSize.y) / 2;
2112 
2114 
2115 
2116  // Calc block positions
2117  // /////////////////////////////////////////////////////////////////////
2118  m_blockPositions.clear();
2121 
2122  i = 0;
2123 
2124  while(1)
2125  {
2126  SFVEC2UI blockPos( DecodeMorton2X(i) * RAYPACKET_DIM,
2127  DecodeMorton2Y(i) * RAYPACKET_DIM );
2128  i++;
2129 
2130  if( (blockPos.x >= m_realBufferSize.x) && (blockPos.y >= m_realBufferSize.y) )
2131  break;
2132 
2133  if( (blockPos.x < m_realBufferSize.x) && (blockPos.y < m_realBufferSize.y) )
2134  m_blockPositions.push_back( blockPos );
2135  }
2136 
2137  // Create m_shader buffer
2138  delete[] m_shaderBuffer;
2140 
2141  opengl_init_pbo();
2142 }
#define RAYPACKET_DIM
Definition: raypacket.h:37
CPOSTSHADER_SSAO m_postshader_ssao
uint32_t DecodeMorton2X(uint32_t code)
Definition: mortoncodes.cpp:98
#define RAYPACKET_INVMASK
Definition: raypacket.h:39
uint32_t DecodeMorton2Y(uint32_t code)
glm::uvec2 SFVEC2UI
Definition: xv3d_types.h:41
wxSize m_windowSize
The window size that this camera is working.
std::vector< SFVEC2UI > m_blockPositionsFast
this encodes the Morton code positions (on fast preview mode)
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
std::vector< SFVEC2UI > m_blockPositions
this encodes the Morton code positions
void UpdateSize(const SFVEC2UI &aSize)
Definition: cpostshader.cpp:72
void C3D_RENDER_RAYTRACING::initializeNewWindowSize ( )
private

Definition at line 2024 of file c3d_render_raytracing.cpp.

References opengl_init_pbo().

Referenced by SetCurWindowSize().

2025 {
2026  opengl_init_pbo();
2027 }
bool C3D_RENDER_RAYTRACING::initializeOpenGL ( )
private

Definition at line 2059 of file c3d_render_raytracing.cpp.

References C3D_RENDER_BASE::m_is_opengl_initialized.

Referenced by Redraw().

2060 {
2061  m_is_opengl_initialized = true;
2062 
2063  return true;
2064 }
bool m_is_opengl_initialized
flag if the opengl specific for this render was already initialized
void C3D_RENDER_RAYTRACING::insert3DPadHole ( const D_PAD aPad)
private

Definition at line 1012 of file c3d_render_createscene.cpp.

References CGENERICCONTAINER2D::Add(), CGENERICCONTAINER::Add(), B_Cu, CINFO3D_VISU::BiuTo3Dunits(), ConvertSRGBToLinear(), CSGITEM_EMPTY, CSGITEM_FULL, F_Cu, FL_USE_REALISTIC_MODE, COBJECT2D::GetBBox(), CINFO3D_VISU::GetCopperThickness3DU(), CINFO3D_VISU::GetCopperThicknessBIU(), D_PAD::GetDrillSize(), CINFO3D_VISU::GetFlag(), CINFO3D_VISU::GetItemColor(), CINFO3D_VISU::GetLayerBottomZpos3DU(), CGENERICCONTAINER2D::GetList(), CBVHCONTAINER2D::GetListObjectsIntersects(), D_PAD::GetOrientation(), D_PAD::GetPosition(), CINFO3D_VISU::GetThroughHole_Inner(), COBJECT2D::Intersects(), LAYER_PADS_TH, m_containerWithObjectsToDelete, CINFO3D_VISU::m_CopperColor, m_materials, m_object_container, C3D_RENDER_BASE::m_settings, RotatePoint(), CLAYERITEM::SetColor(), COBJECT::SetMaterial(), wxPoint::x, and wxPoint::y.

Referenced by add_3D_vias_and_pads_to_container().

1013 {
1014  const COBJECT2D *object2d_A = NULL;
1015 
1016  SFVEC3F objColor;
1017 
1019  objColor = (SFVEC3F)m_settings.m_CopperColor;
1020  else
1021  objColor = m_settings.GetItemColor( LAYER_PADS_TH );
1022 
1023  const wxSize drillsize = aPad->GetDrillSize();
1024  const bool hasHole = drillsize.x && drillsize.y;
1025 
1026  if( !hasHole )
1027  return;
1028 
1029  const float topZ = m_settings.GetLayerBottomZpos3DU( F_Cu ) +
1031 
1032  const float botZ = m_settings.GetLayerBottomZpos3DU( B_Cu ) -
1034 
1035  if( drillsize.x == drillsize.y ) // usual round hole
1036  {
1037  SFVEC2F center = SFVEC2F( aPad->GetPosition().x * m_settings.BiuTo3Dunits(),
1038  -aPad->GetPosition().y * m_settings.BiuTo3Dunits() );
1039 
1040  CRING2D *ring = new CRING2D( center,
1041  ( drillsize.x / 2 ) * m_settings.BiuTo3Dunits(),
1042  ( ( drillsize.x / 2 ) +
1045  *aPad );
1046 
1048 
1049  object2d_A = ring;
1050  }
1051  else // Oblong hole
1052  {
1053  wxPoint ends_offset;
1054  int width;
1055 
1056  if( drillsize.x > drillsize.y ) // Horizontal oval
1057  {
1058  ends_offset.x = ( drillsize.x - drillsize.y ) / 2;
1059  width = drillsize.y;
1060  }
1061  else // Vertical oval
1062  {
1063  ends_offset.y = ( drillsize.y - drillsize.x ) / 2;
1064  width = drillsize.x;
1065  }
1066 
1067  RotatePoint( &ends_offset, aPad->GetOrientation() );
1068 
1069  wxPoint start = aPad->GetPosition() + ends_offset;
1070  wxPoint end = aPad->GetPosition() - ends_offset;
1071 
1072  CROUNDSEGMENT2D *innerSeg = new CROUNDSEGMENT2D(
1073  SFVEC2F( start.x * m_settings.BiuTo3Dunits(),
1074  -start.y * m_settings.BiuTo3Dunits() ),
1075  SFVEC2F( end.x * m_settings.BiuTo3Dunits(),
1076  -end.y * m_settings.BiuTo3Dunits() ),
1077  width * m_settings.BiuTo3Dunits(),
1078  *aPad );
1079 
1080  CROUNDSEGMENT2D *outterSeg = new CROUNDSEGMENT2D(
1081  SFVEC2F( start.x * m_settings.BiuTo3Dunits(),
1082  -start.y * m_settings.BiuTo3Dunits() ),
1083  SFVEC2F( end.x * m_settings.BiuTo3Dunits(),
1084  -end.y * m_settings.BiuTo3Dunits() ),
1085  ( width + m_settings.GetCopperThicknessBIU() * 2 ) *
1087  *aPad );
1088 
1089  // NOTE: the round segment width is the "diameter", so we double the thickness
1090 
1091  std::vector<const COBJECT2D *> *object2d_B = new std::vector<const COBJECT2D *>();
1092  object2d_B->push_back( innerSeg );
1093 
1094  CITEMLAYERCSG2D *itemCSG2d = new CITEMLAYERCSG2D( outterSeg,
1095  object2d_B,
1096  CSGITEM_FULL,
1097  *aPad );
1098 
1099  m_containerWithObjectsToDelete.Add( itemCSG2d );
1100  m_containerWithObjectsToDelete.Add( innerSeg );
1101  m_containerWithObjectsToDelete.Add( outterSeg );
1102 
1103  object2d_A = itemCSG2d;
1104  }
1105 
1106 
1107  if( object2d_A )
1108  {
1109  std::vector<const COBJECT2D *> *object2d_B = new std::vector<const COBJECT2D *>();
1110 
1111  // Check if there are any other THT that intersects this hole
1112  // It will use the non inflated holes
1113  if( !m_settings.GetThroughHole_Inner().GetList().empty() )
1114  {
1115 
1116  CONST_LIST_OBJECT2D intersectionList;
1118  intersectionList );
1119 
1120  if( !intersectionList.empty() )
1121  {
1122  for( CONST_LIST_OBJECT2D::const_iterator hole = intersectionList.begin();
1123  hole != intersectionList.end();
1124  ++hole )
1125  {
1126  const COBJECT2D *hole2d = static_cast<const COBJECT2D *>(*hole);
1127 
1128  if( object2d_A->Intersects( hole2d->GetBBox() ) )
1129  //if( object2d_A->GetBBox().Intersects( hole2d->GetBBox() ) )
1130  object2d_B->push_back( hole2d );
1131  }
1132  }
1133  }
1134 
1135  if( object2d_B->empty() )
1136  {
1137  delete object2d_B;
1138  object2d_B = CSGITEM_EMPTY;
1139  }
1140 
1141  if( object2d_B == CSGITEM_EMPTY )
1142  {
1143  CLAYERITEM *objPtr = new CLAYERITEM( object2d_A, topZ, botZ );
1144 
1145  objPtr->SetMaterial( &m_materials.m_Copper );
1146  objPtr->SetColor( ConvertSRGBToLinear( objColor ) );
1147  m_object_container.Add( objPtr );
1148  }
1149  else
1150  {
1151  CITEMLAYERCSG2D *itemCSG2d = new CITEMLAYERCSG2D( object2d_A,
1152  object2d_B,
1153  CSGITEM_FULL,
1154  (const BOARD_ITEM &)*aPad );
1155 
1156  m_containerWithObjectsToDelete.Add( itemCSG2d );
1157 
1158  CLAYERITEM *objPtr = new CLAYERITEM( itemCSG2d, topZ, botZ );
1159 
1160  objPtr->SetMaterial( &m_materials.m_Copper );
1161  objPtr->SetColor( ConvertSRGBToLinear( objColor ) );
1162 
1163  m_object_container.Add( objPtr );
1164  }
1165  }
1166 }
void GetListObjectsIntersects(const CBBOX2D &aBBox, CONST_LIST_OBJECT2D &aOutList) const override
GetListObjectsIntersects - Get a list of objects that intersects a bbox.
const LIST_OBJECT2D & GetList() const
Definition: ccontainer2d.h:62
SFVEC3F ConvertSRGBToLinear(const SFVEC3F &aSRGBcolor)
float GetCopperThickness3DU() const
GetCopperThickness3DU - Get the current copper layer thickness.
Definition: cinfo3d_visu.h:165
multilayer pads, usually with holes
Class BOARD_ITEM is a base class for any item which can be embedded within the BOARD container class...
SFVEC3D m_CopperColor
in realistic mode: copper color
Definition: cinfo3d_visu.h:509
SFVEC3F GetItemColor(int aItemId) const
GetItemColor - get the technical color of a layer.
std::list< const COBJECT2D * > CONST_LIST_OBJECT2D
Definition: ccontainer2d.h:37
void SetMaterial(const CMATERIAL *aMaterial)
Definition: cobject.h:62
int GetCopperThicknessBIU() const
GetCopperThicknessBIU - Get the current copper layer thickness.
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:317
const wxSize & GetDrillSize() const
Definition: class_pad.h:275
CINFO3D_VISU & m_settings
settings refrence in use for this render
#define CSGITEM_EMPTY
This class is used to make constructive solig geometry for items objects on layers.
glm::vec2 SFVEC2F
Definition: xv3d_types.h:45
float GetLayerBottomZpos3DU(PCB_LAYER_ID aLayerId) const
GetLayerBottomZpos3DU - Get the bottom z position.
Definition: cinfo3d_visu.h:287
CCONTAINER2D m_containerWithObjectsToDelete
This will store the list of created objects special for RT, that will be clear in the end...
#define CSGITEM_FULL
void SetColor(SFVEC3F aObjColor)
Definition: clayeritem.h:46
void Add(COBJECT *aObject)
Definition: ccontainer.h:52
const CBVHCONTAINER2D & GetThroughHole_Inner() const
GetThroughHole_Inner - Get the ThroughHole container.
Definition: cinfo3d_visu.h:350
struct C3D_RENDER_RAYTRACING::@31 m_materials
void Add(COBJECT2D *aObject)
Definition: ccontainer2d.h:51
bool GetFlag(DISPLAY3D_FLG aFlag) const
GetFlag - get a configuration status of a flag.
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
double GetOrientation() const
Function GetOrientation returns the rotation angle of the pad in tenths of degrees, but soon degrees.
Definition: class_pad.h:375
const CBBOX2D & GetBBox() const
Definition: cobject2d.h:121
const wxPoint GetPosition() const override
Definition: class_pad.h:220
virtual bool Intersects(const CBBOX2D &aBBox) const =0
Function Intersects.
double BiuTo3Dunits() const
BiuTo3Dunits - Board integer units To 3D units.
Definition: cinfo3d_visu.h:141
void C3D_RENDER_RAYTRACING::insert3DViaHole ( const VIA aVia)
private

Definition at line 972 of file c3d_render_createscene.cpp.

References CGENERICCONTAINER2D::Add(), CGENERICCONTAINER::Add(), CINFO3D_VISU::BiuTo3Dunits(), ConvertSRGBToLinear(), FL_USE_REALISTIC_MODE, CINFO3D_VISU::GetCopperThickness3DU(), CINFO3D_VISU::GetCopperThicknessBIU(), VIA::GetDrillValue(), CINFO3D_VISU::GetFlag(), CINFO3D_VISU::GetItemColor(), CINFO3D_VISU::GetLayerBottomZpos3DU(), TRACK::GetStart(), VIA::GetViaType(), LAYER_VIAS, VIA::LayerPair(), m_containerWithObjectsToDelete, CINFO3D_VISU::m_CopperColor, m_materials, m_object_container, C3D_RENDER_BASE::m_settings, CLAYERITEM::SetColor(), COBJECT::SetMaterial(), wxPoint::x, and wxPoint::y.

Referenced by add_3D_vias_and_pads_to_container().

973 {
974  PCB_LAYER_ID top_layer, bottom_layer;
975  int radiusBUI = (aVia->GetDrillValue() / 2);
976 
977  aVia->LayerPair( &top_layer, &bottom_layer );
978 
979  float topZ = m_settings.GetLayerBottomZpos3DU( top_layer ) +
981 
982  float botZ = m_settings.GetLayerBottomZpos3DU( bottom_layer ) -
984 
985  const SFVEC2F center = SFVEC2F( aVia->GetStart().x * m_settings.BiuTo3Dunits(),
986  -aVia->GetStart().y * m_settings.BiuTo3Dunits() );
987 
988  CRING2D *ring = new CRING2D( center,
989  radiusBUI * m_settings.BiuTo3Dunits(),
990  ( radiusBUI + m_settings.GetCopperThicknessBIU() ) *
992  *aVia );
993 
995 
996 
997  CLAYERITEM *objPtr = new CLAYERITEM( ring, topZ, botZ );
998 
999  objPtr->SetMaterial( &m_materials.m_Copper );
1000 
1003  else
1005 
1006  m_object_container.Add( objPtr );
1007 }
SFVEC3F ConvertSRGBToLinear(const SFVEC3F &aSRGBcolor)
float GetCopperThickness3DU() const
GetCopperThickness3DU - Get the current copper layer thickness.
Definition: cinfo3d_visu.h:165
SFVEC3D m_CopperColor
in realistic mode: copper color
Definition: cinfo3d_visu.h:509
SFVEC3F GetItemColor(int aItemId) const
GetItemColor - get the technical color of a layer.
void SetMaterial(const CMATERIAL *aMaterial)
Definition: cobject.h:62
int GetCopperThicknessBIU() const
GetCopperThicknessBIU - Get the current copper layer thickness.
CINFO3D_VISU & m_settings
settings refrence in use for this render
PCB_LAYER_ID
A quick note on layer IDs:
glm::vec2 SFVEC2F
Definition: xv3d_types.h:45
VIATYPE_T GetViaType() const
Definition: class_track.h:455
float GetLayerBottomZpos3DU(PCB_LAYER_ID aLayerId) const
GetLayerBottomZpos3DU - Get the bottom z position.
Definition: cinfo3d_visu.h:287
const wxPoint & GetStart() const
Definition: class_track.h:122
CCONTAINER2D m_containerWithObjectsToDelete
This will store the list of created objects special for RT, that will be clear in the end...
void SetColor(SFVEC3F aObjColor)
Definition: clayeritem.h:46
void Add(COBJECT *aObject)
Definition: ccontainer.h:52
void LayerPair(PCB_LAYER_ID *top_layer, PCB_LAYER_ID *bottom_layer) const
Function LayerPair Return the 2 layers used by the via (the via actually uses all layers between thes...
struct C3D_RENDER_RAYTRACING::@31 m_materials
void Add(COBJECT2D *aObject)
Definition: ccontainer2d.h:51
bool GetFlag(DISPLAY3D_FLG aFlag) const
GetFlag - get a configuration status of a flag.
int GetDrillValue() const
Function GetDrillValue "calculates" the drill value for vias (m-Drill if > 0, or default drill value ...
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
double BiuTo3Dunits() const
BiuTo3Dunits - Board integer units To 3D units.
Definition: cinfo3d_visu.h:141
bool C3D_RENDER_BASE::IsReloadRequestPending ( ) const
inlineinherited

IsReloadRequestPending - Query if there is a pending reload request.

Returns
true if it wants to reload, false if there is no reload pending

Definition at line 79 of file c3d_render_base.h.

References C3D_RENDER_BASE::GetWaitForEditingTimeOut(), and C3D_RENDER_BASE::m_reloadRequested.

Referenced by EDA_3D_CANVAS::IsReloadRequestPending().

79 { return m_reloadRequested; }
bool m_reloadRequested
!TODO: this must be reviewed in order to flag change types
void C3D_RENDER_RAYTRACING::load_3D_models ( )
private

Definition at line 1200 of file c3d_render_createscene.cpp.

References add_3D_models(), CINFO3D_VISU::BiuTo3Dunits(), CINFO3D_VISU::Get3DCacheManager(), CINFO3D_VISU::GetBoard(), S3D_CACHE::GetModel(), CINFO3D_VISU::GetModulesZcoord3DIU(), BOARD::m_Modules, C3D_RENDER_BASE::m_settings, MODULE::Next(), scale, CINFO3D_VISU::ShouldModuleBeDisplayed(), UNITS3D_TO_UNITSPCB, wxPoint::x, and wxPoint::y.

Referenced by reload().

1201 {
1202  // Go for all modules
1203  for( const MODULE* module = m_settings.GetBoard()->m_Modules;
1204  module;
1205  module = module->Next() )
1206  {
1207  if( (!module->Models().empty() ) &&
1208  m_settings.ShouldModuleBeDisplayed( (MODULE_ATTR_T)module->GetAttributes() ) )
1209  {
1210  double zpos = m_settings.GetModulesZcoord3DIU( module->IsFlipped() );
1211 
1212  wxPoint pos = module->GetPosition();
1213 
1214  glm::mat4 moduleMatrix = glm::mat4();
1215 
1216  moduleMatrix = glm::translate( moduleMatrix,
1217  SFVEC3F( pos.x * m_settings.BiuTo3Dunits(),
1218  -pos.y * m_settings.BiuTo3Dunits(),
1219  zpos ) );
1220 
1221  if( module->GetOrientation() )
1222  {
1223  moduleMatrix = glm::rotate( moduleMatrix,
1224  ( (float)(module->GetOrientation() / 10.0f) / 180.0f ) *
1225  glm::pi<float>(),
1226  SFVEC3F( 0.0f, 0.0f, 1.0f ) );
1227  }
1228 
1229 
1230  if( module->IsFlipped() )
1231  {
1232  moduleMatrix = glm::rotate( moduleMatrix,
1233  glm::pi<float>(),
1234  SFVEC3F( 0.0f, 1.0f, 0.0f ) );
1235 
1236  moduleMatrix = glm::rotate( moduleMatrix,
1237  glm::pi<float>(),
1238  SFVEC3F( 0.0f, 0.0f, 1.0f ) );
1239  }
1240 
1241  const double modelunit_to_3d_units_factor = m_settings.BiuTo3Dunits() *
1243 
1244  moduleMatrix = glm::scale( moduleMatrix,
1245  SFVEC3F( modelunit_to_3d_units_factor,
1246  modelunit_to_3d_units_factor,
1247  modelunit_to_3d_units_factor ) );
1248 
1249 
1250  // Get the list of model files for this model
1251  auto sM = module->Models().begin();
1252  auto eM = module->Models().end();
1253 
1254  while( sM != eM )
1255  {
1256  // get it from cache
1257  const S3DMODEL *modelPtr =
1258  m_settings.Get3DCacheManager()->GetModel( sM->m_Filename );
1259 
1260  // only add it if the return is not NULL
1261  if( modelPtr )
1262  {
1263  glm::mat4 modelMatrix = moduleMatrix;
1264 
1265  modelMatrix = glm::translate( modelMatrix,
1266  SFVEC3F( sM->m_Offset.x,
1267  sM->m_Offset.y,
1268  sM->m_Offset.z ) );
1269 
1270  modelMatrix = glm::rotate( modelMatrix,
1271  (float)-( sM->m_Rotation.z / 180.0f ) *
1272  glm::pi<float>(),
1273  SFVEC3F( 0.0f, 0.0f, 1.0f ) );
1274 
1275  modelMatrix = glm::rotate( modelMatrix,
1276  (float)-( sM->m_Rotation.y / 180.0f ) *
1277  glm::pi<float>(),
1278  SFVEC3F( 0.0f, 1.0f, 0.0f ) );
1279 
1280  modelMatrix = glm::rotate( modelMatrix,
1281  (float)-( sM->m_Rotation.x / 180.0f ) *
1282  glm::pi<float>(),
1283  SFVEC3F( 1.0f, 0.0f, 0.0f ) );
1284 
1285  modelMatrix = glm::scale( modelMatrix,
1286  SFVEC3F( sM->m_Scale.x,
1287  sM->m_Scale.y,
1288  sM->m_Scale.z ) );
1289 
1290  add_3D_models( modelPtr, modelMatrix );
1291  }
1292 
1293  ++sM;
1294  }
1295  }
1296  }
1297 }
S3D_CACHE * Get3DCacheManager() const
Get3DCacheManager - Return the 3d cache manager pointer.
Definition: cinfo3d_visu.h:88
MODULE * Next() const
Definition: class_module.h:121
CINFO3D_VISU & m_settings
settings refrence in use for this render
#define UNITS3D_TO_UNITSPCB
Scale convertion from 3d model units to pcb units.
S3DMODEL * GetModel(const wxString &aModelFileName)
Function GetModel attempts to load the scene data for a model and to translate it into an S3D_MODEL s...
Definition: 3d_cache.cpp:781
MODULE_ATTR_T
Enum MODULE_ATTR_T is the set of attributes allowed within a MODULE, using MODULE::SetAttributes() an...
Definition: class_module.h:74
void add_3D_models(const S3DMODEL *a3DModel, const glm::mat4 &aModelMatrix)
float GetModulesZcoord3DIU(bool aIsFlipped) const
GetModulesZcoord3DIU - Get the position of the module in 3d integer units considering if it is flippe...
const int scale
bool ShouldModuleBeDisplayed(MODULE_ATTR_T aModuleAttributs) const
ShouldModuleBeDisplayed - Test if module should be displayed in relation to attributs and the flags...
DLIST< MODULE > m_Modules
Definition: class_board.h:245
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
Store the a model based on meshes and materials.
Definition: c3dmodel.h:90
const BOARD * GetBoard() const
GetBoard - Get current board to be rendered.
Definition: cinfo3d_visu.h:128
double BiuTo3Dunits() const
BiuTo3Dunits - Board integer units To 3D units.
Definition: cinfo3d_visu.h:141
void C3D_RENDER_RAYTRACING::opengl_delete_pbo ( )
private

Definition at line 101 of file c3d_render_raytracing.cpp.

References m_opengl_support_vertex_buffer_object, and m_pboId.

Referenced by opengl_init_pbo(), and ~C3D_RENDER_RAYTRACING().

102 {
103  // Delete PBO if it was created
105  {
106  if( glIsBufferARB( m_pboId ) )
107  glDeleteBuffers( 1, &m_pboId );
108 
109  m_pboId = GL_NONE;
110  }
111 }
void C3D_RENDER_RAYTRACING::opengl_init_pbo ( )
private

Definition at line 2030 of file c3d_render_raytracing.cpp.

References C3D_RENDER_BASE::m_logTrace, m_opengl_support_vertex_buffer_object, m_pboDataSize, m_pboId, m_realBufferSize, and opengl_delete_pbo().

Referenced by initialize_block_positions(), and initializeNewWindowSize().

2031 {
2032  if( GLEW_ARB_pixel_buffer_object )
2033  {
2035 
2036  // Try to delete vbo if it was already initialized
2038 
2039  // Learn about Pixel buffer objects at:
2040  // http://www.songho.ca/opengl/gl_pbo.html
2041  // http://web.eecs.umich.edu/~sugih/courses/eecs487/lectures/25-PBO+Mipmapping.pdf
2042  // "create 2 pixel buffer objects, you need to delete them when program exits.
2043  // glBufferDataARB with NULL pointer reserves only memory space."
2044 
2045  // This sets the number of RGBA pixels
2047 
2048  glGenBuffersARB( 1, &m_pboId );
2049  glBindBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, m_pboId );
2050  glBufferDataARB( GL_PIXEL_UNPACK_BUFFER_ARB, m_pboDataSize, 0, GL_STREAM_DRAW_ARB );
2051  glBindBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, 0 );
2052 
2053  wxLogTrace( m_logTrace,
2054  wxT( "C3D_RENDER_RAYTRACING:: GLEW_ARB_pixel_buffer_object is supported" ) );
2055  }
2056 }
static const wxChar * m_logTrace
Trace mask used to enable or disable the trace output of this class.
bool C3D_RENDER_RAYTRACING::Redraw ( bool  aIsMoving,
REPORTER aStatusTextReporter 
)
overridevirtual

Redraw - Ask to redraw the view.

Parameters
aIsMovingif the user is moving the scene, it should be render in preview mode
aStatusTextReportera pointer to the status progress reporter
Returns
it will return true if the render would like to redraw again

Implements C3D_RENDER_BASE.

Definition at line 150 of file c3d_render_raytracing.cpp.

References CINFO3D_VISU::CameraGet(), dummy(), CCAMERA::GetDir(), initialize_block_positions(), initializeOpenGL(), CINFO3D_VISU::m_BgColorBot, CINFO3D_VISU::m_BgColorTop, m_camera_light, C3D_RENDER_BASE::m_is_opengl_initialized, m_oldWindowsSize, m_pboId, m_realBufferSize, C3D_RENDER_BASE::m_reloadRequested, m_rt_render_state, C3D_RENDER_BASE::m_settings, C3D_RENDER_BASE::m_windowSize, m_xoffset, m_yoffset, OGL_DrawBackground(), CCAMERA::ParametersChanged(), reload(), render(), render_preview(), REPORTER::Report(), RT_RENDER_STATE_FINISH, RT_RENDER_STATE_MAX, and CDIRECTIONALLIGHT::SetDirection().

151 {
152  bool requestRedraw = false;
153 
154  // Initialize openGL if need
155  // /////////////////////////////////////////////////////////////////////////
157  {
158  if( !initializeOpenGL() )
159  return false;
160 
161  //aIsMoving = true;
162  requestRedraw = true;
163 
164  // It will assign the first time the windows size, so it will now
165  // revert to preview mode the first time the Redraw is called
168  }
169 
170  wxBusyCursor dummy;
171 
172  // Reload board if it was requested
173  // /////////////////////////////////////////////////////////////////////////
174  if( m_reloadRequested )
175  {
176  if( aStatusTextReporter )
177  aStatusTextReporter->Report( _( "Loading..." ) );
178 
179  //aIsMoving = true;
180  requestRedraw = true;
181  reload( aStatusTextReporter );
182  }
183 
184 
185  // Recalculate constants if windows size was changed
186  // /////////////////////////////////////////////////////////////////////////
188  {
190  aIsMoving = true;
191  requestRedraw = true;
192 
194  }
195 
196 
197  // Clear buffers
198  // /////////////////////////////////////////////////////////////////////////
199  glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
200  glClearDepth( 1.0f );
201  glClearStencil( 0x00 );
202  glClear( GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
203 
204  // 4-byte pixel alignment
205  glPixelStorei( GL_UNPACK_ALIGNMENT, 4 );
206 
207  glDisable( GL_STENCIL_TEST );
208  glDisable( GL_LIGHTING );
209  glDisable( GL_COLOR_MATERIAL );
210  glDisable( GL_DEPTH_TEST );
211  glDisable( GL_TEXTURE_2D );
212  glDisable( GL_BLEND );
213 
214 
215  const bool was_camera_changed = m_settings.CameraGet().ParametersChanged();
216 
217  if( requestRedraw || aIsMoving || was_camera_changed )
218  m_rt_render_state = RT_RENDER_STATE_MAX; // Set to an invalid state,
219  // so it will restart again latter
220 
221 
222  // This will only render if need, otherwise it will redraw the PBO on the screen again
223  if( aIsMoving || was_camera_changed )
224  {
225  // Set head light (camera view light) with the oposite direction of the camera
226  if( m_camera_light )
228 
231 
232  // Bind PBO
233  glBindBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, m_pboId );
234 
235  // Get the PBO pixel pointer to write the data
236  GLubyte *ptrPBO = (GLubyte *)glMapBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB,
237  GL_WRITE_ONLY_ARB );
238 
239  if( ptrPBO )
240  {
241  render_preview( ptrPBO );
242 
243  // release pointer to mapping buffer, this initialize the coping to PBO
244  glUnmapBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB );
245  }
246 
247  glWindowPos2i( m_xoffset, m_yoffset );
248  }
249  else
250  {
251  // Bind PBO
252  glBindBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, m_pboId );
253 
255  {
256  // Get the PBO pixel pointer to write the data
257  GLubyte *ptrPBO = (GLubyte *)glMapBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB,
258  GL_WRITE_ONLY_ARB );
259 
260  if( ptrPBO )
261  {
262  render( ptrPBO, aStatusTextReporter );
263 
265  requestRedraw = true;
266 
267  // release pointer to mapping buffer, this initialize the coping to PBO
268  glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB);
269  }
270  }
271 
273  {
274  glClear( GL_COLOR_BUFFER_BIT );
275  // Options if we want draw background instead
276  //OGL_DrawBackground( SFVEC3F(m_settings.m_BgColorTop),
277  // SFVEC3F(m_settings.m_BgColorBot) );
278  }
279 
280  glWindowPos2i( m_xoffset, m_yoffset );
281  }
282 
283  // This way it will blend the progress rendering with the last buffer. eg:
284  // if it was called after a openGL.
285  glEnable( GL_BLEND );
286  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
287  glEnable( GL_ALPHA_TEST );
288 
289  glDrawPixels( m_realBufferSize.x,
291  GL_RGBA,
292  GL_UNSIGNED_BYTE,
293  0 );
294 
295  glBindBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, 0 );
296 
297  return requestRedraw;
298 }
wxSize m_oldWindowsSize
used to see if the windows size changed
SFVEC3D m_BgColorBot
background bottom color
Definition: cinfo3d_visu.h:503
const SFVEC3F & GetDir() const
Definition: ccamera.h:109
CINFO3D_VISU & m_settings
settings refrence in use for this render
SFVEC3D m_BgColorTop
background top color
Definition: cinfo3d_visu.h:504
void OGL_DrawBackground(const SFVEC3F &aTopColor, const SFVEC3F &aBotColor)
OGL_DrawBackground.
Definition: ogl_utils.cpp:176
bool m_is_opengl_initialized
flag if the opengl specific for this render was already initialized
RT_RENDER_STATE m_rt_render_state
State used on quality render.
wxSize m_windowSize
The window size that this camera is working.
CDIRECTIONALLIGHT * m_camera_light
void SetDirection(const SFVEC3F &aDir)
SetDirection - Set directional light orientation.
Definition: clight.h:129
bool m_reloadRequested
!TODO: this must be reviewed in order to flag change types
static LIB_PART * dummy()
Used when a LIB_PART is not found in library to draw a dummy shape This component is a 400 mils squar...
CCAMERA & CameraGet() const
CameraGet - get current camera in use.
Definition: cinfo3d_visu.h:210
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_UNDEFINED)=0
Function Report is a pure virtual function to override in the derived object.
void render_preview(GLubyte *ptrPBO)
void render(GLubyte *ptrPBO, REPORTER *aStatusTextReporter)
bool ParametersChanged()
Function ParametersChanged.
Definition: ccamera.cpp:567
void reload(REPORTER *aStatusTextReporter)
void C3D_RENDER_RAYTRACING::reload ( REPORTER aStatusTextReporter)
private

Definition at line 249 of file c3d_render_createscene.cpp.

References CGENERICCONTAINER2D::Add(), CGENERICCONTAINER::Add(), CLIGHTCONTAINER::Add(), add_3D_vias_and_pads_to_container(), B_Adhes, B_CrtYd, B_Cu, B_Fab, B_Mask, B_Paste, B_SilkS, CINFO3D_VISU::BiuTo3Dunits(), CINFO3D_VISU::CameraGet(), CGENERICCONTAINER2D::Clear(), CGENERICCONTAINER::Clear(), CLIGHTCONTAINER::Clear(), Cmts_User, Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(), ConvertSRGBToLinear(), create_3d_object_from(), CSGITEM_EMPTY, CSGITEM_FULL, Dwgs_User, Eco1_User, Eco2_User, Edge_Cuts, F_Adhes, F_CrtYd, F_Cu, F_Fab, F_Mask, F_Paste, F_SilkS, FL_RENDER_RAYTRACING_BACKFLOOR, FL_SHOW_BOARD_BODY, FL_SOLDERMASK, FL_USE_REALISTIC_MODE, Format(), SHAPE_POLY_SET::Fracture(), CGENERICCONTAINER::GetBBox(), COBJECT2D::GetBBox(), CINFO3D_VISU::GetBBox3DU(), CINFO3D_VISU::GetBoard(), CINFO3D_VISU::GetBoardCenter3DU(), COBJECT2D::GetBoardItem(), CINFO3D_VISU::GetBoardPoly(), CBBOX::GetCenter(), COBJECT2D::GetCentroid(), CBBOX2D::GetExtent(), CINFO3D_VISU::GetFlag(), CINFO3D_VISU::GetLayerBottomZpos3DU(), CINFO3D_VISU::GetLayerColor(), CINFO3D_VISU::GetLayerTopZpos3DU(), CGENERICCONTAINER2D::GetList(), CGENERICCONTAINER::GetList(), CBVHCONTAINER2D::GetListObjectsIntersects(), CINFO3D_VISU::GetMapLayers(), CINFO3D_VISU::GetMapLayersHoles(), COBJECT2D::GetObjectType(), GetRunningMicroSecs(), CINFO3D_VISU::GetStats_Med_Hole_Diameter3DU(), CINFO3D_VISU::GetStats_Med_Via_Hole_Diameter3DU(), CINFO3D_VISU::GetStats_Nr_Holes(), CINFO3D_VISU::GetStats_Nr_Vias(), CINFO3D_VISU::GetThroughHole_Outer(), CINFO3D_VISU::InitSettings(), COBJECT3D_STATS::Instance(), COBJECT2D_STATS::Instance(), COBJECT2D::Intersects(), CBBOX::IsInitialized(), load_3D_models(), m_accelerator, CINFO3D_VISU::m_BgColorTop, CINFO3D_VISU::m_BoardBodyColor, m_camera_light, m_containerWithObjectsToDelete, CINFO3D_VISU::m_CopperColor, m_lights, m_materials, m_model_materials, m_object_container, m_outlineBoard2dObjects, C3D_RENDER_BASE::m_reloadRequested, C3D_RENDER_BASE::m_settings, CINFO3D_VISU::m_SilkScreenColor, CINFO3D_VISU::m_SolderMaskColor, CINFO3D_VISU::m_SolderPasteColor, m_stats_converted_dummy_to_plane, m_stats_converted_roundsegment2d_to_roundsegment, Margin, min, CBBOX::Min(), NextFloatDown(), NextFloatUp(), OBJ2D_FILLED_CIRCLE, SHAPE_POLY_SET::PM_FAST, COBJECT3D_STATS::PrintStats(), COBJECT2D_STATS::PrintStats(), RANGE_SCALE_3D, REPORTER::Report(), COBJECT3D_STATS::ResetStats(), COBJECT2D_STATS::ResetStats(), CBBOX::Scale(), CCAMERA::SetBoardLookAtPos(), CLIGHT::SetCastShadows(), CLAYERITEM::SetColor(), CVCYLINDER::SetColor(), CTRIANGLE::SetColor(), COBJECT::SetMaterial(), setupMaterials(), and SphericalToCartesian().

Referenced by Redraw().

250 {
251  m_reloadRequested = false;
252 
253  m_model_materials.clear();
254 
257 
258 #ifdef PRINT_STATISTICS_3D_VIEWER
259  printf("InitSettings...\n");
260 #endif
261 
262  unsigned stats_startReloadTime = GetRunningMicroSecs();
263 
264  m_settings.InitSettings( aStatusTextReporter );
265 
266 #ifdef PRINT_STATISTICS_3D_VIEWER
267  unsigned stats_endReloadTime = GetRunningMicroSecs();
268  unsigned stats_startConvertTime = GetRunningMicroSecs();
269  #endif
270 
271  SFVEC3F camera_pos = m_settings.GetBoardCenter3DU();
272  m_settings.CameraGet().SetBoardLookAtPos( camera_pos );
273 
276 
277 
278  // Create and add the outline board
279  // /////////////////////////////////////////////////////////////////////////
280 
281 #ifdef PRINT_STATISTICS_3D_VIEWER
282  printf("Create outline board...\n");
283 #endif
284 
286 
288 
289  if( ((const SHAPE_POLY_SET &)m_settings.GetBoardPoly()).OutlineCount() == 1 )
290  {
291  float divFactor = 0.0f;
292 
294  divFactor = m_settings.GetStats_Med_Via_Hole_Diameter3DU() * 18.0f;
295  else
297  divFactor = m_settings.GetStats_Med_Hole_Diameter3DU() * 8.0f;
298 
299  SHAPE_POLY_SET boardPolyCopy = m_settings.GetBoardPoly();
300  boardPolyCopy.Fracture( SHAPE_POLY_SET::PM_FAST );
301 
303  boardPolyCopy,
306  divFactor,
307  (const BOARD_ITEM &)*m_settings.GetBoard() );
308 
310  {
311  const LIST_OBJECT2D &listObjects = m_outlineBoard2dObjects->GetList();
312 
313  for( LIST_OBJECT2D::const_iterator object2d_iterator = listObjects.begin();
314  object2d_iterator != listObjects.end();
315  ++object2d_iterator )
316  {
317  const COBJECT2D *object2d_A = static_cast<const COBJECT2D *>(*object2d_iterator);
318 
319  std::vector<const COBJECT2D *> *object2d_B = new std::vector<const COBJECT2D *>();
320 
321  // Check if there are any THT that intersects this outline object part
322  if( !m_settings.GetThroughHole_Outer().GetList().empty() )
323  {
324 
325  CONST_LIST_OBJECT2D intersectionList;
327  object2d_A->GetBBox(),
328  intersectionList );
329 
330  if( !intersectionList.empty() )
331  {
332  for( CONST_LIST_OBJECT2D::const_iterator hole = intersectionList.begin();
333  hole != intersectionList.end();
334  ++hole )
335  {
336  const COBJECT2D *hole2d = static_cast<const COBJECT2D *>(*hole);
337 
338  if( object2d_A->Intersects( hole2d->GetBBox() ) )
339  //if( object2d_A->GetBBox().Intersects( hole2d->GetBBox() ) )
340  object2d_B->push_back( hole2d );
341  }
342  }
343  }
344 
345  if( object2d_B->empty() )
346  {
347  delete object2d_B;
348  object2d_B = CSGITEM_EMPTY;
349  }
350 
351  if( object2d_B == CSGITEM_EMPTY )
352  {
353  #if 0
357  &m_materials.m_EpoxyBoard,
358  g_epoxyColor );
359  #else
360  CLAYERITEM *objPtr = new CLAYERITEM( object2d_A,
363 
364  objPtr->SetMaterial( &m_materials.m_EpoxyBoard );
365  objPtr->SetColor( ConvertSRGBToLinear( (SFVEC3F)m_settings.m_BoardBodyColor ) );
366  m_object_container.Add( objPtr );
367  #endif
368  }
369  else
370  {
371  CITEMLAYERCSG2D *itemCSG2d = new CITEMLAYERCSG2D(
372  object2d_A,
373  object2d_B,
374  CSGITEM_FULL,
375  (const BOARD_ITEM &)*m_settings.GetBoard() );
376 
377  m_containerWithObjectsToDelete.Add( itemCSG2d );
378 
379  CLAYERITEM *objPtr = new CLAYERITEM( itemCSG2d,
382 
383  objPtr->SetMaterial( &m_materials.m_EpoxyBoard );
385  m_object_container.Add( objPtr );
386  }
387  }
388 
389  // Add cylinders of the board body to container
390  // Note: This is actually a workarround for the holes in the board.
391  // The issue is because if a hole is in a border of a divided polygon ( ex
392  // a polygon or dummyblock) it will cut also the render of the hole.
393  // So this will add a full hole.
394  // In fact, that is not need if the hole have copper.
395  // /////////////////////////////////////////////////////////////////////////
396  if( !m_settings.GetThroughHole_Outer().GetList().empty() )
397  {
399 
400  for( LIST_OBJECT2D::const_iterator hole = holeList.begin();
401  hole != holeList.end();
402  ++hole )
403  {
404  const COBJECT2D *hole2d = static_cast<const COBJECT2D *>(*hole);
405 
406  switch( hole2d->GetObjectType() )
407  {
408  case OBJ2D_FILLED_CIRCLE:
409  {
410  const float radius = hole2d->GetBBox().GetExtent().x * 0.5f * 0.999f;
411 
412  CVCYLINDER *objPtr = new CVCYLINDER(
413  hole2d->GetCentroid(),
416  radius );
417 
418  objPtr->SetMaterial( &m_materials.m_EpoxyBoard );
420 
421  m_object_container.Add( objPtr );
422  }
423  break;
424 
425  default:
426  break;
427  }
428  }
429  }
430  }
431  }
432 
433 
434  // Add layers maps (except B_Mask and F_Mask)
435  // /////////////////////////////////////////////////////////////////////////
436 
437 #ifdef PRINT_STATISTICS_3D_VIEWER
438  printf("Add layers maps...\n");
439 #endif
440 
441  for( MAP_CONTAINER_2D::const_iterator ii = m_settings.GetMapLayers().begin();
442  ii != m_settings.GetMapLayers().end();
443  ++ii )
444  {
445  PCB_LAYER_ID layer_id = static_cast<PCB_LAYER_ID>(ii->first);
446 
447  // Mask kayers are not processed here because they are a special case
448  if( (layer_id == B_Mask) || (layer_id == F_Mask) )
449  continue;
450 
451  CMATERIAL *materialLayer = &m_materials.m_SilkS;
452  SFVEC3F layerColor = SFVEC3F( 0.0f, 0.0f, 0.0f );
453 
454  switch( layer_id )
455  {
456  case B_Adhes:
457  case F_Adhes:
458  break;
459 
460  case B_Paste:
461  case F_Paste:
462  materialLayer = &m_materials.m_Paste;
463 
465  layerColor = m_settings.m_SolderPasteColor;
466  else
467  layerColor = m_settings.GetLayerColor( layer_id );
468  break;
469 
470  case B_SilkS:
471  case F_SilkS:
472  materialLayer = &m_materials.m_SilkS;
473 
475  layerColor = m_settings.m_SilkScreenColor;
476  else
477  layerColor = m_settings.GetLayerColor( layer_id );
478  break;
479 
480  case Dwgs_User:
481  case Cmts_User:
482  case Eco1_User:
483  case Eco2_User:
484  case Edge_Cuts:
485  case Margin:
486  break;
487 
488  case B_CrtYd:
489  case F_CrtYd:
490  break;
491 
492  case B_Fab:
493  case F_Fab:
494  break;
495 
496  default:
497  materialLayer = &m_materials.m_Copper;
498 
500  layerColor = m_settings.m_CopperColor;
501  else
502  layerColor = m_settings.GetLayerColor( layer_id );
503  break;
504  }
505 
506  const CBVHCONTAINER2D *container2d = static_cast<const CBVHCONTAINER2D *>(ii->second);
507  const LIST_OBJECT2D &listObject2d = container2d->GetList();
508 
509  for( LIST_OBJECT2D::const_iterator itemOnLayer = listObject2d.begin();
510  itemOnLayer != listObject2d.end();
511  ++itemOnLayer )
512  {
513  const COBJECT2D *object2d_A = static_cast<const COBJECT2D *>(*itemOnLayer);
514 
515  // not yet used / implemented (can be used in future to clip the objects in the board borders
516  COBJECT2D *object2d_C = CSGITEM_FULL;
517 
518  std::vector<const COBJECT2D *> *object2d_B = CSGITEM_EMPTY;
519 
520  if( true ) // previously, was a option, now holes are always drawn in zones
521  {
522  object2d_B = new std::vector<const COBJECT2D *>();
523 
524  // Check if there are any layerhole that intersects this object
525  // Eg: a segment is cutted by a via hole or THT hole.
526  // /////////////////////////////////////////////////////////////
527  const MAP_CONTAINER_2D &layerHolesMap = m_settings.GetMapLayersHoles();
528 
529  if( layerHolesMap.find(layer_id) != layerHolesMap.end() )
530  {
531  MAP_CONTAINER_2D::const_iterator ii_hole = layerHolesMap.find(layer_id);
532 
533  const CBVHCONTAINER2D *containerLayerHoles2d =
534  static_cast<const CBVHCONTAINER2D *>(ii_hole->second);
535 
536 
537  CONST_LIST_OBJECT2D intersectionList;
538  containerLayerHoles2d->GetListObjectsIntersects( object2d_A->GetBBox(),
539  intersectionList );
540 
541  if( !intersectionList.empty() )
542  {
543  for( CONST_LIST_OBJECT2D::const_iterator holeOnLayer =
544  intersectionList.begin();
545  holeOnLayer != intersectionList.end();
546  ++holeOnLayer )
547  {
548  const COBJECT2D *hole2d = static_cast<const COBJECT2D *>(*holeOnLayer);
549 
550  //if( object2d_A->Intersects( hole2d->GetBBox() ) )
551  //if( object2d_A->GetBBox().Intersects( hole2d->GetBBox() ) )
552  object2d_B->push_back( hole2d );
553  }
554  }
555  }
556 
557  // Check if there are any THT that intersects this object
558  // /////////////////////////////////////////////////////////////
559  if( !m_settings.GetThroughHole_Outer().GetList().empty() )
560  {
561  CONST_LIST_OBJECT2D intersectionList;
562 
564  object2d_A->GetBBox(),
565  intersectionList );
566 
567  if( !intersectionList.empty() )
568  {
569  for( CONST_LIST_OBJECT2D::const_iterator hole = intersectionList.begin();
570  hole != intersectionList.end();
571  ++hole )
572  {
573  const COBJECT2D *hole2d = static_cast<const COBJECT2D *>(*hole);
574 
575  //if( object2d_A->Intersects( hole2d->GetBBox() ) )
576  //if( object2d_A->GetBBox().Intersects( hole2d->GetBBox() ) )
577  object2d_B->push_back( hole2d );
578  }
579  }
580  }
581 
582  if( object2d_B->empty() )
583  {
584  delete object2d_B;
585  object2d_B = CSGITEM_EMPTY;
586  }
587  }
588 
589  if( (object2d_B == CSGITEM_EMPTY) &&
590  (object2d_C == CSGITEM_FULL) )
591  {
592 #if 0
594  object2d_A,
595  m_settings.GetLayerBottomZpos3DU( layer_id ),
596  m_settings.GetLayerTopZpos3DU( layer_id ),
597  materialLayer,
598  layerColor );
599 #else
600  CLAYERITEM *objPtr = new CLAYERITEM( object2d_A,
601  m_settings.GetLayerBottomZpos3DU( layer_id ),
602  m_settings.GetLayerTopZpos3DU( layer_id ) );
603  objPtr->SetMaterial( materialLayer );
604  objPtr->SetColor( ConvertSRGBToLinear( layerColor ) );
605  m_object_container.Add( objPtr );
606 #endif
607  }
608  else
609  {
610 #if 1
611  CITEMLAYERCSG2D *itemCSG2d = new CITEMLAYERCSG2D( object2d_A,
612  object2d_B,
613  object2d_C,
614  object2d_A->GetBoardItem() );
615  m_containerWithObjectsToDelete.Add( itemCSG2d );
616 
617  CLAYERITEM *objPtr = new CLAYERITEM( itemCSG2d,
618  m_settings.GetLayerBottomZpos3DU( layer_id ),
619  m_settings.GetLayerTopZpos3DU( layer_id ) );
620 
621  objPtr->SetMaterial( materialLayer );
622  objPtr->SetColor( ConvertSRGBToLinear( layerColor ) );
623 
624  m_object_container.Add( objPtr );
625 #endif
626  }
627  }
628  }// for each layer on map
629 
630 
631 
632  // Add Mask layer
633  // Solder mask layers are "negative" layers so the elements that we have
634  // (in the container) should remove the board outline.
635  // We will check for all objects in the outline if it intersects any object
636  // in the layer container and also any hole.
637  // /////////////////////////////////////////////////////////////////////////
639  (m_outlineBoard2dObjects->GetList().size() >= 1) )
640  {
641  CMATERIAL *materialLayer = &m_materials.m_SolderMask;
642 
643  for( MAP_CONTAINER_2D::const_iterator ii = m_settings.GetMapLayers().begin();
644  ii != m_settings.GetMapLayers().end();
645  ++ii )
646  {
647  PCB_LAYER_ID layer_id = static_cast<PCB_LAYER_ID>(ii->first);
648 
649  const CBVHCONTAINER2D *containerLayer2d =
650  static_cast<const CBVHCONTAINER2D *>(ii->second);
651 
652  // Only get the Solder mask layers
653  if( !((layer_id == B_Mask) || (layer_id == F_Mask)) )
654  continue;
655 
656  SFVEC3F layerColor;
658  layerColor = m_settings.m_SolderMaskColor;
659  else
660  layerColor = m_settings.GetLayerColor( layer_id );
661 
662  const float zLayerMin = m_settings.GetLayerBottomZpos3DU( layer_id );
663  const float zLayerMax = m_settings.GetLayerTopZpos3DU( layer_id );
664 
665  // Get the outline board objects
666  const LIST_OBJECT2D &listObjects = m_outlineBoard2dObjects->GetList();
667 
668  for( LIST_OBJECT2D::const_iterator object2d_iterator = listObjects.begin();
669  object2d_iterator != listObjects.end();
670  ++object2d_iterator )
671  {
672  const COBJECT2D *object2d_A = static_cast<const COBJECT2D *>(*object2d_iterator);
673 
674  std::vector<const COBJECT2D *> *object2d_B = new std::vector<const COBJECT2D *>();
675 
676  // Check if there are any THT that intersects this outline object part
677  if( !m_settings.GetThroughHole_Outer().GetList().empty() )
678  {
679 
680  CONST_LIST_OBJECT2D intersectionList;
681 
683  object2d_A->GetBBox(),
684  intersectionList );
685 
686  if( !intersectionList.empty() )
687  {
688  for( CONST_LIST_OBJECT2D::const_iterator hole = intersectionList.begin();
689  hole != intersectionList.end();
690  ++hole )
691  {
692  const COBJECT2D *hole2d = static_cast<const COBJECT2D *>(*hole);
693 
694  if( object2d_A->Intersects( hole2d->GetBBox() ) )
695  //if( object2d_A->GetBBox().Intersects( hole2d->GetBBox() ) )
696  object2d_B->push_back( hole2d );
697  }
698  }
699  }
700 
701  // Check if there are any objects in the layer to subtract with the
702  // corrent object
703  if( !containerLayer2d->GetList().empty() )
704  {
705  CONST_LIST_OBJECT2D intersectionList;
706 
707  containerLayer2d->GetListObjectsIntersects( object2d_A->GetBBox(),
708  intersectionList );
709 
710  if( !intersectionList.empty() )
711  {
712  for( CONST_LIST_OBJECT2D::const_iterator obj = intersectionList.begin();
713  obj != intersectionList.end();
714  ++obj )
715  {
716  const COBJECT2D *obj2d = static_cast<const COBJECT2D *>(*obj);
717 
718  //if( object2d_A->Intersects( obj2d->GetBBox() ) )
719  //if( object2d_A->GetBBox().Intersects( obj2d->GetBBox() ) )
720  object2d_B->push_back( obj2d );
721  }
722  }
723  }
724 
725  if( object2d_B->empty() )
726  {
727  delete object2d_B;
728  object2d_B = CSGITEM_EMPTY;
729  }
730 
731  if( object2d_B == CSGITEM_EMPTY )
732  {
733  #if 0
735  object2d_A,
736  zLayerMin,
737  zLayerMax,
738  materialLayer,
739  layerColor );
740  #else
741  CLAYERITEM *objPtr = new CLAYERITEM( object2d_A,
742  zLayerMin,
743  zLayerMax );
744 
745  objPtr->SetMaterial( materialLayer );
746  objPtr->SetColor( ConvertSRGBToLinear( layerColor ) );
747 
748  m_object_container.Add( objPtr );
749  #endif
750  }
751  else
752  {
753  CITEMLAYERCSG2D *itemCSG2d = new CITEMLAYERCSG2D( object2d_A,
754  object2d_B,
755  CSGITEM_FULL,
756  object2d_A->GetBoardItem() );
757 
758  m_containerWithObjectsToDelete.Add( itemCSG2d );
759 
760  CLAYERITEM *objPtr = new CLAYERITEM( itemCSG2d,
761  zLayerMin,
762  zLayerMax );
763  objPtr->SetMaterial( materialLayer );
764  objPtr->SetColor( ConvertSRGBToLinear( layerColor ) );
765 
766  m_object_container.Add( objPtr );
767  }
768  }
769  }
770  }
771 
773 
774 #ifdef PRINT_STATISTICS_3D_VIEWER
775  unsigned stats_endConvertTime = GetRunningMicroSecs();
776  unsigned stats_startLoad3DmodelsTime = stats_endConvertTime;
777 #endif
778 
779 
780  load_3D_models();
781 
782 
783 #ifdef PRINT_STATISTICS_3D_VIEWER
784  unsigned stats_endLoad3DmodelsTime = GetRunningMicroSecs();
785 #endif
786 
787  // Add floor
788  // /////////////////////////////////////////////////////////////////////////
790  {
791  CBBOX boardBBox = m_settings.GetBBox3DU();
792 
793  if( boardBBox.IsInitialized() )
794  {
795  boardBBox.Scale( 3.0f );
796 
797  if( m_object_container.GetList().size() > 0 )
798  {
799  CBBOX containerBBox = m_object_container.GetBBox();
800 
801  containerBBox.Scale( 1.3f );
802 
803  const SFVEC3F centerBBox = containerBBox.GetCenter();
804 
805  const float minZ = glm::min( containerBBox.Min().z,
806  boardBBox.Min().z );
807 
808  const SFVEC3F v1 = SFVEC3F( -RANGE_SCALE_3D * 4.0f,
809  -RANGE_SCALE_3D * 4.0f,
810  minZ ) +
811  SFVEC3F( centerBBox.x,
812  centerBBox.y,
813  0.0f );
814 
815  const SFVEC3F v3 = SFVEC3F( +RANGE_SCALE_3D * 4.0f,
816  +RANGE_SCALE_3D * 4.0f,
817  minZ ) +
818  SFVEC3F( centerBBox.x,
819  centerBBox.y,
820  0.0f );
821 
822  const SFVEC3F v2 = SFVEC3F( v1.x, v3.y, v1.z );
823  const SFVEC3F v4 = SFVEC3F( v3.x, v1.y, v1.z );
824 
825  CTRIANGLE *newTriangle1 = new CTRIANGLE( v1, v2, v3 );
826  CTRIANGLE *newTriangle2 = new CTRIANGLE( v3, v4, v1 );
827 
828  m_object_container.Add( newTriangle1 );
829  m_object_container.Add( newTriangle2 );
830 
831  newTriangle1->SetMaterial( (const CMATERIAL *)&m_materials.m_Floor );
832  newTriangle2->SetMaterial( (const CMATERIAL *)&m_materials.m_Floor );
833 
836  }
837  }
838  }
839 
840 
841  // Init initial lights
842  // /////////////////////////////////////////////////////////////////////////
843  m_lights.Clear();
844 
845  // This will work as the front camera light.
846  const float light_camera_intensity = 0.20;
847  const float light_top_bottom = 0.25;
848  const float light_directional_intensity = ( 1.0f - ( light_camera_intensity +
849  light_top_bottom * 0.5f ) ) / 4.0f;
850 
851  m_camera_light = new CDIRECTIONALLIGHT( SFVEC3F( 0.0f, 0.0f, 0.0f ),
852  SFVEC3F( light_camera_intensity ) );
853  m_camera_light->SetCastShadows( false );
855 
856  // Option 1 - using Point Lights
857 
858  const SFVEC3F &boarCenter = m_settings.GetBBox3DU().GetCenter();
859 
860  m_lights.Add( new CPOINTLIGHT( SFVEC3F( boarCenter.x, boarCenter.y, +RANGE_SCALE_3D * 2.0f ),
861  SFVEC3F( light_top_bottom ) ) );
862 
863  m_lights.Add( new CPOINTLIGHT( SFVEC3F( boarCenter.x, boarCenter.y, -RANGE_SCALE_3D * 2.0f ),
864  SFVEC3F( light_top_bottom ) ) );
865 
866 
867  // http://www.flashandmath.com/mathlets/multicalc/coords/shilmay23fin.html
868 
869  // Option 2 - Top/Bottom direction lights
870  /*
871  m_lights.Add( new CDIRECTIONALLIGHT( SphericalToCartesian( glm::pi<float>() * 0.03f,
872  glm::pi<float>() * 0.25f ),
873  SFVEC3F( light_top_bottom ) ) );
874 
875  m_lights.Add( new CDIRECTIONALLIGHT( SphericalToCartesian( glm::pi<float>() * 0.97f,
876  glm::pi<float>() * 1.25f ),
877  SFVEC3F( light_top_bottom ) ) );
878  */
879 
880  m_lights.Add( new CDIRECTIONALLIGHT( SphericalToCartesian( glm::pi<float>() * 1.0f / 8.0f,
881  glm::pi<float>() * 1 / 4.0f ),
882  SFVEC3F( light_directional_intensity ) ) );
883  m_lights.Add( new CDIRECTIONALLIGHT( SphericalToCartesian( glm::pi<float>() * 1.0f / 8.0f,
884  glm::pi<float>() * 3 / 4.0f ),
885  SFVEC3F( light_directional_intensity ) ) );
886  m_lights.Add( new CDIRECTIONALLIGHT( SphericalToCartesian( glm::pi<float>() * 1.0f / 8.0f,
887  glm::pi<float>() * 5 / 4.0f ),
888  SFVEC3F( light_directional_intensity ) ) );
889  m_lights.Add( new CDIRECTIONALLIGHT( SphericalToCartesian( glm::pi<float>() * 1.0f / 8.0f,
890  glm::pi<float>() * 7 / 4.0f ),
891  SFVEC3F( light_directional_intensity ) ) );
892 
893 
894  m_lights.Add( new CDIRECTIONALLIGHT( SphericalToCartesian( glm::pi<float>() * 7.0f / 8.0f,
895  glm::pi<float>() * 1 / 4.0f ),
896  SFVEC3F( light_directional_intensity ) ) );
897  m_lights.Add( new CDIRECTIONALLIGHT( SphericalToCartesian( glm::pi<float>() * 7.0f / 8.0f,
898  glm::pi<float>() * 3 / 4.0f ),
899  SFVEC3F( light_directional_intensity ) ) );
900  m_lights.Add( new CDIRECTIONALLIGHT( SphericalToCartesian( glm::pi<float>() * 7.0f / 8.0f,
901  glm::pi<float>() * 5 / 4.0f ),
902  SFVEC3F( light_directional_intensity ) ) );
903  m_lights.Add( new CDIRECTIONALLIGHT( SphericalToCartesian( glm::pi<float>() * 7.0f / 8.0f,
904  glm::pi<float>() * 7 / 4.0f ),
905  SFVEC3F( light_directional_intensity ) ) );
906 
907 
908  // Create an accelerator
909  // /////////////////////////////////////////////////////////////////////////
910 
911 #ifdef PRINT_STATISTICS_3D_VIEWER
912  unsigned stats_startAcceleratorTime = GetRunningMicroSecs();
913 #endif
914 
915  if( m_accelerator )
916  {
917  delete m_accelerator;
918  }
919  m_accelerator = 0;
920 
921  //m_accelerator = new CGRID( m_object_container );
923 
924 #ifdef PRINT_STATISTICS_3D_VIEWER
925  unsigned stats_endAcceleratorTime = GetRunningMicroSecs();
926 #endif
927 
928  setupMaterials();
929 
930 #ifdef PRINT_STATISTICS_3D_VIEWER
931  printf( "C3D_RENDER_RAYTRACING::reload times:\n" );
932  printf( " Reload board: %.3f ms\n", (float)( stats_endReloadTime -
933  stats_startReloadTime ) /
934 
935  1000.0f );
936  printf( " Convert to 3D objects: %.3f ms\n", (float)( stats_endConvertTime -
937  stats_startConvertTime ) /
938  1000.0f );
939  printf( " Accelerator construction: %.3f ms\n", (float)( stats_endAcceleratorTime -
940  stats_startAcceleratorTime ) /
941  1000.0f );
942  printf( " Load and add 3D models: %.3f ms\n", (float)( stats_endLoad3DmodelsTime -
943  stats_startLoad3DmodelsTime ) /
944  1000.0f );
945  printf( "Optimizations\n" );
946 
947  printf( " m_stats_converted_dummy_to_plane: %u\n",
949 
950  printf( " m_stats_converted_roundsegment2d_to_roundsegment: %u\n",
952 
955 #endif
956 
957  if( aStatusTextReporter )
958  {
959  // Calculation time in seconds
960  const double calculation_time = (double)( GetRunningMicroSecs() -
961  stats_startReloadTime ) / 1e6;
962 
963  aStatusTextReporter->Report( wxString::Format( _( "Reload time %.3f s" ),
964  calculation_time ) );
965  }
966 }
std::map< PCB_LAYER_ID, CBVHCONTAINER2D * > MAP_CONTAINER_2D
A type that stores a container of 2d objects for each layer id.
Definition: cinfo3d_visu.h:55
void GetListObjectsIntersects(const CBBOX2D &aBBox, CONST_LIST_OBJECT2D &aOutList) const override
GetListObjectsIntersects - Get a list of objects that intersects a bbox.
const LIST_OBJECT2D & GetList() const
Definition: ccontainer2d.h:62
SFVEC3F GetLayerColor(PCB_LAYER_ID aLayerId) const
GetLayerColor - get the technical color of a layer.
SFVEC3F ConvertSRGBToLinear(const SFVEC3F &aSRGBcolor)
Directional light - a light based only on a direction vector.
Definition: clight.h:114
void PrintStats()
Definition: cobject2d.cpp:60
Class BOARD_ITEM is a base class for any item which can be embedded within the BOARD container class...
A base material class that can be used to derive a material implementation.
Definition: cmaterial.h:167
SFVEC3D m_CopperColor
in realistic mode: copper color
Definition: cinfo3d_visu.h:509
const SHAPE_POLY_SET & GetBoardPoly() const
GetBoardPoly - Get the current polygon of the epoxy board.
Definition: cinfo3d_visu.h:252
void create_3d_object_from(CCONTAINER &aDstContainer, const COBJECT2D *aObject2D, float aZMin, float aZMax, const CMATERIAL *aMaterial, const SFVEC3F &aObjColor)
Function create_3d_object_from.
std::list< const COBJECT2D * > CONST_LIST_OBJECT2D
Definition: ccontainer2d.h:37
const BOARD_ITEM & GetBoardItem() const
Definition: cobject2d.h:75
const SFVEC3F & Min() const
Function Min return the minimun vertex pointer.
Definition: cbbox.h:205
void SetMaterial(const CMATERIAL *aMaterial)
Definition: cobject.h:62
bool IsInitialized() const
Function IsInitialized check if this bounding box is already initialized.
Definition: cbbox.cpp:87
#define RANGE_SCALE_3D
This defines the range that all coord will have to be rendered.
Definition: cinfo3d_visu.h:63
float GetStats_Med_Via_Hole_Diameter3DU() const
GetStats_Med_Via_Hole_Diameter3DU - Average diameter of the via holes.
Definition: cinfo3d_visu.h:374
void PrintStats()
Definition: cobject.cpp:57
CINFO3D_VISU & m_settings
settings refrence in use for this render
float GetLayerTopZpos3DU(PCB_LAYER_ID aLayerId) const
GetLayerTopZpos3DU - Get the top z position.
Definition: cinfo3d_visu.h:280
SFVEC3D m_BgColorTop
background top color
Definition: cinfo3d_visu.h:504
SFVEC3D m_BoardBodyColor
in realistic mode: FR4 board color
Definition: cinfo3d_visu.h:505
unsigned int m_stats_converted_dummy_to_plane
#define CSGITEM_EMPTY
This class is used to make constructive solig geometry for items objects on layers.
CGENERICACCELERATOR * m_accelerator
void SetColor(const SFVEC3F &aColor)
Definition: ctriangle.cpp:161
const MAP_CONTAINER_2D & GetMapLayersHoles() const
GetMapLayersHoles -Get the map of container that have the holes per layer.
Definition: cinfo3d_visu.h:299
PCB_LAYER_ID
A quick note on layer IDs:
void SetColor(SFVEC3F aObjColor)
Definition: ccylinder.h:51
const SFVEC3F & GetBoardCenter3DU() const
GetBoardCenter - the board center position in 3d units.
Definition: cinfo3d_visu.h:189
float NextFloatDown(float v)
Definition: 3d_fastmath.h:157
float GetLayerBottomZpos3DU(PCB_LAYER_ID aLayerId) const
GetLayerBottomZpos3DU - Get the bottom z position.
Definition: cinfo3d_visu.h:287
Class SHAPE_POLY_SET.
CCONTAINER2D m_containerWithObjectsToDelete
This will store the list of created objects special for RT, that will be clear in the end...
void Add(CLIGHT *aLight)
Add - Add a light to the container.
Definition: clight.h:186
OBJECT2D_TYPE GetObjectType() const
Definition: cobject2d.h:125
Point light based on: http://ogldev.atspace.co.uk/www/tutorial20/tutorial20.html. ...
Definition: clight.h:67
unsigned int m_stats_converted_roundsegment2d_to_roundsegment
#define CSGITEM_FULL
void SetColor(SFVEC3F aObjColor)
Definition: clayeritem.h:46
SFVEC3D m_SolderPasteColor
in realistic mode: solder paste color
Definition: cinfo3d_visu.h:507
A triangle object.
Definition: ctriangle.h:42
CDIRECTIONALLIGHT * m_camera_light
void Add(COBJECT *aObject)
Definition: ccontainer.h:52
SFVEC3D m_SolderMaskColor
in realistic mode: solder mask color
Definition: cinfo3d_visu.h:506
const CBBOX & GetBBox() const
Definition: ccontainer.h:67
void Fracture(POLYGON_MODE aFastMode)
Converts a set of polygons with holes to a singe outline with "slits"/"fractures" connecting the oute...
static COBJECT2D_STATS & Instance()
Definition: cobject2d.h:146
void Scale(float aScale)
Function Scale scales a bounding box by its center.
Definition: cbbox.cpp:194
A vertical cylinder.
Definition: ccylinder.h:38
SFVEC3F GetCenter() const
Function GetCenter return the center point of the bounding box.
Definition: cbbox.cpp:135
struct C3D_RENDER_RAYTRACING::@31 m_materials
void ResetStats()
Definition: cobject.h:106
void Add(COBJECT2D *aObject)
Definition: ccontainer2d.h:51
bool GetFlag(DISPLAY3D_FLG aFlag) const
GetFlag - get a configuration status of a flag.
const SFVEC2F & GetCentroid() const
Definition: cobject2d.h:123
SFVEC3D m_SilkScreenColor
in realistic mode: SilkScreen color
Definition: cinfo3d_visu.h:508
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
bool m_reloadRequested
!TODO: this must be reviewed in order to flag change types
std::list< COBJECT2D * > LIST_OBJECT2D
Definition: ccontainer2d.h:36
CCAMERA & CameraGet() const
CameraGet - get current camera in use.
Definition: cinfo3d_visu.h:210
unsigned GetRunningMicroSecs()
Function GetRunningMicroSecs An alternate way to calculate an elapset time (in microsecondes) to clas...
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
float NextFloatUp(float v)
Definition: 3d_fastmath.h:136
void SetBoardLookAtPos(const SFVEC3F &aBoardPos)
Definition: ccamera.h:115
static COBJECT3D_STATS & Instance()
Definition: cobject.h:116
void SetCastShadows(bool aCastShadow)
Definition: clight.h:57
SFVEC3F SphericalToCartesian(float aInclination, float aAzimuth)
SphericalToCartesian.
Definition: 3d_math.h:43
void ResetStats()
Definition: cobject2d.h:135
unsigned int GetStats_Nr_Vias() const
GetStats_Nr_Vias - Get statistics of the nr of vias.
Definition: cinfo3d_visu.h:362
const CBBOX2D & GetBBox() const
Definition: cobject2d.h:121
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_UNDEFINED)=0
Function Report is a pure virtual function to override in the derived object.
CCONTAINER2D * m_outlineBoard2dObjects
const CBVHCONTAINER2D & GetThroughHole_Outer() const
GetThroughHole_Outer - Get the inflated ThroughHole container.
Definition: cinfo3d_visu.h:305
float GetStats_Med_Hole_Diameter3DU() const
GetStats_Med_Hole_Diameter3DU - Average diameter of holes.
Definition: cinfo3d_visu.h:380
void Clear()
Clear - Remove all lights from the container.
Definition: clight.h:165
SFVEC2F GetExtent() const
Function GetExtent.
Definition: cbbox2d.cpp:127
virtual bool Intersects(const CBBOX2D &aBBox) const =0
Function Intersects.
Class CBBOX manages a bounding box defined by two SFVEC3F min max points.
Definition: cbbox.h:40
MAP_MODEL_MATERIALS m_model_materials
Stores materials of the 3D models.
const BOARD * GetBoard() const
GetBoard - Get current board to be rendered.
Definition: cinfo3d_visu.h:128
double BiuTo3Dunits() const
BiuTo3Dunits - Board integer units To 3D units.
Definition: cinfo3d_visu.h:141
const LIST_OBJECT & GetList() const
Definition: ccontainer.h:63
const MAP_CONTAINER_2D & GetMapLayers() const
GetMapLayers - Get the map of container that have the objects per layer.
Definition: cinfo3d_visu.h:293
#define min(a, b)
Definition: auxiliary.h:85
void InitSettings(REPORTER *aStatusTextReporter)
InitSettings - Function to be called by the render when it need to reload the settings for the board...
void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(const SHAPE_POLY_SET &aMainPath, CGENERICCONTAINER2D &aDstContainer, float aBiuTo3DunitsScale, float aDivFactor, const BOARD_ITEM &aBoardItem)
Convert_path_polygon_to_polygon_blocks_and_dummy_blocks This function will use a polygon in the forma...
Definition: cpolygon2d.cpp:406
unsigned int GetStats_Nr_Holes() const
GetStats_Nr_Holes - Get statistics of the nr of holes.
Definition: cinfo3d_visu.h:368
const CBBOX & GetBBox3DU() const
GetBBox3DU - Get the bbox of the pcb board.
Definition: cinfo3d_visu.h:147
void C3D_RENDER_BASE::ReloadRequest ( )
inlineinherited

ReloadRequest - !TODO: this must be reviewed to add flags to improve specific render.

Definition at line 73 of file c3d_render_base.h.

References C3D_RENDER_BASE::m_reloadRequested.

Referenced by EDA_3D_CANVAS::ReloadRequest(), EDA_3D_CANVAS::RenderEngineChanged(), and EDA_3D_CANVAS::RenderRaytracingRequest().

73 { m_reloadRequested = true; }
bool m_reloadRequested
!TODO: this must be reviewed in order to flag change types
void C3D_RENDER_RAYTRACING::render ( GLubyte *  ptrPBO,
REPORTER aStatusTextReporter 
)
private

Definition at line 301 of file c3d_render_raytracing.cpp.

References CINFO3D_VISU::CameraGet(), ConvertSRGBToLinear(), Format(), CCAMERA::GetDir(), GetRunningMicroSecs(), CINFO3D_VISU::m_BgColorBot, m_BgColorBot_LinearRGB, CINFO3D_VISU::m_BgColorTop, m_BgColorTop_LinearRGB, m_camera_light, m_realBufferSize, m_rt_render_state, C3D_RENDER_BASE::m_settings, m_stats_start_rendering_time, RENDER_ENGINE_OPENGL_LEGACY, CINFO3D_VISU::RenderEngineGet(), REPORTER::Report(), restart_render_state(), rt_render_post_process_blur_finish(), rt_render_post_process_shade(), RT_RENDER_STATE_FINISH, RT_RENDER_STATE_MAX, RT_RENDER_STATE_POST_PROCESS_BLUR_AND_FINISH, RT_RENDER_STATE_POST_PROCESS_SHADE, RT_RENDER_STATE_TRACING, rt_render_tracing(), and CDIRECTIONALLIGHT::SetDirection().

Referenced by Redraw().

302 {
305  {
307 
308  if( m_camera_light )
310 
312  {
313  // Set all pixels of PBO transparent (Alpha to 0)
314  // This way it will draw the full buffer but only shows the updated (
315  // already calculated) squares
316  // /////////////////////////////////////////////////////////////////////
317  unsigned int nPixels = m_realBufferSize.x * m_realBufferSize.y;
318  GLubyte *tmp_ptrPBO = ptrPBO + 3; // PBO is RGBA
319 
320  for( unsigned int i = 0; i < nPixels; ++i )
321  {
322  *tmp_ptrPBO = 0;
323  tmp_ptrPBO += 4; // PBO is RGBA
324  }
325  }
326 
329  }
330 
331  switch( m_rt_render_state )
332  {
334  rt_render_tracing( ptrPBO, aStatusTextReporter );
335  break;
336 
338  rt_render_post_process_shade( ptrPBO, aStatusTextReporter );
339  break;
340 
342  rt_render_post_process_blur_finish( ptrPBO, aStatusTextReporter );
343  break;
344 
345  default:
346  wxASSERT_MSG( false, "Invalid state on m_rt_render_state");
348  break;
349  }
350 
351  if( aStatusTextReporter && (m_rt_render_state == RT_RENDER_STATE_FINISH) )
352  {
353  // Calculation time in seconds
354  const double calculation_time = (double)( GetRunningMicroSecs() -
356 
357  aStatusTextReporter->Report( wxString::Format( _( "Rendering time %.3f s" ),
358  calculation_time ) );
359  }
360 }
SFVEC3F ConvertSRGBToLinear(const SFVEC3F &aSRGBcolor)
void rt_render_post_process_shade(GLubyte *ptrPBO, REPORTER *aStatusTextReporter)
SFVEC3D m_BgColorBot
background bottom color
Definition: cinfo3d_visu.h:503
const SFVEC3F & GetDir() const
Definition: ccamera.h:109
CINFO3D_VISU & m_settings
settings refrence in use for this render
SFVEC3D m_BgColorTop
background top color
Definition: cinfo3d_visu.h:504
RT_RENDER_STATE m_rt_render_state
State used on quality render.
void rt_render_tracing(GLubyte *ptrPBO, REPORTER *aStatusTextReporter)
void rt_render_post_process_blur_finish(GLubyte *ptrPBO, REPORTER *aStatusTextReporter)
CDIRECTIONALLIGHT * m_camera_light
RENDER_ENGINE RenderEngineGet() const
RenderEngineGet.
Definition: cinfo3d_visu.h:234
void SetDirection(const SFVEC3F &aDir)
SetDirection - Set directional light orientation.
Definition: clight.h:129
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
CCAMERA & CameraGet() const
CameraGet - get current camera in use.
Definition: cinfo3d_visu.h:210
unsigned GetRunningMicroSecs()
Function GetRunningMicroSecs An alternate way to calculate an elapset time (in microsecondes) to clas...
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
unsigned long int m_stats_start_rendering_time
Time that the render starts.
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_UNDEFINED)=0
Function Report is a pure virtual function to override in the derived object.
void C3D_RENDER_RAYTRACING::render_preview ( GLubyte *  ptrPBO)
private

Definition at line 1089 of file c3d_render_raytracing.cpp.

References BlendColor(), CINFO3D_VISU::CameraGet(), RAY::Init(), CGENERICACCELERATOR::Intersect(), COBJECT::Intersect(), m_accelerator, CINFO3D_VISU::m_BgColorBot, CINFO3D_VISU::m_BgColorTop, m_blockPositionsFast, HITINFO_PACKET::m_HitInfo, HITINFO::m_HitNormal, m_isPreview, m_realBufferSize, C3D_RENDER_BASE::m_settings, HITINFO::m_tHit, C3D_RENDER_BASE::m_windowSize, m_xoffset, m_yoffset, HITINFO::pHitObject, RAYPACKET_DIM, RAYPACKET_RAYS_PER_PACKET, SetPixel(), and shadeHit().

Referenced by Redraw().

1090 {
1091  m_isPreview = true;
1092 
1093  unsigned int nrBlocks = m_blockPositionsFast.size();
1094 
1095  #pragma omp parallel for schedule(dynamic)
1096  for( signed int iBlock = 0; iBlock < (int)nrBlocks; iBlock++ )
1097  {
1098  const SFVEC2UI &windowPosUI = m_blockPositionsFast[ iBlock ];
1099  const SFVEC2I windowsPos = SFVEC2I( windowPosUI.x + m_xoffset,
1100  windowPosUI.y + m_yoffset );
1101 
1102  RAYPACKET blockPacket( m_settings.CameraGet(), windowsPos, 4 );
1103 
1105 
1106  // Initialize hitPacket with a "not hit" information
1107  for( unsigned int i = 0; i < RAYPACKET_RAYS_PER_PACKET; ++i )
1108  {
1109  hitPacket[i].m_HitInfo.m_tHit = std::numeric_limits<float>::infinity();
1110  hitPacket[i].m_HitInfo.m_acc_node_info = 0;
1111  hitPacket[i].m_hitresult = false;
1112  }
1113 
1114  // Intersect packet block
1115  m_accelerator->Intersect( blockPacket, hitPacket );
1116 
1117 
1118  // Calculate background gradient color
1119  // /////////////////////////////////////////////////////////////////////
1120  SFVEC3F bgColor[RAYPACKET_DIM];
1121 
1122  for( unsigned int y = 0; y < RAYPACKET_DIM; ++y )
1123  {
1124  const float posYfactor = (float)(windowsPos.y + y * 4.0f) / (float)m_windowSize.y;
1125 
1126  bgColor[y] = (SFVEC3F)m_settings.m_BgColorTop * SFVEC3F(posYfactor) +
1127  (SFVEC3F)m_settings.m_BgColorBot * ( SFVEC3F(1.0f) - SFVEC3F(posYfactor) );
1128  }
1129 
1130  CCOLORRGB hitColorShading[RAYPACKET_RAYS_PER_PACKET];
1131 
1132  for( unsigned int i = 0; i < RAYPACKET_RAYS_PER_PACKET; ++i )
1133  {
1134  const SFVEC3F bhColorY = bgColor[i / RAYPACKET_DIM];
1135 
1136  if( hitPacket[i].m_hitresult == true )
1137  {
1138  const SFVEC3F hitColor = shadeHit( bhColorY,
1139  blockPacket.m_ray[i],
1140  hitPacket[i].m_HitInfo,
1141  false,
1142  0,
1143  false );
1144 
1145  hitColorShading[i] = CCOLORRGB( hitColor );
1146  }
1147  else
1148  hitColorShading[i] = bhColorY;
1149  }
1150 
1151  CCOLORRGB cLRB_old[(RAYPACKET_DIM - 1)];
1152 
1153  for( unsigned int y = 0; y < (RAYPACKET_DIM - 1); ++y )
1154  {
1155 
1156  const SFVEC3F bgColorY = bgColor[y];
1157  const CCOLORRGB bgColorYRGB = CCOLORRGB( bgColorY );
1158 
1159  // This stores cRTB from the last block to be reused next time in a cLTB pixel
1160  CCOLORRGB cRTB_old;
1161 
1162  //RAY cRTB_ray;
1163  //HITINFO cRTB_hitInfo;
1164 
1165  for( unsigned int x = 0; x < (RAYPACKET_DIM - 1); ++x )
1166  {
1167  // pxl 0 pxl 1 pxl 2 pxl 3 pxl 4
1168  // x0 x1 ...
1169  // .---------------------------.
1170  // y0 | cLT | cxxx | cLRT | cxxx | cRT |
1171  // | cxxx | cLTC | cxxx | cRTC | cxxx |
1172  // | cLTB | cxxx | cC | cxxx | cRTB |
1173  // | cxxx | cLBC | cxxx | cRBC | cxxx |
1174  // '---------------------------'
1175  // y1 | cLB | cxxx | cLRB | cxxx | cRB |
1176 
1177  const unsigned int iLT = ((x + 0) + RAYPACKET_DIM * (y + 0));
1178  const unsigned int iRT = ((x + 1) + RAYPACKET_DIM * (y + 0));
1179  const unsigned int iLB = ((x + 0) + RAYPACKET_DIM * (y + 1));
1180  const unsigned int iRB = ((x + 1) + RAYPACKET_DIM * (y + 1));
1181 
1182  // !TODO: skip when there are no hits
1183 
1184 
1185  const CCOLORRGB &cLT = hitColorShading[ iLT ];
1186  const CCOLORRGB &cRT = hitColorShading[ iRT ];
1187  const CCOLORRGB &cLB = hitColorShading[ iLB ];
1188  const CCOLORRGB &cRB = hitColorShading[ iRB ];
1189 
1190  // Trace and shade cC
1191  // /////////////////////////////////////////////////////////////
1192  CCOLORRGB cC = bgColorYRGB;
1193 
1194  const SFVEC3F &oriLT = blockPacket.m_ray[ iLT ].m_Origin;
1195  const SFVEC3F &oriRB = blockPacket.m_ray[ iRB ].m_Origin;
1196 
1197  const SFVEC3F &dirLT = blockPacket.m_ray[ iLT ].m_Dir;
1198  const SFVEC3F &dirRB = blockPacket.m_ray[ iRB ].m_Dir;
1199 
1200  SFVEC3F oriC;
1201  SFVEC3F dirC;
1202 
1203  HITINFO centerHitInfo;
1204  centerHitInfo.m_tHit = std::numeric_limits<float>::infinity();
1205 
1206  bool hittedC = false;
1207 
1208  if( (hitPacket[ iLT ].m_hitresult == true) ||
1209  (hitPacket[ iRT ].m_hitresult == true) ||
1210  (hitPacket[ iLB ].m_hitresult == true) ||
1211  (hitPacket[ iRB ].m_hitresult == true) )
1212  {
1213 
1214  oriC = ( oriLT + oriRB ) * 0.5f;
1215  dirC = glm::normalize( ( dirLT + dirRB ) * 0.5f );
1216 
1217  // Trace the center ray
1218  RAY centerRay;
1219  centerRay.Init( oriC, dirC );
1220 
1221  const unsigned int nodeLT = hitPacket[ iLT ].m_HitInfo.m_acc_node_info;
1222  const unsigned int nodeRT = hitPacket[ iRT ].m_HitInfo.m_acc_node_info;
1223  const unsigned int nodeLB = hitPacket[ iLB ].m_HitInfo.m_acc_node_info;
1224  const unsigned int nodeRB = hitPacket[ iRB ].m_HitInfo.m_acc_node_info;
1225 
1226  if( nodeLT != 0 )
1227  hittedC |= m_accelerator->Intersect( centerRay, centerHitInfo, nodeLT );
1228 
1229  if( ( nodeRT != 0 ) &&
1230  ( nodeRT != nodeLT ) )
1231  hittedC |= m_accelerator->Intersect( centerRay, centerHitInfo, nodeRT );
1232 
1233  if( ( nodeLB != 0 ) &&
1234  ( nodeLB != nodeLT ) &&
1235  ( nodeLB != nodeRT ) )
1236  hittedC |= m_accelerator->Intersect( centerRay, centerHitInfo, nodeLB );
1237 
1238  if( ( nodeRB != 0 ) &&
1239  ( nodeRB != nodeLB ) &&
1240  ( nodeRB != nodeLT ) &&
1241  ( nodeRB != nodeRT ) )
1242  hittedC |= m_accelerator->Intersect( centerRay, centerHitInfo, nodeRB );
1243 
1244  if( hittedC )
1245  cC = CCOLORRGB( shadeHit( bgColorY, centerRay, centerHitInfo, false, 0, false ) );
1246  else
1247  {
1248  centerHitInfo.m_tHit = std::numeric_limits<float>::infinity();
1249  hittedC = m_accelerator->Intersect( centerRay, centerHitInfo );
1250 
1251  if( hittedC )
1252  cC = CCOLORRGB( shadeHit( bgColorY,
1253  centerRay,
1254  centerHitInfo,
1255  false,
1256  0,
1257  false ) );
1258  }
1259  }
1260 
1261  // Trace and shade cLRT
1262  // /////////////////////////////////////////////////////////////
1263  CCOLORRGB cLRT = bgColorYRGB;
1264 
1265  const SFVEC3F &oriRT = blockPacket.m_ray[ iRT ].m_Origin;
1266  const SFVEC3F &dirRT = blockPacket.m_ray[ iRT ].m_Dir;
1267 
1268  if( y == 0 )
1269  {
1270  // Trace the center ray
1271  RAY rayLRT;
1272  rayLRT.Init( ( oriLT + oriRT ) * 0.5f,
1273  glm::normalize( ( dirLT + dirRT ) * 0.5f ) );
1274 
1275  HITINFO hitInfoLRT;
1276  hitInfoLRT.m_tHit = std::numeric_limits<float>::infinity();
1277 
1278  if( hitPacket[ iLT ].m_hitresult &&
1279  hitPacket[ iRT ].m_hitresult &&
1280  (hitPacket[ iLT ].m_HitInfo.pHitObject == hitPacket[ iRT ].m_HitInfo.pHitObject) )
1281  {
1282  hitInfoLRT.pHitObject = hitPacket[ iLT ].m_HitInfo.pHitObject;
1283  hitInfoLRT.m_tHit = ( hitPacket[ iLT ].m_HitInfo.m_tHit +
1284  hitPacket[ iRT ].m_HitInfo.m_tHit ) * 0.5f;
1285  hitInfoLRT.m_HitNormal =
1286  glm::normalize( ( hitPacket[ iLT ].m_HitInfo.m_HitNormal +
1287  hitPacket[ iRT ].m_HitInfo.m_HitNormal ) * 0.5f );
1288 
1289  cLRT = CCOLORRGB( shadeHit( bgColorY, rayLRT, hitInfoLRT, false, 0, false ) );
1290  cLRT = BlendColor( cLRT, BlendColor( cLT, cRT) );
1291  }
1292  else
1293  {
1294  if( hitPacket[ iLT ].m_hitresult ||
1295  hitPacket[ iRT ].m_hitresult ) // If any hits
1296  {
1297  const unsigned int nodeLT = hitPacket[ iLT ].m_HitInfo.m_acc_node_info;
1298  const unsigned int nodeRT = hitPacket[ iRT ].m_HitInfo.m_acc_node_info;
1299 
1300  bool hittedLRT = false;
1301 
1302  if( nodeLT != 0 )
1303  hittedLRT |= m_accelerator->Intersect( rayLRT, hitInfoLRT, nodeLT );
1304 
1305  if( ( nodeRT != 0 ) &&
1306  ( nodeRT != nodeLT ) )
1307  hittedLRT |= m_accelerator->Intersect( rayLRT,
1308  hitInfoLRT,
1309  nodeRT );
1310 
1311  if( hittedLRT )
1312  cLRT = CCOLORRGB( shadeHit( bgColorY,
1313  rayLRT,
1314  hitInfoLRT,
1315  false,
1316  0,
1317  false ) );
1318  else
1319  {
1320  hitInfoLRT.m_tHit = std::numeric_limits<float>::infinity();
1321 
1322  if( m_accelerator->Intersect( rayLRT,hitInfoLRT ) )
1323  cLRT = CCOLORRGB( shadeHit( bgColorY,
1324  rayLRT,
1325  hitInfoLRT,
1326  false,
1327  0,
1328  false ) );
1329  }
1330  }
1331  }
1332  }
1333  else
1334  cLRT = cLRB_old[x];
1335 
1336 
1337  // Trace and shade cLTB
1338  // /////////////////////////////////////////////////////////////
1339  CCOLORRGB cLTB = bgColorYRGB;
1340 
1341  if( x == 0 )
1342  {
1343  const SFVEC3F &oriLB = blockPacket.m_ray[ iLB ].m_Origin;
1344  const SFVEC3F &dirLB = blockPacket.m_ray[ iLB ].m_Dir;
1345 
1346  // Trace the center ray
1347  RAY rayLTB;
1348  rayLTB.Init( ( oriLT + oriLB ) * 0.5f,
1349  glm::normalize( ( dirLT + dirLB ) * 0.5f ) );
1350 
1351  HITINFO hitInfoLTB;
1352  hitInfoLTB.m_tHit = std::numeric_limits<float>::infinity();
1353 
1354  if( hitPacket[ iLT ].m_hitresult &&
1355  hitPacket[ iLB ].m_hitresult &&
1356  ( hitPacket[ iLT ].m_HitInfo.pHitObject ==
1357  hitPacket[ iLB ].m_HitInfo.pHitObject ) )
1358  {
1359  hitInfoLTB.pHitObject = hitPacket[ iLT ].m_HitInfo.pHitObject;
1360  hitInfoLTB.m_tHit = ( hitPacket[ iLT ].m_HitInfo.m_tHit +
1361  hitPacket[ iLB ].m_HitInfo.m_tHit ) * 0.5f;
1362  hitInfoLTB.m_HitNormal =
1363  glm::normalize( ( hitPacket[ iLT ].m_HitInfo.m_HitNormal +
1364  hitPacket[ iLB ].m_HitInfo.m_HitNormal ) * 0.5f );
1365  cLTB = CCOLORRGB( shadeHit( bgColorY, rayLTB, hitInfoLTB, false, 0, false ) );
1366  cLTB = BlendColor( cLTB, BlendColor( cLT, cLB) );
1367  }
1368  else
1369  {
1370  if( hitPacket[ iLT ].m_hitresult ||
1371  hitPacket[ iLB ].m_hitresult ) // If any hits
1372  {
1373  const unsigned int nodeLT = hitPacket[ iLT ].m_HitInfo.m_acc_node_info;
1374  const unsigned int nodeLB = hitPacket[ iLB ].m_HitInfo.m_acc_node_info;
1375 
1376  bool hittedLTB = false;
1377 
1378  if( nodeLT != 0 )
1379  hittedLTB |= m_accelerator->Intersect( rayLTB,
1380  hitInfoLTB,
1381  nodeLT );
1382 
1383  if( ( nodeLB != 0 ) &&
1384  ( nodeLB != nodeLT ) )
1385  hittedLTB |= m_accelerator->Intersect( rayLTB,
1386  hitInfoLTB,
1387  nodeLB );
1388 
1389  if( hittedLTB )
1390  cLTB = CCOLORRGB( shadeHit( bgColorY,
1391  rayLTB,
1392  hitInfoLTB,
1393  false,
1394  0,
1395  false ) );
1396  else
1397  {
1398  hitInfoLTB.m_tHit = std::numeric_limits<float>::infinity();
1399 
1400  if( m_accelerator->Intersect( rayLTB, hitInfoLTB ) )
1401  cLTB = CCOLORRGB( shadeHit( bgColorY,
1402  rayLTB,
1403  hitInfoLTB,
1404  false,
1405  0,
1406  false ) );
1407  }
1408  }
1409  }
1410  }
1411  else
1412  cLTB = cRTB_old;
1413 
1414 
1415  // Trace and shade cRTB
1416  // /////////////////////////////////////////////////////////////
1417  CCOLORRGB cRTB = bgColorYRGB;
1418 
1419  // Trace the center ray
1420  RAY rayRTB;
1421  rayRTB.Init( ( oriRT + oriRB ) * 0.5f,
1422  glm::normalize( ( dirRT + dirRB ) * 0.5f ) );
1423 
1424  HITINFO hitInfoRTB;
1425  hitInfoRTB.m_tHit = std::numeric_limits<float>::infinity();
1426 
1427  if( hitPacket[ iRT ].m_hitresult &&
1428  hitPacket[ iRB ].m_hitresult &&
1429  ( hitPacket[ iRT ].m_HitInfo.pHitObject ==
1430  hitPacket[ iRB ].m_HitInfo.pHitObject ) )
1431  {
1432  hitInfoRTB.pHitObject = hitPacket[ iRT ].m_HitInfo.pHitObject;
1433 
1434  hitInfoRTB.m_tHit = ( hitPacket[ iRT ].m_HitInfo.m_tHit +
1435  hitPacket[ iRB ].m_HitInfo.m_tHit ) * 0.5f;
1436 
1437  hitInfoRTB.m_HitNormal =
1438  glm::normalize( ( hitPacket[ iRT ].m_HitInfo.m_HitNormal +
1439  hitPacket[ iRB ].m_HitInfo.m_HitNormal ) * 0.5f );
1440 
1441  cRTB = CCOLORRGB( shadeHit( bgColorY, rayRTB, hitInfoRTB, false, 0, false ) );
1442  cRTB = BlendColor( cRTB, BlendColor( cRT, cRB) );
1443  }
1444  else
1445  {
1446  if( hitPacket[ iRT ].m_hitresult ||
1447  hitPacket[ iRB ].m_hitresult ) // If any hits
1448  {
1449  const unsigned int nodeRT = hitPacket[ iRT ].m_HitInfo.m_acc_node_info;
1450  const unsigned int nodeRB = hitPacket[ iRB ].m_HitInfo.m_acc_node_info;
1451 
1452  bool hittedRTB = false;
1453 
1454  if( nodeRT != 0 )
1455  hittedRTB |= m_accelerator->Intersect( rayRTB, hitInfoRTB, nodeRT );
1456 
1457  if( ( nodeRB != 0 ) &&
1458  ( nodeRB != nodeRT ) )
1459  hittedRTB |= m_accelerator->Intersect( rayRTB, hitInfoRTB, nodeRB );
1460 
1461  if( hittedRTB )
1462  cRTB = CCOLORRGB( shadeHit( bgColorY,
1463  rayRTB,
1464  hitInfoRTB,
1465  false,
1466  0,
1467  false) );
1468  else
1469  {
1470  hitInfoRTB.m_tHit = std::numeric_limits<float>::infinity();
1471 
1472  if( m_accelerator->Intersect( rayRTB, hitInfoRTB ) )
1473  cRTB = CCOLORRGB( shadeHit( bgColorY,
1474  rayRTB,
1475  hitInfoRTB,
1476  false,
1477  0,
1478  false ) );
1479  }
1480  }
1481  }
1482 
1483  cRTB_old = cRTB;
1484 
1485 
1486  // Trace and shade cLRB
1487  // /////////////////////////////////////////////////////////////
1488  CCOLORRGB cLRB = bgColorYRGB;
1489 
1490  const SFVEC3F &oriLB = blockPacket.m_ray[ iLB ].m_Origin;
1491  const SFVEC3F &dirLB = blockPacket.m_ray[ iLB ].m_Dir;
1492 
1493  // Trace the center ray
1494  RAY rayLRB;
1495  rayLRB.Init( ( oriLB + oriRB ) * 0.5f,
1496  glm::normalize( ( dirLB + dirRB ) * 0.5f ) );
1497 
1498  HITINFO hitInfoLRB;
1499  hitInfoLRB.m_tHit = std::numeric_limits<float>::infinity();
1500 
1501  if( hitPacket[ iLB ].m_hitresult &&
1502  hitPacket[ iRB ].m_hitresult &&
1503  ( hitPacket[ iLB ].m_HitInfo.pHitObject ==
1504  hitPacket[ iRB ].m_HitInfo.pHitObject ) )
1505  {
1506  hitInfoLRB.pHitObject = hitPacket[ iLB ].m_HitInfo.pHitObject;
1507 
1508  hitInfoLRB.m_tHit = ( hitPacket[ iLB ].m_HitInfo.m_tHit +
1509  hitPacket[ iRB ].m_HitInfo.m_tHit ) * 0.5f;
1510 
1511  hitInfoLRB.m_HitNormal =
1512  glm::normalize( ( hitPacket[ iLB ].m_HitInfo.m_HitNormal +
1513  hitPacket[ iRB ].m_HitInfo.m_HitNormal ) * 0.5f );
1514 
1515  cLRB = CCOLORRGB( shadeHit( bgColorY, rayLRB, hitInfoLRB, false, 0, false ) );
1516  cLRB = BlendColor( cLRB, BlendColor( cLB, cRB) );
1517  }
1518  else
1519  {
1520  if( hitPacket[ iLB ].m_hitresult ||
1521  hitPacket[ iRB ].m_hitresult ) // If any hits
1522  {
1523  const unsigned int nodeLB = hitPacket[ iLB ].m_HitInfo.m_acc_node_info;
1524  const unsigned int nodeRB = hitPacket[ iRB ].m_HitInfo.m_acc_node_info;
1525 
1526  bool hittedLRB = false;
1527 
1528  if( nodeLB != 0 )
1529  hittedLRB |= m_accelerator->Intersect( rayLRB, hitInfoLRB, nodeLB );
1530 
1531  if( ( nodeRB != 0 ) &&
1532  ( nodeRB != nodeLB ) )
1533  hittedLRB |= m_accelerator->Intersect( rayLRB, hitInfoLRB, nodeRB );
1534 
1535  if( hittedLRB )
1536  cLRB = CCOLORRGB( shadeHit( bgColorY, rayLRB, hitInfoLRB, false, 0, false ) );
1537  else
1538  {
1539  hitInfoLRB.m_tHit = std::numeric_limits<float>::infinity();
1540 
1541  if( m_accelerator->Intersect( rayLRB, hitInfoLRB ) )
1542  cLRB = CCOLORRGB( shadeHit( bgColorY,
1543  rayLRB,
1544  hitInfoLRB,
1545  false,
1546  0,
1547  false ) );
1548  }
1549  }
1550  }
1551 
1552  cLRB_old[x] = cLRB;
1553 
1554 
1555  // Trace and shade cLTC
1556  // /////////////////////////////////////////////////////////////
1557  CCOLORRGB cLTC = BlendColor( cLT , cC );
1558 
1559  if( hitPacket[ iLT ].m_hitresult || hittedC )
1560  {
1561  // Trace the center ray
1562  RAY rayLTC;
1563  rayLTC.Init( ( oriLT + oriC ) * 0.5f,
1564  glm::normalize( ( dirLT + dirC ) * 0.5f ) );
1565 
1566  HITINFO hitInfoLTC;
1567  hitInfoLTC.m_tHit = std::numeric_limits<float>::infinity();
1568 
1569  bool hitted = false;
1570 
1571  if( hittedC )
1572  hitted = centerHitInfo.pHitObject->Intersect( rayLTC, hitInfoLTC );
1573  else
1574  if( hitPacket[ iLT ].m_hitresult )
1575  hitted = hitPacket[ iLT ].m_HitInfo.pHitObject->Intersect( rayLTC,
1576  hitInfoLTC );
1577 
1578  if( hitted )
1579  cLTC = CCOLORRGB( shadeHit( bgColorY, rayLTC, hitInfoLTC, false, 0, false ) );
1580  }
1581 
1582 
1583  // Trace and shade cRTC
1584  // /////////////////////////////////////////////////////////////
1585  CCOLORRGB cRTC = BlendColor( cRT , cC );
1586 
1587  if( hitPacket[ iRT ].m_hitresult || hittedC )
1588  {
1589  // Trace the center ray
1590  RAY rayRTC;
1591  rayRTC.Init( ( oriRT + oriC ) * 0.5f,
1592  glm::normalize( ( dirRT + dirC ) * 0.5f ) );
1593 
1594  HITINFO hitInfoRTC;
1595  hitInfoRTC.m_tHit = std::numeric_limits<float>::infinity();
1596 
1597  bool hitted = false;
1598 
1599  if( hittedC )
1600  hitted = centerHitInfo.pHitObject->Intersect( rayRTC, hitInfoRTC );
1601  else
1602  if( hitPacket[ iRT ].m_hitresult )
1603  hitted = hitPacket[ iRT ].m_HitInfo.pHitObject->Intersect( rayRTC,
1604  hitInfoRTC );
1605 
1606  if( hitted )
1607  cRTC = CCOLORRGB( shadeHit( bgColorY, rayRTC, hitInfoRTC, false, 0, false ) );
1608  }
1609 
1610 
1611  // Trace and shade cLBC
1612  // /////////////////////////////////////////////////////////////
1613  CCOLORRGB cLBC = BlendColor( cLB , cC );
1614 
1615  if( hitPacket[ iLB ].m_hitresult || hittedC )
1616  {
1617  // Trace the center ray
1618  RAY rayLBC;
1619  rayLBC.Init( ( oriLB + oriC ) * 0.5f,
1620  glm::normalize( ( dirLB + dirC ) * 0.5f ) );
1621 
1622  HITINFO hitInfoLBC;
1623  hitInfoLBC.m_tHit = std::numeric_limits<float>::infinity();
1624 
1625  bool hitted = false;
1626 
1627  if( hittedC )
1628  hitted = centerHitInfo.pHitObject->Intersect( rayLBC, hitInfoLBC );
1629  else
1630  if( hitPacket[ iLB ].m_hitresult )
1631  hitted = hitPacket[ iLB ].m_HitInfo.pHitObject->Intersect( rayLBC,
1632  hitInfoLBC );
1633 
1634  if( hitted )
1635  cLBC = CCOLORRGB( shadeHit( bgColorY, rayLBC, hitInfoLBC, false, 0, false ) );
1636  }
1637 
1638 
1639  // Trace and shade cRBC
1640  // /////////////////////////////////////////////////////////////
1641  CCOLORRGB cRBC = BlendColor( cRB , cC );
1642 
1643  if( hitPacket[ iRB ].m_hitresult || hittedC )
1644  {
1645  // Trace the center ray
1646  RAY rayRBC;
1647  rayRBC.Init( ( oriRB + oriC ) * 0.5f,
1648  glm::normalize( ( dirRB + dirC ) * 0.5f ) );
1649 
1650  HITINFO hitInfoRBC;
1651  hitInfoRBC.m_tHit = std::numeric_limits<float>::infinity();
1652 
1653  bool hitted = false;
1654 
1655  if( hittedC )
1656  hitted = centerHitInfo.pHitObject->Intersect( rayRBC, hitInfoRBC );
1657  else
1658  if( hitPacket[ iRB ].m_hitresult )
1659  hitted = hitPacket[ iRB ].m_HitInfo.pHitObject->Intersect( rayRBC,
1660  hitInfoRBC );
1661 
1662  if( hitted )
1663  cRBC = CCOLORRGB( shadeHit( bgColorY, rayRBC, hitInfoRBC, false, 0, false ) );
1664  }
1665 
1666 
1667  // Set pixel colors
1668  // /////////////////////////////////////////////////////////////
1669 
1670  GLubyte *ptr = &ptrPBO[ (4 * x + m_blockPositionsFast[iBlock].x +
1671  m_realBufferSize.x *
1672  (m_blockPositionsFast[iBlock].y + 4 * y)) * 4 ];
1673  SetPixel( ptr + 0, cLT );
1674  SetPixel( ptr + 4, BlendColor( cLT, cLRT, cLTC ) );
1675  SetPixel( ptr + 8, cLRT );
1676  SetPixel( ptr + 12, BlendColor( cLRT, cRT, cRTC ) );
1677 
1678  ptr += m_realBufferSize.x * 4;
1679  SetPixel( ptr + 0, BlendColor( cLT , cLTB, cLTC ) );
1680  SetPixel( ptr + 4, BlendColor( cLTC, BlendColor( cLT , cC ) ) );
1681  SetPixel( ptr + 8, BlendColor( cC, BlendColor( cLRT, cLTC, cRTC ) ) );
1682  SetPixel( ptr + 12, BlendColor( cRTC, BlendColor( cRT , cC ) ) );
1683 
1684  ptr += m_realBufferSize.x * 4;
1685  SetPixel( ptr + 0, cLTB );
1686  SetPixel( ptr + 4, BlendColor( cC, BlendColor( cLTB, cLTC, cLBC ) ) );
1687  SetPixel( ptr + 8, cC );
1688  SetPixel( ptr + 12, BlendColor( cC, BlendColor( cRTB, cRTC, cRBC ) ) );
1689 
1690  ptr += m_realBufferSize.x * 4;
1691  SetPixel( ptr + 0, BlendColor( cLB , cLTB, cLBC ) );
1692  SetPixel( ptr + 4, BlendColor( cLBC, BlendColor( cLB , cC ) ) );
1693  SetPixel( ptr + 8, BlendColor( cC, BlendColor( cLRB, cLBC, cRBC ) ) );
1694  SetPixel( ptr + 12, BlendColor( cRBC, BlendColor( cRB , cC ) ) );
1695  }
1696  }
1697  }
1698 
1699  // Wait for all threads to finish (not sure if this is need)
1700  #pragma omp barrier
1701 }
#define RAYPACKET_DIM
Definition: raypacket.h:37
SFVEC3F shadeHit(const SFVEC3F &aBgColor, const RAY &aRay, HITINFO &aHitInfo, bool aIsInsideObject, unsigned int aRecursiveLevel, bool is_testShadow) const
void Init(const SFVEC3F &o, const SFVEC3F &d)
Definition: ray.cpp:40
SFVEC3D m_BgColorBot
background bottom color
Definition: cinfo3d_visu.h:503
Definition: ray.h:43
glm::ivec2 SFVEC2I
Definition: xv3d_types.h:42
CINFO3D_VISU & m_settings
settings refrence in use for this render
SFVEC3D m_BgColorTop
background top color
Definition: cinfo3d_visu.h:504
float m_tHit
( 4) distance
Definition: hitinfo.h:43
glm::uvec2 SFVEC2UI
Definition: xv3d_types.h:41
CGENERICACCELERATOR * m_accelerator
virtual bool Intersect(const RAY &aRay, HITINFO &aHitInfo) const =0
HITINFO m_HitInfo
Definition: hitinfo.h:63
wxSize m_windowSize
The window size that this camera is working.
const COBJECT * pHitObject
( 4) Object that was hitted
Definition: hitinfo.h:45
std::vector< SFVEC2UI > m_blockPositionsFast
this encodes the Morton code positions (on fast preview mode)
virtual bool Intersect(const RAY &aRay, HITINFO &aHitInfo) const =0
Functions Intersect.
static void SetPixel(GLubyte *p, const CCOLORRGB &v)
Stores the hit information of a ray with a point on the surface of a object.
Definition: hitinfo.h:40
#define RAYPACKET_RAYS_PER_PACKET
Definition: raypacket.h:40
CCAMERA & CameraGet() const
CameraGet - get current camera in use.
Definition: cinfo3d_visu.h:210
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
CCOLORRGB BlendColor(const CCOLORRGB &aC1, const CCOLORRGB &aC2)
Definition: ccolorrgb.cpp:42
SFVEC3F m_HitNormal
(12) normal at the hit point
Definition: hitinfo.h:42
void C3D_RENDER_RAYTRACING::restart_render_state ( )
private

Definition at line 126 of file c3d_render_raytracing.cpp.

References GetRunningMicroSecs(), CPOSTSHADER::InitFrame(), m_blockPositions, m_blockPositionsWasProcessed, m_nrBlocksRenderProgress, m_postshader_ssao, m_rt_render_state, m_stats_start_rendering_time, and RT_RENDER_STATE_TRACING.

Referenced by render().

127 {
129 
132 
134 
136 
137  // Mark the blocks not processed yet
138  std::fill( m_blockPositionsWasProcessed.begin(),
140  false );
141 }
std::vector< bool > m_blockPositionsWasProcessed
this flags if a position was already processed (cleared each new render)
long m_nrBlocksRenderProgress
Save the number of blocks progress of the render.
CPOSTSHADER_SSAO m_postshader_ssao
RT_RENDER_STATE m_rt_render_state
State used on quality render.
void InitFrame()
Definition: cpostshader.h:54
unsigned GetRunningMicroSecs()
Function GetRunningMicroSecs An alternate way to calculate an elapset time (in microsecondes) to clas...
std::vector< SFVEC2UI > m_blockPositions
this encodes the Morton code positions
unsigned long int m_stats_start_rendering_time
Time that the render starts.
void C3D_RENDER_RAYTRACING::rt_final_color ( GLubyte *  ptrPBO,
const SFVEC3F rgbColor,
bool  applyColorSpaceConversion 
)
private

Definition at line 467 of file c3d_render_raytracing.cpp.

References color, and convertLinearToSRGB().

Referenced by rt_render_post_process_blur_finish(), and rt_render_trace_block().

470 {
471 
472  SFVEC3F color = rgbColor;
473 
474 #ifdef USE_SRGB_SPACE
475 
476  // This should be used in future when the KiCad support a greater version of
477  // glm lib.
478  // if( applyColorSpaceConversion )
479  // rgbColor = glm::convertLinearToSRGB( rgbColor );
480 
481  if( applyColorSpaceConversion )
482  color = convertLinearToSRGB( rgbColor );
483 #endif
484 
485  ptrPBO[0] = (unsigned int)glm::clamp( (int)(color.r * 255), 0, 255 );
486  ptrPBO[1] = (unsigned int)glm::clamp( (int)(color.g * 255), 0, 255 );
487  ptrPBO[2] = (unsigned int)glm::clamp( (int)(color.b * 255), 0, 255 );
488  ptrPBO[3] = 255;
489 }
int color
Definition: DXF_plotter.cpp:62
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
static SFVEC3F convertLinearToSRGB(const SFVEC3F &aRGBcolor)
void C3D_RENDER_RAYTRACING::rt_render_post_process_blur_finish ( GLubyte *  ptrPBO,
REPORTER aStatusTextReporter 
)
private

Definition at line 955 of file c3d_render_raytracing.cpp.

References CPOSTSHADER_SSAO::ApplyShadeColor(), convertLinearToSRGB(), FL_RENDER_RAYTRACING_POST_PROCESSING, CPOSTSHADER::GetColorAtNotProtected(), CINFO3D_VISU::GetFlag(), m_postshader_ssao, m_realBufferSize, m_rt_render_state, C3D_RENDER_BASE::m_settings, m_shaderBuffer, max, min, rt_final_color(), and RT_RENDER_STATE_FINISH.

Referenced by render().

957 {
958  (void)aStatusTextReporter; //unused
959 
961  {
962  // Now blurs the shader result and compute the final color
963  #pragma omp parallel for schedule(dynamic)
964  for( signed int y = 0; y < (int)m_realBufferSize.y; ++y )
965  {
966  GLubyte *ptr = &ptrPBO[ y * m_realBufferSize.x * 4 ];
967 
968  SFVEC3F *ptrShaderY0 =
969  &m_shaderBuffer[ glm::max((int)y - 2, 0) * m_realBufferSize.x ];
970  SFVEC3F *ptrShaderY1 =
971  &m_shaderBuffer[ glm::max((int)y - 1, 0) * m_realBufferSize.x ];
972  SFVEC3F *ptrShaderY2 =
974  SFVEC3F *ptrShaderY3 =
975  &m_shaderBuffer[ glm::min((int)y + 1, (int)(m_realBufferSize.y - 1)) *
976  m_realBufferSize.x ];
977  SFVEC3F *ptrShaderY4 =
978  &m_shaderBuffer[ glm::min((int)y + 2, (int)(m_realBufferSize.y - 1)) *
979  m_realBufferSize.x ];
980 
981  for( signed int x = 0; x < (int)m_realBufferSize.x; ++x )
982  {
983 // This #if should be 1, it is here that can be used for debug proposes during development
984 #if 1
985 
986  SFVEC3F bluredShadeColor = (*ptrShaderY0) * 1.0f / 273.0f +
987  (*ptrShaderY1) * 4.0f / 273.0f +
988  (*ptrShaderY2) * 7.0f / 273.0f +
989  (*ptrShaderY3) * 4.0f / 273.0f +
990  (*ptrShaderY4) * 1.0f / 273.0f;
991  if( x > 1 )
992  {
993  ptrShaderY0++;
994  ptrShaderY1++;
995  ptrShaderY2++;
996  ptrShaderY3++;
997  ptrShaderY4++;
998  }
999 
1000  bluredShadeColor += (*ptrShaderY0) * 4.0f / 273.0f +
1001  (*ptrShaderY1) *16.0f / 273.0f +
1002  (*ptrShaderY2) *26.0f / 273.0f +
1003  (*ptrShaderY3) *16.0f / 273.0f +
1004  (*ptrShaderY4) * 4.0f / 273.0f;
1005 
1006  if( x > 0 )
1007  {
1008  ptrShaderY0++;
1009  ptrShaderY1++;
1010  ptrShaderY2++;
1011  ptrShaderY3++;
1012  ptrShaderY4++;
1013  }
1014 
1015  bluredShadeColor += (*ptrShaderY0) * 7.0f / 273.0f +
1016  (*ptrShaderY1) *26.0f / 273.0f +
1017  (*ptrShaderY2) *41.0f / 273.0f +
1018  (*ptrShaderY3) *26.0f / 273.0f +
1019  (*ptrShaderY4) * 7.0f / 273.0f;
1020 
1021  if( x < ((int)m_realBufferSize.x - 1) )
1022  {
1023  ptrShaderY0++;
1024  ptrShaderY1++;
1025  ptrShaderY2++;
1026  ptrShaderY3++;
1027  ptrShaderY4++;
1028  }
1029 
1030  bluredShadeColor += (*ptrShaderY0) * 4.0f / 273.0f +
1031  (*ptrShaderY1) *16.0f / 273.0f +
1032  (*ptrShaderY2) *26.0f / 273.0f +
1033  (*ptrShaderY3) *16.0f / 273.0f +
1034  (*ptrShaderY4) * 4.0f / 273.0f;
1035 
1036  if( x < ((int)m_realBufferSize.x - 2) )
1037  {
1038  ptrShaderY0++;
1039  ptrShaderY1++;
1040  ptrShaderY2++;
1041  ptrShaderY3++;
1042  ptrShaderY4++;
1043  }
1044 
1045  bluredShadeColor += (*ptrShaderY0) * 1.0f / 273.0f +
1046  (*ptrShaderY1) * 4.0f / 273.0f +
1047  (*ptrShaderY2) * 7.0f / 273.0f +
1048  (*ptrShaderY3) * 4.0f / 273.0f +
1049  (*ptrShaderY4) * 1.0f / 273.0f;
1050 
1051  ptrShaderY0-= 3;
1052  ptrShaderY1-= 3;
1053  ptrShaderY2-= 3;
1054  ptrShaderY3-= 3;
1055  ptrShaderY4-= 3;
1056 
1057 #ifdef USE_SRGB_SPACE
1059 #else
1060  const SFVEC3F originColor = m_postshader_ssao.GetColorAtNotProtected( SFVEC2I( x,y ) );
1061 #endif
1062 
1063  const SFVEC3F shadedColor = m_postshader_ssao.ApplyShadeColor( SFVEC2I( x,y ), originColor, bluredShadeColor );
1064 #else
1065  // Debug code
1066  //const SFVEC3F shadedColor = SFVEC3F( 1.0f ) -
1067  // m_shaderBuffer[ y * m_realBufferSize.x + x];
1068  const SFVEC3F shadedColor = m_shaderBuffer[ y * m_realBufferSize.x + x ];
1069 #endif
1070 
1071  rt_final_color( ptr, shadedColor, false );
1072 
1073  ptr += 4;
1074  }
1075  }
1076 
1077  // Wait for all threads to finish
1078  #pragma omp barrier
1079 
1080  // Debug code
1081  //m_postshader_ssao.DebugBuffersOutputAsImages();
1082  }
1083 
1084  // End rendering
1086 }
SFVEC3F ApplyShadeColor(const SFVEC2I &aShaderPos, const SFVEC3F &aInputColor, const SFVEC3F &aShadeColor) const override
ApplyShadeColor - apply the final color process using a previous stage color.
const SFVEC3F & GetColorAtNotProtected(const SFVEC2I &aPos) const
void rt_final_color(GLubyte *ptrPBO, const SFVEC3F &rgbColor, bool applyColorSpaceConversion)
CPOSTSHADER_SSAO m_postshader_ssao
glm::ivec2 SFVEC2I
Definition: xv3d_types.h:42
CINFO3D_VISU & m_settings
settings refrence in use for this render
RT_RENDER_STATE m_rt_render_state
State used on quality render.
bool GetFlag(DISPLAY3D_FLG aFlag) const
GetFlag - get a configuration status of a flag.
#define max(a, b)
Definition: auxiliary.h:86
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
static SFVEC3F convertLinearToSRGB(const SFVEC3F &aRGBcolor)
#define min(a, b)
Definition: auxiliary.h:85
void C3D_RENDER_RAYTRACING::rt_render_post_process_shade ( GLubyte *  ptrPBO,
REPORTER aStatusTextReporter 
)
private

Definition at line 918 of file c3d_render_raytracing.cpp.

References FL_RENDER_RAYTRACING_POST_PROCESSING, CINFO3D_VISU::GetFlag(), m_postshader_ssao, m_realBufferSize, m_rt_render_state, C3D_RENDER_BASE::m_settings, m_shaderBuffer, REPORTER::Report(), RT_RENDER_STATE_FINISH, RT_RENDER_STATE_POST_PROCESS_BLUR_AND_FINISH, and CPOSTSHADER_SSAO::Shade().

Referenced by render().

920 {
921  (void)ptrPBO; // unused
922 
924  {
925  if( aStatusTextReporter )
926  aStatusTextReporter->Report( _("Rendering: Post processing shader") );
927 
928  // Compute the shader value
929  #pragma omp parallel for schedule(dynamic)
930  for( signed int y = 0; y < (int)m_realBufferSize.y; ++y )
931  {
932  SFVEC3F *ptr = &m_shaderBuffer[ y * m_realBufferSize.x ];
933 
934  for( signed int x = 0; x < (int)m_realBufferSize.x; ++x )
935  {
936  *ptr = m_postshader_ssao.Shade( SFVEC2I( x, y ) );
937  ptr++;
938  }
939  }
940 
941  // Wait for all threads to finish
942  #pragma omp barrier
943 
944  // Set next state
946  }
947  else
948  {
949  // As this was an invalid state, set to finish
951  }
952 }
SFVEC3F Shade(const SFVEC2I &aShaderPos) const override
CPOSTSHADER_SSAO m_postshader_ssao
glm::ivec2 SFVEC2I
Definition: xv3d_types.h:42
CINFO3D_VISU & m_settings
settings refrence in use for this render
RT_RENDER_STATE m_rt_render_state
State used on quality render.
bool GetFlag(DISPLAY3D_FLG aFlag) const
GetFlag - get a configuration status of a flag.
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_UNDEFINED)=0
Function Report is a pure virtual function to override in the derived object.
void C3D_RENDER_RAYTRACING::rt_render_trace_block ( GLubyte *  ptrPBO,
signed int  iBlock 
)
private

Definition at line 661 of file c3d_render_raytracing.cpp.

References CINFO3D_VISU::CameraGet(), DISP_FACTOR, FL_RENDER_RAYTRACING_ANTI_ALIASING, FL_RENDER_RAYTRACING_POST_PROCESSING, FL_RENDER_RAYTRACING_SHADOWS, CINFO3D_VISU::GetFlag(), HITINFO_PACKET_init(), CGENERICACCELERATOR::Intersect(), m_accelerator, m_BgColorBot_LinearRGB, m_BgColorTop_LinearRGB, m_blockPositions, m_postshader_ssao, m_realBufferSize, C3D_RENDER_BASE::m_settings, C3D_RENDER_BASE::m_windowSize, m_xoffset, m_yoffset, RAYPACKET_DIM, RAYPACKET_InitRays_with2DDisplacement(), RAYPACKET_RAYS_PER_PACKET, rt_final_color(), rt_shades_packet(), rt_trace_AA_packet(), and CPOSTSHADER::SetPixelData().

Referenced by rt_render_tracing().

663 {
664  // Initialize ray packets
665  // /////////////////////////////////////////////////////////////////////////
666  const SFVEC2UI &blockPos = m_blockPositions[iBlock];
667  const SFVEC2I blockPosI = SFVEC2I( blockPos.x + m_xoffset,
668  blockPos.y + m_yoffset );
669 
670  RAYPACKET blockPacket( m_settings.CameraGet(),
671  (SFVEC2F)blockPosI + SFVEC2F(DISP_FACTOR, DISP_FACTOR),
672  SFVEC2F(DISP_FACTOR, DISP_FACTOR) // Displacement random factor
673  );
674 
676 
677  HITINFO_PACKET_init( hitPacket_X0Y0 );
678 
679  // Calculate background gradient color
680  // /////////////////////////////////////////////////////////////////////////
681  SFVEC3F bgColor[RAYPACKET_DIM];// Store a vertical gradient color
682 
683  for( unsigned int y = 0; y < RAYPACKET_DIM; ++y )
684  {
685  const float posYfactor = (float)(blockPosI.y + y) / (float)m_windowSize.y;
686 
687  bgColor[y] = m_BgColorTop_LinearRGB * SFVEC3F(posYfactor) +
688  m_BgColorBot_LinearRGB * ( SFVEC3F(1.0f) - SFVEC3F(posYfactor) );
689  }
690 
691  // Intersect ray packets (calculate the intersection with rays and objects)
692  // /////////////////////////////////////////////////////////////////////////
693  if( !m_accelerator->Intersect( blockPacket, hitPacket_X0Y0 ) )
694  {
695 
696  // If block is empty then set shades and continue
698  {
699  for( unsigned int y = 0; y < RAYPACKET_DIM; ++y )
700  {
701  const SFVEC3F &outColor = bgColor[y];
702 
703  const unsigned int yBlockPos = blockPos.y + y;
704 
705  for( unsigned int x = 0; x < RAYPACKET_DIM; ++x )
706  {
707  m_postshader_ssao.SetPixelData( blockPos.x + x,
708  yBlockPos,
709  SFVEC3F(),
710  outColor,
711  SFVEC3F(),
712  0,
713  1.0f );
714  }
715  }
716  }
717 
718  // This will set the output color to be displayed
719  // If post processing is enabled, it will not reflect the final result
720  // (as the final color will be computed on post processing)
721  // but it is used for report progress
722 
723  const bool isFinalColor = !m_settings.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING );
724 
725  for( unsigned int y = 0; y < RAYPACKET_DIM; ++y )
726  {
727  const SFVEC3F &outColor = bgColor[y];
728 
729  const unsigned int yConst = blockPos.x +
730  ( (y + blockPos.y) * m_realBufferSize.x);
731 
732  for( unsigned int x = 0; x < RAYPACKET_DIM; ++x )
733  {
734  GLubyte *ptr = &ptrPBO[ (yConst + x) * 4 ];
735 
736  rt_final_color( ptr, outColor, isFinalColor );
737  }
738  }
739 
740  // There is nothing more here to do.. there are no hits ..
741  // just background so continue
742  return;
743  }
744 
745 
746  SFVEC3F hitColor_X0Y0[RAYPACKET_RAYS_PER_PACKET];
747 
748  // Shade original (0, 0) hits ("paint" the intersected objects)
749  // /////////////////////////////////////////////////////////////////////////
750  rt_shades_packet( bgColor,
751  blockPacket.m_ray,
752  hitPacket_X0Y0,
754  hitColor_X0Y0 );
755 
757  {
758  SFVEC3F hitColor_AA_X1Y1[RAYPACKET_RAYS_PER_PACKET];
759 
760 
761  // Intersect one blockPosI + (0.5, 0.5) used for anti aliasing calculation
762  // /////////////////////////////////////////////////////////////////////////
763  HITINFO_PACKET hitPacket_AA_X1Y1[RAYPACKET_RAYS_PER_PACKET];
764  HITINFO_PACKET_init( hitPacket_AA_X1Y1 );
765 
766  RAYPACKET blockPacket_AA_X1Y1( m_settings.CameraGet(),
767  (SFVEC2F)blockPosI + SFVEC2F(0.5f, 0.5f),
768  SFVEC2F(DISP_FACTOR, DISP_FACTOR) // Displacement random factor
769  );
770 
771  if( !m_accelerator->Intersect( blockPacket_AA_X1Y1, hitPacket_AA_X1Y1 ) )
772  {
773  // Missed all the package
774  for( unsigned int y = 0, i = 0; y < RAYPACKET_DIM; ++y )
775  {
776  const SFVEC3F &outColor = bgColor[y];
777 
778  for( unsigned int x = 0; x < RAYPACKET_DIM; ++x, ++i )
779  {
780  hitColor_AA_X1Y1[i] = outColor;
781  }
782  }
783  }
784  else
785  {
786  rt_shades_packet( bgColor,
787  blockPacket_AA_X1Y1.m_ray,
788  hitPacket_AA_X1Y1,
790  hitColor_AA_X1Y1
791  );
792  }
793 
794  SFVEC3F hitColor_AA_X1Y0[RAYPACKET_RAYS_PER_PACKET];
795  SFVEC3F hitColor_AA_X0Y1[RAYPACKET_RAYS_PER_PACKET];
796  SFVEC3F hitColor_AA_X0Y1_half[RAYPACKET_RAYS_PER_PACKET];
797 
798  for( unsigned int i = 0; i < RAYPACKET_RAYS_PER_PACKET; ++i )
799  {
800  const SFVEC3F color_average = ( hitColor_X0Y0[i] +
801  hitColor_AA_X1Y1[i] ) * SFVEC3F(0.5f);
802 
803  hitColor_AA_X1Y0[i] = color_average;
804  hitColor_AA_X0Y1[i] = color_average;
805  hitColor_AA_X0Y1_half[i] = color_average;
806  }
807 
808  RAY blockRayPck_AA_X1Y0[RAYPACKET_RAYS_PER_PACKET];
809  RAY blockRayPck_AA_X0Y1[RAYPACKET_RAYS_PER_PACKET];
810  RAY blockRayPck_AA_X1Y1_half[RAYPACKET_RAYS_PER_PACKET];
811 
813  (SFVEC2F)blockPosI + SFVEC2F(0.5f - DISP_FACTOR, DISP_FACTOR),
814  SFVEC2F(DISP_FACTOR, DISP_FACTOR), // Displacement random factor
815  blockRayPck_AA_X1Y0 );
816 
818  (SFVEC2F)blockPosI + SFVEC2F(DISP_FACTOR, 0.5f - DISP_FACTOR),
819  SFVEC2F(DISP_FACTOR, DISP_FACTOR), // Displacement random factor
820  blockRayPck_AA_X0Y1 );
821 
823  (SFVEC2F)blockPosI + SFVEC2F(0.25f - DISP_FACTOR, 0.25f - DISP_FACTOR),
824  SFVEC2F(DISP_FACTOR, DISP_FACTOR), // Displacement random factor
825  blockRayPck_AA_X1Y1_half );
826 
827  rt_trace_AA_packet( bgColor,
828  hitPacket_X0Y0, hitPacket_AA_X1Y1,
829  blockRayPck_AA_X1Y0,
830  hitColor_AA_X1Y0 );
831 
832  rt_trace_AA_packet( bgColor,
833  hitPacket_X0Y0, hitPacket_AA_X1Y1,
834  blockRayPck_AA_X0Y1,
835  hitColor_AA_X0Y1 );
836 
837  rt_trace_AA_packet( bgColor,
838  hitPacket_X0Y0, hitPacket_AA_X1Y1,
839  blockRayPck_AA_X1Y1_half,
840  hitColor_AA_X0Y1_half );
841 
842  // Average the result
843  for( unsigned int i = 0; i < RAYPACKET_RAYS_PER_PACKET; ++i )
844  {
845  hitColor_X0Y0[i] = ( hitColor_X0Y0[i] +
846  hitColor_AA_X1Y1[i] +
847  hitColor_AA_X1Y0[i] +
848  hitColor_AA_X0Y1[i] +
849  hitColor_AA_X0Y1_half[i]
850  ) * SFVEC3F(1.0f / 5.0f);
851  }
852  }
853 
854 
855  // Copy results to the next stage
856  // /////////////////////////////////////////////////////////////////////
857 
858  GLubyte *ptr = &ptrPBO[ ( blockPos.x +
859  (blockPos.y * m_realBufferSize.x) ) * 4 ];
860 
861  const uint32_t ptrInc = (m_realBufferSize.x - RAYPACKET_DIM) * 4;
862 
864  {
865  SFVEC2I bPos;
866  bPos.y = blockPos.y;
867 
868  for( unsigned int y = 0, i = 0; y < RAYPACKET_DIM; ++y )
869  {
870  bPos.x = blockPos.x;
871 
872  for( unsigned int x = 0; x < RAYPACKET_DIM; ++x, ++i )
873  {
874  const SFVEC3F &hColor = hitColor_X0Y0[i];
875 
876  if( hitPacket_X0Y0[i].m_hitresult == true )
877  m_postshader_ssao.SetPixelData( bPos.x, bPos.y,
878  hitPacket_X0Y0[i].m_HitInfo.m_HitNormal,
879  hColor,
880  blockPacket.m_ray[i].at(
881  hitPacket_X0Y0[i].m_HitInfo.m_tHit ),
882  hitPacket_X0Y0[i].m_HitInfo.m_tHit,
883  hitPacket_X0Y0[i].m_HitInfo.m_ShadowFactor );
884  else
885  m_postshader_ssao.SetPixelData( bPos.x, bPos.y,
886  SFVEC3F(),
887  hColor,
888  SFVEC3F(),
889  0,
890  1.0f );
891 
892  rt_final_color( ptr, hColor, false );
893 
894  bPos.x++;
895  ptr += 4;
896  }
897 
898  ptr += ptrInc;
899  bPos.y++;
900  }
901  }
902  else
903  {
904  for( unsigned int y = 0, i = 0; y < RAYPACKET_DIM; ++y )
905  {
906  for( unsigned int x = 0; x < RAYPACKET_DIM; ++x, ++i )
907  {
908  rt_final_color( ptr, hitColor_X0Y0[i], true );
909  ptr += 4;
910  }
911 
912  ptr += ptrInc;
913  }
914  }
915 }
#define RAYPACKET_DIM
Definition: raypacket.h:37
void rt_shades_packet(const SFVEC3F *bgColorY, const RAY *aRayPkt, HITINFO_PACKET *aHitPacket, bool is_testShadow, SFVEC3F *aOutHitColor)
void rt_final_color(GLubyte *ptrPBO, const SFVEC3F &rgbColor, bool applyColorSpaceConversion)
CPOSTSHADER_SSAO m_postshader_ssao
Definition: ray.h:43
glm::ivec2 SFVEC2I
Definition: xv3d_types.h:42
CINFO3D_VISU & m_settings
settings refrence in use for this render
glm::uvec2 SFVEC2UI
Definition: xv3d_types.h:41
CGENERICACCELERATOR * m_accelerator
glm::vec2 SFVEC2F
Definition: xv3d_types.h:45
virtual bool Intersect(const RAY &aRay, HITINFO &aHitInfo) const =0
wxSize m_windowSize
The window size that this camera is working.
void rt_trace_AA_packet(const SFVEC3F *aBgColorY, const HITINFO_PACKET *aHitPck_X0Y0, const HITINFO_PACKET *aHitPck_AA_X1Y1, const RAY *aRayPck, SFVEC3F *aOutHitColor)
static void HITINFO_PACKET_init(HITINFO_PACKET *aHitPacket)
bool GetFlag(DISPLAY3D_FLG aFlag) const
GetFlag - get a configuration status of a flag.
void SetPixelData(unsigned int x, unsigned int y, const SFVEC3F &aNormal, const SFVEC3F &aColor, const SFVEC3F &aHitPosition, float aDepth, float aShadowAttFactor)
Definition: cpostshader.cpp:78
#define RAYPACKET_RAYS_PER_PACKET
Definition: raypacket.h:40
CCAMERA & CameraGet() const
CameraGet - get current camera in use.
Definition: cinfo3d_visu.h:210
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
#define DISP_FACTOR
std::vector< SFVEC2UI > m_blockPositions
this encodes the Morton code positions
void RAYPACKET_InitRays_with2DDisplacement(const CCAMERA &aCamera, const SFVEC2F &aWindowsPosition, const SFVEC2F &a2DWindowsPosDisplacementFactor, RAY *aRayPck)
Definition: raypacket.cpp:174
void C3D_RENDER_RAYTRACING::rt_render_tracing ( GLubyte *  ptrPBO,
REPORTER aStatusTextReporter 
)
private

Definition at line 363 of file c3d_render_raytracing.cpp.

References FL_RENDER_RAYTRACING_POST_PROCESSING, Format(), CINFO3D_VISU::GetFlag(), GetRunningMicroSecs(), m_blockPositions, m_blockPositionsWasProcessed, m_isPreview, m_nrBlocksRenderProgress, m_rt_render_state, C3D_RENDER_BASE::m_settings, REPORTER::Report(), RT_RENDER_STATE_FINISH, RT_RENDER_STATE_POST_PROCESS_SHADE, and rt_render_trace_block().

Referenced by render().

365 {
366  m_isPreview = false;
367  wxASSERT( m_blockPositions.size() <= LONG_MAX );
368 
369  const long nrBlocks = (long) m_blockPositions.size();
370  const unsigned startTime = GetRunningMicroSecs();
371  bool breakLoop = false;
372  int numBlocksRendered = 0;
373 
374  #pragma omp parallel for schedule(dynamic) shared(breakLoop) \
375  firstprivate(ptrPBO, nrBlocks, startTime) reduction(+:numBlocksRendered) default(none)
376  for( long iBlock = 0; iBlock < nrBlocks; iBlock++ )
377  {
378 
379  #pragma omp flush(breakLoop)
380  if( !breakLoop )
381  {
382  bool process_block;
383 
384  // std::vector<bool> stuffs eight bools to each byte, so access to
385  // them can never be natively atomic.
386  #pragma omp critical(checkProcessBlock)
387  {
388  process_block = !m_blockPositionsWasProcessed[iBlock];
389  m_blockPositionsWasProcessed[iBlock] = true;
390  }
391 
392  if( process_block )
393  {
394  rt_render_trace_block( ptrPBO, iBlock );
395  numBlocksRendered++;
396 
397 
398  // Check if it spend already some time render and request to exit
399  // to display the progress
400  #ifdef _OPENMP
401  if( omp_get_thread_num() == 0 )
402  #endif
403  if( (GetRunningMicroSecs() - startTime) > 150000 )
404  {
405  breakLoop = true;
406  #pragma omp flush(breakLoop)
407  }
408  }
409  }
410  }
411 
412  m_nrBlocksRenderProgress += numBlocksRendered;
413 
414  if( aStatusTextReporter )
415  aStatusTextReporter->Report( wxString::Format( _( "Rendering: %.0f %%" ),
416  (float)(m_nrBlocksRenderProgress * 100) /
417  (float)nrBlocks ) );
418 
419  // Check if it finish the rendering and if should continue to a post processing
420  // or mark it as finished
421  if( m_nrBlocksRenderProgress >= nrBlocks )
422  {
425  else
426  {
428  }
429  }
430 }
std::vector< bool > m_blockPositionsWasProcessed
this flags if a position was already processed (cleared each new render)
long m_nrBlocksRenderProgress
Save the number of blocks progress of the render.
CINFO3D_VISU & m_settings
settings refrence in use for this render
RT_RENDER_STATE m_rt_render_state
State used on quality render.
bool GetFlag(DISPLAY3D_FLG aFlag) const
GetFlag - get a configuration status of a flag.
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
unsigned GetRunningMicroSecs()
Function GetRunningMicroSecs An alternate way to calculate an elapset time (in microsecondes) to clas...
std::vector< SFVEC2UI > m_blockPositions
this encodes the Morton code positions
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_UNDEFINED)=0
Function Report is a pure virtual function to override in the derived object.
void rt_render_trace_block(GLubyte *ptrPBO, signed int iBlock)
void C3D_RENDER_RAYTRACING::rt_shades_packet ( const SFVEC3F bgColorY,
const RAY aRayPkt,
HITINFO_PACKET aHitPacket,
bool  is_testShadow,
SFVEC3F aOutHitColor 
)
private

Definition at line 506 of file c3d_render_raytracing.cpp.

References RAYPACKET_DIM, and shadeHit().

Referenced by rt_render_trace_block().

511 {
512  for( unsigned int y = 0, i = 0; y < RAYPACKET_DIM; ++y )
513  {
514  for( unsigned int x = 0; x < RAYPACKET_DIM; ++x, ++i )
515  {
516  if( aHitPacket[i].m_hitresult == true )
517  {
518  aOutHitColor[i] = shadeHit( bgColorY[y],
519  aRayPkt[i],
520  aHitPacket[i].m_HitInfo,
521  false,
522  0,
523  is_testShadow );
524  }
525  else
526  {
527  aOutHitColor[i] = bgColorY[y];
528  }
529  }
530  }
531 }
#define RAYPACKET_DIM
Definition: raypacket.h:37
SFVEC3F shadeHit(const SFVEC3F &aBgColor, const RAY &aRay, HITINFO &aHitInfo, bool aIsInsideObject, unsigned int aRecursiveLevel, bool is_testShadow) const
void C3D_RENDER_RAYTRACING::rt_trace_AA_packet ( const SFVEC3F aBgColorY,
const HITINFO_PACKET aHitPck_X0Y0,
const HITINFO_PACKET aHitPck_AA_X1Y1,
const RAY aRayPck,
SFVEC3F aOutHitColor 
)
private

Definition at line 534 of file c3d_render_raytracing.cpp.

References FL_RENDER_RAYTRACING_SHADOWS, CINFO3D_VISU::GetFlag(), CGENERICACCELERATOR::Intersect(), HITINFO::m_acc_node_info, m_accelerator, HITINFO_PACKET::m_HitInfo, C3D_RENDER_BASE::m_settings, HITINFO::m_tHit, RAYPACKET_DIM, and shadeHit().

Referenced by rt_render_trace_block().

539 {
540  const bool is_testShadow = m_settings.GetFlag( FL_RENDER_RAYTRACING_SHADOWS );
541 
542  for( unsigned int y = 0, i = 0; y < RAYPACKET_DIM; ++y )
543  {
544  for( unsigned int x = 0; x < RAYPACKET_DIM; ++x, ++i )
545  {
546  const RAY &rayAA = aRayPck[i];
547 
548  HITINFO hitAA;
549  hitAA.m_tHit = std::numeric_limits<float>::infinity();
550  hitAA.m_acc_node_info = 0;
551 
552  bool hitted = false;
553 
554  const unsigned int idx0y1 = ( x + 0 ) + RAYPACKET_DIM * ( y + 1 );
555  const unsigned int idx1y1 = ( x + 1 ) + RAYPACKET_DIM * ( y + 1 );
556 
557  // Gets the node info from the hit.
558  const unsigned int nodex0y0 = aHitPck_X0Y0[ i ].m_HitInfo.m_acc_node_info;
559  const unsigned int node_AA_x0y0 = aHitPck_AA_X1Y1[ i ].m_HitInfo.m_acc_node_info;
560 
561  unsigned int nodex1y0 = 0;
562 
563  if( x < (RAYPACKET_DIM - 1) )
564  nodex1y0 = aHitPck_X0Y0[ i + 1 ].m_HitInfo.m_acc_node_info;
565 
566  unsigned int nodex0y1 = 0;
567 
568  if( y < (RAYPACKET_DIM - 1) )
569  nodex0y1 = aHitPck_X0Y0[ idx0y1 ].m_HitInfo.m_acc_node_info;
570 
571  unsigned int nodex1y1 = 0;
572 
573  if( ((x < (RAYPACKET_DIM - 1)) &&
574  (y < (RAYPACKET_DIM - 1))) )
575  nodex1y1 = aHitPck_X0Y0[ idx1y1 ].m_HitInfo.m_acc_node_info;
576 
577 
578  if( ((nodex0y0 == nodex1y0) || (nodex1y0 == 0)) && // If all notes are equal we assume there was no change on the object hits
579  ((nodex0y0 == nodex0y1) || (nodex0y1 == 0)) &&
580  ((nodex0y0 == nodex1y1) || (nodex1y1 == 0)) &&
581  (nodex0y0 == node_AA_x0y0) )
582  {
583  // Option 1
584  // This option will give a very good quality on reflections (slow)
585  /*
586  if( m_accelerator->Intersect( rayAA, hitAA, nodex0y0 ) )
587  {
588  aOutHitColor[i] += shadeHit( aBgColorY[y], rayAA, hitAA, false, 0 );
589  }
590  else
591  {
592  if( m_accelerator->Intersect( rayAA, hitAA ) )
593  aOutHitColor[i] += shadeHit( aBgColorY[y], rayAA, hitAA, false, 0 );
594  else
595  aOutHitColor[i] += hitColor[i];
596  }
597  */
598 
599  // Option 2
600  // Trace again with the same node,
601  // then if miss just give the same color as before
602  //if( m_accelerator->Intersect( rayAA, hitAA, nodex0y0 ) )
603  // aOutHitColor[i] += shadeHit( aBgColorY[y], rayAA, hitAA, false, 0 );
604 
605  // Option 3
606  // Use same color
607 
608  }
609  else
610  {
611  // Try to intersect the different nodes
612  // It tests the possible combination of hitted or not hitted points
613  // This will try to get the best hit for this ray
614 
615  if( nodex0y0 != 0 )
616  hitted |= m_accelerator->Intersect( rayAA, hitAA, nodex0y0 );
617 
618  if( ( nodex1y0 != 0 ) &&
619  ( nodex0y0 != nodex1y0 ) )
620  hitted |= m_accelerator->Intersect( rayAA, hitAA, nodex1y0 );
621 
622  if( ( nodex0y1 != 0 ) &&
623  ( nodex0y0 != nodex0y1 ) &&
624  ( nodex1y0 != nodex0y1 ) )
625  hitted |= m_accelerator->Intersect( rayAA, hitAA, nodex0y1 );
626 
627  if( (nodex1y1 != 0 ) &&
628  ( nodex0y0 != nodex1y1 ) &&
629  ( nodex0y1 != nodex1y1 ) &&
630  ( nodex1y0 != nodex1y1 ) )
631  hitted |= m_accelerator->Intersect( rayAA, hitAA, nodex1y1 );
632 
633  if( (node_AA_x0y0 != 0 ) &&
634  ( nodex0y0 != node_AA_x0y0 ) &&
635  ( nodex0y1 != node_AA_x0y0 ) &&
636  ( nodex1y0 != node_AA_x0y0 ) &&
637  ( nodex1y1 != node_AA_x0y0 ) )
638  hitted |= m_accelerator->Intersect( rayAA, hitAA, node_AA_x0y0 );
639 
640  if( hitted )
641  {
642  // If we got any result, shade it
643  aOutHitColor[i] = shadeHit( aBgColorY[y], rayAA, hitAA, false, 0, is_testShadow );
644  }
645  else
646  {
647  // Note: There are very few cases that will end on this situation
648  // so it is not so expensive to trace a single ray from the beginning
649 
650  // It was missed the 'last nodes' so, trace a ray from the beginning
651  if( m_accelerator->Intersect( rayAA, hitAA ) )
652  aOutHitColor[i] = shadeHit( aBgColorY[y], rayAA, hitAA, false, 0, is_testShadow );
653  }
654  }
655  }
656  }
657 }
#define RAYPACKET_DIM
Definition: raypacket.h:37
SFVEC3F shadeHit(const SFVEC3F &aBgColor, const RAY &aRay, HITINFO &aHitInfo, bool aIsInsideObject, unsigned int aRecursiveLevel, bool is_testShadow) const
Definition: ray.h:43
CINFO3D_VISU & m_settings
settings refrence in use for this render
float m_tHit
( 4) distance
Definition: hitinfo.h:43
CGENERICACCELERATOR * m_accelerator
virtual bool Intersect(const RAY &aRay, HITINFO &aHitInfo) const =0
HITINFO m_HitInfo
Definition: hitinfo.h:63
bool GetFlag(DISPLAY3D_FLG aFlag) const
GetFlag - get a configuration status of a flag.
Stores the hit information of a ray with a point on the surface of a object.
Definition: hitinfo.h:40
unsigned int m_acc_node_info
( 4) The acc stores here the node that it hits
Definition: hitinfo.h:47
void C3D_RENDER_RAYTRACING::SetCurWindowSize ( const wxSize &  aSize)
overridevirtual

SetCurWindowSize - Before each render, the canvas will tell the render what is the size of its windows, so render can take actions if it changed.

Parameters
aSizethe current size of the render window

Implements C3D_RENDER_BASE.

Definition at line 114 of file c3d_render_raytracing.cpp.

References initializeNewWindowSize(), and C3D_RENDER_BASE::m_windowSize.

115 {
116  if( m_windowSize != aSize )
117  {
118  m_windowSize = aSize;
119  glViewport( 0, 0, m_windowSize.x, m_windowSize.y );
120 
122  }
123 }
wxSize m_windowSize
The window size that this camera is working.
void C3D_RENDER_RAYTRACING::setupMaterials ( )
private

Definition at line 56 of file c3d_render_createscene.cpp.

References CINFO3D_VISU::BiuTo3Dunits(), ConvertSRGBToLinear(), FL_RENDER_RAYTRACING_PROCEDURAL_TEXTURES, CINFO3D_VISU::GetFlag(), CINFO3D_VISU::m_BgColorTop, m_board_normal_perturbator, m_brushed_metal_normal_perturbator, m_copper_normal_perturbator, CINFO3D_VISU::m_CopperColor, m_materials, m_plastic_normal_perturbator, m_plastic_shine_normal_perturbator, C3D_RENDER_BASE::m_settings, CINFO3D_VISU::m_SilkScreenColor, m_solder_mask_normal_perturbator, CINFO3D_VISU::m_SolderMaskColor, and CINFO3D_VISU::m_SolderPasteColor.

Referenced by reload().

57 {
58 
60  {
62 
65 
67 
69 
71 
73  }
74 
75  // http://devernay.free.fr/cours/opengl/materials.html
76 
77  // Copper
80  (SFVEC3F)(0.18f), // ambient
81  SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive
82  glm::clamp( ((SFVEC3F)(1.0f) -
84  SFVEC3F( 0.0f ),
85  SFVEC3F( 0.35f ) ), // specular
86  0.4f * 128.0f, // shiness
87  0.0f, // transparency
88  0.0f );
89 
91  m_materials.m_Copper.SetNormalPerturbator( &m_copper_normal_perturbator );
92 
96  SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive
99  0.10f * 128.0f, // shiness
100  0.0f, // transparency
101  0.0f );
102 
104  ConvertSRGBToLinear( SFVEC3F( 0.11f ) ),// ambient
105  SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive
106  glm::clamp( ((SFVEC3F)(1.0f) -
108  SFVEC3F( 0.0f ),
109  SFVEC3F( 0.10f ) ), // specular
110  0.078125f * 128.0f, // shiness
111  0.0f, // transparency
112  0.0f );
113 
114  const float solderMask_gray = ( m_settings.m_SolderMaskColor.r +
116  m_settings.m_SolderMaskColor.b ) / 3.0f;
117 
118  const float solderMask_transparency = solderMask_gray * 0.40f + 0.005f;
119 
120  m_materials.m_SolderMask = CBLINN_PHONG_MATERIAL(
122  0.10f, // ambient
123  SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive
124  glm::clamp( ( (SFVEC3F)( 1.0f ) -
126  SFVEC3F( 0.0f ),
127  SFVEC3F( solderMask_gray * 2.0f ) ), // specular
128  0.85f * 128.0f, // shiness
129  solderMask_transparency, // transparency
130  0.16f ); // reflection
131 
132  m_materials.m_SolderMask.SetCastShadows( true );
133  m_materials.m_SolderMask.SetNrRefractionsSamples( 1 );
134  m_materials.m_SolderMask.SetNrReflectionsSamples( 2 );
135 
137  m_materials.m_SolderMask.SetNormalPerturbator( &m_solder_mask_normal_perturbator );
138 
139  m_materials.m_EpoxyBoard = CBLINN_PHONG_MATERIAL(
140  ConvertSRGBToLinear( SFVEC3F( 16.0f / 255.0f,
141  14.0f / 255.0f,
142  10.0f / 255.0f ) ), // ambient
143  SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive
144  ConvertSRGBToLinear( SFVEC3F( 10.0f / 255.0f,
145  8.0f / 255.0f,
146  10.0f / 255.0f ) ), // specular
147  0.1f * 128.0f, // shiness
148  0.10f, // transparency
149  0.0f ); // reflection
150 
151  m_materials.m_EpoxyBoard.SetAbsorvance( 10.0f );
152  m_materials.m_EpoxyBoard.SetNrRefractionsSamples( 3 );
153 
155  m_materials.m_EpoxyBoard.SetNormalPerturbator( &m_board_normal_perturbator );
156 
158  //SFVEC3F bgBot = (SFVEC3F)m_settings.m_BgColorBot;
159 
161  bgTop * 0.125f, // ambient
162  SFVEC3F( 0.0f, 0.0f, 0.0f ), // emissive
163  (SFVEC3F(1.0f) - bgTop) / 3.0f, // specular
164  0.10f * 128.0f, // shiness
165  0.0f, // transparency
166  0.50f ); // reflection
167 }
CPLASTICNORMAL m_plastic_normal_perturbator
SFVEC3F ConvertSRGBToLinear(const SFVEC3F &aSRGBcolor)
CBOARDNORMAL m_board_normal_perturbator
SFVEC3D m_CopperColor
in realistic mode: copper color
Definition: cinfo3d_visu.h:509
CCOPPERNORMAL m_copper_normal_perturbator
CPLASTICSHINENORMAL m_plastic_shine_normal_perturbator
CMETALBRUSHEDNORMAL m_brushed_metal_normal_perturbator
CINFO3D_VISU & m_settings
settings refrence in use for this render
SFVEC3D m_BgColorTop
background top color
Definition: cinfo3d_visu.h:504
Blinn Phong based material https://en.wikipedia.org/wiki/Blinn%E2%80%93Phong_shading_model.
Definition: cmaterial.h:248
SFVEC3D m_SolderPasteColor
in realistic mode: solder paste color
Definition: cinfo3d_visu.h:507
SFVEC3D m_SolderMaskColor
in realistic mode: solder mask color
Definition: cinfo3d_visu.h:506
struct C3D_RENDER_RAYTRACING::@31 m_materials
bool GetFlag(DISPLAY3D_FLG aFlag) const
GetFlag - get a configuration status of a flag.
SFVEC3D m_SilkScreenColor
in realistic mode: SilkScreen color
Definition: cinfo3d_visu.h:508
CSOLDERMASKNORMAL m_solder_mask_normal_perturbator
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
double BiuTo3Dunits() const
BiuTo3Dunits - Board integer units To 3D units.
Definition: cinfo3d_visu.h:141
SFVEC3F C3D_RENDER_RAYTRACING::shadeHit ( const SFVEC3F aBgColor,
const RAY aRay,
HITINFO aHitInfo,
bool  aIsInsideObject,
unsigned int  aRecursiveLevel,
bool  is_testShadow 
) const
private

Definition at line 1706 of file c3d_render_raytracing.cpp.

References RAY::at(), FL_RENDER_RAYTRACING_ANTI_ALIASING, FL_RENDER_RAYTRACING_POST_PROCESSING, FL_RENDER_RAYTRACING_REFLECTIONS, FL_RENDER_RAYTRACING_REFRACTIONS, CMATERIAL::GetAbsorvance(), CMATERIAL::GetAmbientColor(), CLIGHT::GetCastShadows(), COBJECT::GetDiffuseColor(), CMATERIAL::GetEmissiveColor(), CINFO3D_VISU::GetFlag(), CLIGHT::GetLightParameters(), CLIGHTCONTAINER::GetList(), COBJECT::GetMaterial(), CINFO3D_VISU::GetNonCopperLayerThickness3DU(), CMATERIAL::GetNrReflectionsSamples(), CMATERIAL::GetNrRefractionsSamples(), CMATERIAL::GetReflection(), CMATERIAL::GetSpecularColor(), CMATERIAL::GetTransparency(), RAY::Init(), CGENERICACCELERATOR::Intersect(), CGENERICACCELERATOR::IntersectP(), m_accelerator, RAY::m_Dir, HITINFO::m_HitNormal, HITINFO::m_HitPoint, m_isPreview, m_lights, C3D_RENDER_BASE::m_settings, HITINFO::m_ShadowFactor, HITINFO::m_tHit, max, min, NextFloatUp(), HITINFO::pHitObject, Refract(), CMATERIAL::Shade(), and UniformRandomHemisphereDirection().

Referenced by render_preview(), rt_shades_packet(), and rt_trace_AA_packet().

1712 {
1713  if( aRecursiveLevel > 2 )
1714  return SFVEC3F( 0.0f );
1715 
1716  SFVEC3F hitPoint = aHitInfo.m_HitPoint;
1717 
1718  if( !m_isPreview )
1719  hitPoint += aHitInfo.m_HitNormal * m_settings.GetNonCopperLayerThickness3DU() * 1.0f;
1720 
1721  const CMATERIAL *objMaterial = aHitInfo.pHitObject->GetMaterial();
1722  wxASSERT( objMaterial != NULL );
1723 
1724  const SFVEC3F diffuseColorObj = aHitInfo.pHitObject->GetDiffuseColor( aHitInfo );
1725 
1726  SFVEC3F outColor = objMaterial->GetEmissiveColor();
1727 
1728  const LIST_LIGHT &lightList = m_lights.GetList();
1729 
1730 #if USE_EXPERIMENTAL_SOFT_SHADOWS
1731  const bool is_aa_enabled = m_settings.GetFlag( FL_RENDER_RAYTRACING_ANTI_ALIASING ) &&
1732  (!m_isPreview);
1733 #endif
1734 
1735  float shadow_att_factor_sum = 0.0f;
1736 
1737  unsigned int nr_lights_that_can_cast_shadows = 0;
1738 
1739  for( LIST_LIGHT::const_iterator ii = lightList.begin();
1740  ii != lightList.end();
1741  ++ii )
1742  {
1743  const CLIGHT *light = (CLIGHT *)*ii;
1744 
1745  SFVEC3F vectorToLight;
1746  SFVEC3F colorOfLight;
1747  float distToLight;
1748 
1749  light->GetLightParameters( hitPoint, vectorToLight, colorOfLight, distToLight );
1750 
1751  if( m_isPreview )
1752  colorOfLight = SFVEC3F( 1.0f );
1753 
1754  /*
1755  if( (!m_isPreview) &&
1756  // Little hack to make randomness to the shading and shadows
1757  m_settings.GetFlag( FL_RENDER_RAYTRACING_POST_PROCESSING ) )
1758  vectorToLight = glm::normalize( vectorToLight +
1759  UniformRandomHemisphereDirection() * 0.1f );
1760  */
1761 
1762  const float NdotL = glm::dot( aHitInfo.m_HitNormal, vectorToLight );
1763 
1764  // Only calc shade if the normal is facing the direction of light,
1765  // otherwise it is in the shadow
1766  if( NdotL >= FLT_EPSILON )
1767  {
1768  float shadow_att_factor_light = 1.0f;
1769 
1770  if( is_testShadow && light->GetCastShadows() )
1771  {
1772  nr_lights_that_can_cast_shadows++;
1773 #if USE_EXPERIMENTAL_SOFT_SHADOWS
1774  if( (!is_aa_enabled) ||
1775 
1776  // For rays that are recursive, just calculate one hit shadow
1777  (aRecursiveLevel > 0) ||
1778 
1779  // Only use soft shadows if using post processing
1781  )
1782  {
1783 #endif
1784  RAY rayToLight;
1785  rayToLight.Init( hitPoint, vectorToLight );
1786 
1787  // Test if point is not in the shadow.
1788  // Test for any hit from the point in the direction of light
1789  if( m_accelerator->IntersectP( rayToLight, distToLight ) )
1790  shadow_att_factor_light = 0.0f;
1791 
1792 #if USE_EXPERIMENTAL_SOFT_SHADOWS
1793  }
1794 
1795  // Experimental softshadow calculation
1796  else
1797  {
1798 
1799  const unsigned int shadow_number_of_samples = 3;
1800  const float shadow_inc_factor = 1.0f / (float)(shadow_number_of_samples);
1801 
1802  for( unsigned int i = 0; i < shadow_number_of_samples; ++i )
1803  {
1804  const SFVEC3F unifVector = UniformRandomHemisphereDirection();
1805  const SFVEC3F disturbed_vector_to_light = glm::normalize( vectorToLight +
1806  unifVector *
1807  0.05f );
1808 
1809  RAY rayToLight;
1810  rayToLight.Init( hitPoint, disturbed_vector_to_light );
1811 
1812  // !TODO: there are multiple ways that this tests can be
1813  // optimized. Eg: by packing rays or to test against the
1814  // latest hit object.
1815 
1816  if( m_accelerator->IntersectP( rayToLight, distToLight ) )
1817  {
1818  shadow_att_factor_light -= shadow_inc_factor;
1819  }
1820  }
1821  }
1822 #endif
1823  shadow_att_factor_sum += shadow_att_factor_light;
1824  }
1825 
1827  {
1828  outColor += objMaterial->Shade( aRay,
1829  aHitInfo,
1830  NdotL,
1831  diffuseColorObj,
1832  vectorToLight,
1833  colorOfLight,
1834  shadow_att_factor_light );
1835  }
1836  else
1837  {
1838  // This is a render hack in order to compensate for the lack of
1839  // ambient and too much darkness when using post process shader
1840  // It will calculate as it was not in shadow
1841  outColor += objMaterial->Shade( aRay,
1842  aHitInfo,
1843  NdotL,
1844  diffuseColorObj,
1845  vectorToLight,
1846  colorOfLight,
1847  // The sampled point will be darkshaded by the post
1848  // processing, so here it compensates to not shadow
1849  // so much
1850  glm::min( shadow_att_factor_light + (3.0f / 6.0f), 1.0f )
1851  );
1852  }
1853  }
1854  else
1855  {
1856  outColor += objMaterial->GetAmbientColor();
1857  }
1858 
1859  // Only use the headlight for preview
1860  if( m_isPreview )
1861  break;
1862  }
1863 
1864  // Improvement: this is not taking in account the lightcolor
1865  if( nr_lights_that_can_cast_shadows > 0 )
1866  {
1867  aHitInfo.m_ShadowFactor = glm::max( shadow_att_factor_sum /
1868  (float)(nr_lights_that_can_cast_shadows * 1.0f), 0.0f );
1869  }
1870  else
1871  {
1872  aHitInfo.m_ShadowFactor = 1.0f;
1873  }
1874 
1875  // Clamp color to not be brighter than 1.0f
1876  outColor = glm::min( outColor, SFVEC3F( 1.0f ) );
1877 
1878  if( !m_isPreview )
1879  {
1880  // Reflections
1881  // /////////////////////////////////////////////////////////////////////
1882 
1883  if( !aIsInsideObject &&
1884  (objMaterial->GetReflection() > 0.0f) &&
1886  {
1887  const unsigned int reflection_number_of_samples = objMaterial->GetNrReflectionsSamples();
1888 
1889  SFVEC3F sum_color = SFVEC3F(0.0f);
1890 
1891  const SFVEC3F reflectVector = aRay.m_Dir -
1892  2.0f * glm::dot( aRay.m_Dir, aHitInfo.m_HitNormal ) *
1893  aHitInfo.m_HitNormal;
1894 
1895  for( unsigned int i = 0; i < reflection_number_of_samples; ++i )
1896  {
1897  // Apply some randomize to the reflected vector
1898  const SFVEC3F random_reflectVector =
1899  glm::normalize( reflectVector +
1901  0.025f );
1902 
1903  RAY reflectedRay;
1904  reflectedRay.Init( hitPoint, random_reflectVector );
1905 
1906  HITINFO reflectedHit;
1907  reflectedHit.m_tHit = std::numeric_limits<float>::infinity();
1908 
1909  if( m_accelerator->Intersect( reflectedRay, reflectedHit ) )
1910  {
1911  sum_color += ( diffuseColorObj + objMaterial->GetSpecularColor() ) *
1912  shadeHit( aBgColor,
1913  reflectedRay,
1914  reflectedHit,
1915  false,
1916  aRecursiveLevel + 1,
1917  is_testShadow ) *
1918  SFVEC3F( objMaterial->GetReflection() *
1919  // Falloff factor
1920  (1.0f / ( 1.0f + 0.75f * reflectedHit.m_tHit *
1921  reflectedHit.m_tHit) ) );
1922  }
1923  }
1924 
1925  outColor += (sum_color / SFVEC3F( (float)reflection_number_of_samples) );
1926  }
1927 
1928 
1929  // Refractions
1930  // /////////////////////////////////////////////////////////////////////
1931 
1932  if( (objMaterial->GetTransparency() > 0.0f) &&
1934  {
1935  const float airIndex = 1.000293f;
1936  const float glassIndex = 1.49f;
1937  const float air_over_glass = airIndex / glassIndex;
1938  const float glass_over_air = glassIndex / airIndex;
1939 
1940  const float refractionRatio = aIsInsideObject?glass_over_air:air_over_glass;
1941 
1942  SFVEC3F refractedVector;
1943 
1944  if( Refract( aRay.m_Dir,
1945  aHitInfo.m_HitNormal,
1946  refractionRatio,
1947  refractedVector ) )
1948  {
1949  const float objTransparency = objMaterial->GetTransparency();
1950 
1951  // This increase the start point by a "fixed" factor so it will work the
1952  // same for all distances
1953  const SFVEC3F startPoint = aRay.at( NextFloatUp(
1954  NextFloatUp(
1955  NextFloatUp( aHitInfo.m_tHit ) ) ) );
1956 
1957  const unsigned int refractions_number_of_samples = objMaterial->GetNrRefractionsSamples();
1958 
1959  SFVEC3F sum_color = SFVEC3F(0.0f);
1960 
1961  for( unsigned int i = 0; i < refractions_number_of_samples; ++i )
1962  {
1963  RAY refractedRay;
1964 
1965  if( refractions_number_of_samples > 1 )
1966  {
1967  // apply some randomize to the refracted vector
1968  const SFVEC3F randomizeRefractedVector = glm::normalize( refractedVector +
1970  0.15f *
1971  (1.0f - objTransparency) );
1972 
1973  refractedRay.Init( startPoint, randomizeRefractedVector );
1974  }
1975  else
1976  {
1977  refractedRay.Init( startPoint, refractedVector );
1978  }
1979 
1980  HITINFO refractedHit;
1981  refractedHit.m_tHit = std::numeric_limits<float>::infinity();
1982 
1983  SFVEC3F refractedColor = objMaterial->GetAmbientColor();
1984 
1985  if( m_accelerator->Intersect( refractedRay, refractedHit ) )
1986  {
1987  refractedColor = shadeHit( aBgColor,
1988  refractedRay,
1989  refractedHit,
1990  true,
1991  aRecursiveLevel + 1,
1992  false );
1993 
1994  const SFVEC3F absorbance = ( SFVEC3F(1.0f) - diffuseColorObj ) *
1995  (1.0f - objTransparency ) *
1996  objMaterial->GetAbsorvance() * // Adjust falloff factor
1997  -refractedHit.m_tHit;
1998 
1999  const SFVEC3F transparency = SFVEC3F( expf( absorbance.r ),
2000  expf( absorbance.g ),
2001  expf( absorbance.b ) );
2002 
2003  sum_color += refractedColor * transparency * objTransparency;
2004  }
2005  else
2006  {
2007  sum_color += refractedColor * objTransparency;
2008  }
2009  }
2010 
2011  outColor = outColor * (1.0f - objTransparency) +
2012  (sum_color / SFVEC3F( (float)refractions_number_of_samples) );
2013  }
2014  }
2015  }
2016 
2017  //outColor += glm::max( -glm::dot( aHitInfo.m_HitNormal, aRay.m_Dir ), 0.0f ) *
2018  // objMaterial->GetAmbientColor();
2019 
2020  return outColor;
2021 }
float m_ShadowFactor
( 4) Shadow attenuation (1.0 no shadow, 0.0f darkness)
Definition: hitinfo.h:50
float GetTransparency() const
Definition: cmaterial.h:183
const LIST_LIGHT & GetList() const
GetList - get light list of this container.
Definition: clight.h:196
const SFVEC3F & GetAmbientColor() const
Definition: cmaterial.h:178
SFVEC3F shadeHit(const SFVEC3F &aBgColor, const RAY &aRay, HITINFO &aHitInfo, bool aIsInsideObject, unsigned int aRecursiveLevel, bool is_testShadow) const
A base material class that can be used to derive a material implementation.
Definition: cmaterial.h:167
void Init(const SFVEC3F &o, const SFVEC3F &d)
Definition: ray.cpp:40
virtual bool IntersectP(const RAY &aRay, float aMaxDistance) const =0
float GetAbsorvance() const
Definition: cmaterial.h:185
float GetNonCopperLayerThickness3DU() const
GetNonCopperLayerThickness3DU - Get the current non copper layers thickness.
Definition: cinfo3d_visu.h:159
SFVEC3F at(float t) const
Definition: ray.h:65
const CMATERIAL * GetMaterial() const
Definition: cobject.h:63
const SFVEC3F & GetSpecularColor() const
Definition: cmaterial.h:180
Definition: ray.h:43
CINFO3D_VISU & m_settings
settings refrence in use for this render
float m_tHit
( 4) distance
Definition: hitinfo.h:43
bool Refract(const SFVEC3F &aInVector, const SFVEC3F &aNormal, float aRin_over_Rout, SFVEC3F &aOutVector)
Refract Based on: https://github.com/mmp/pbrt-v3/blob/master/src/core/reflection.h See also: http://w...
Definition: 3d_math.h:113
virtual SFVEC3F Shade(const RAY &aRay, const HITINFO &aHitInfo, float NdotL, const SFVEC3F &aDiffuseObjColor, const SFVEC3F &aDirToLight, const SFVEC3F &aLightColor, float aShadowAttenuationFactor) const =0
Shade - Shades an intersection point.
SFVEC3F m_HitPoint
(12) hit position
Definition: hitinfo.h:49
CGENERICACCELERATOR * m_accelerator
unsigned int GetNrReflectionsSamples() const
Definition: cmaterial.h:187
virtual bool Intersect(const RAY &aRay, HITINFO &aHitInfo) const =0
unsigned int GetNrRefractionsSamples() const
Definition: cmaterial.h:186
const COBJECT * pHitObject
( 4) Object that was hitted
Definition: hitinfo.h:45
A base light class to derive to implement other light classes.
Definition: clight.h:37
SFVEC3F m_Dir
Definition: ray.h:48
SFVEC3F UniformRandomHemisphereDirection()
Definition: 3d_math.h:54
bool GetFlag(DISPLAY3D_FLG aFlag) const
GetFlag - get a configuration status of a flag.
bool GetCastShadows() const
Definition: clight.h:58
Stores the hit information of a ray with a point on the surface of a object.
Definition: hitinfo.h:40
#define max(a, b)
Definition: auxiliary.h:86
glm::vec3 SFVEC3F
Definition: xv3d_types.h:47
float NextFloatUp(float v)
Definition: 3d_fastmath.h:136
virtual void GetLightParameters(const SFVEC3F &aHitPoint, SFVEC3F &aOutVectorToLight, SFVEC3F &aOutLightColor, float &aOutDistance) const =0
GetLightParameters - Get parameters from this light.
SFVEC3F m_HitNormal
(12) normal at the hit point
Definition: hitinfo.h:42
std::list< CLIGHT * > LIST_LIGHT
Definition: clight.h:151
const SFVEC3F & GetEmissiveColor() const
Definition: cmaterial.h:179
virtual SFVEC3F GetDiffuseColor(const HITINFO &aHitInfo) const =0
float GetReflection() const
Definition: cmaterial.h:184
#define min(a, b)
Definition: auxiliary.h:85

Member Data Documentation

SFVEC3F C3D_RENDER_RAYTRACING::m_BgColorBot_LinearRGB
private

Definition at line 157 of file c3d_render_raytracing.h.

Referenced by render(), and rt_render_trace_block().

SFVEC3F C3D_RENDER_RAYTRACING::m_BgColorTop_LinearRGB
private

Definition at line 156 of file c3d_render_raytracing.h.

Referenced by render(), and rt_render_trace_block().

std::vector< SFVEC2UI > C3D_RENDER_RAYTRACING::m_blockPositions
private

this encodes the Morton code positions

Definition at line 165 of file c3d_render_raytracing.h.

Referenced by initialize_block_positions(), restart_render_state(), rt_render_trace_block(), and rt_render_tracing().

std::vector< SFVEC2UI > C3D_RENDER_RAYTRACING::m_blockPositionsFast
private

this encodes the Morton code positions (on fast preview mode)

Definition at line 171 of file c3d_render_raytracing.h.

Referenced by initialize_block_positions(), and render_preview().

std::vector< bool > C3D_RENDER_RAYTRACING::m_blockPositionsWasProcessed
private

this flags if a position was already processed (cleared each new render)

Definition at line 168 of file c3d_render_raytracing.h.

Referenced by restart_render_state(), and rt_render_tracing().

CBOARDNORMAL C3D_RENDER_RAYTRACING::m_board_normal_perturbator
private

Definition at line 111 of file c3d_render_raytracing.h.

Referenced by setupMaterials().

CMETALBRUSHEDNORMAL C3D_RENDER_RAYTRACING::m_brushed_metal_normal_perturbator
private

Definition at line 116 of file c3d_render_raytracing.h.

Referenced by add_3D_models(), and setupMaterials().

CDIRECTIONALLIGHT* C3D_RENDER_RAYTRACING::m_camera_light
private

Definition at line 140 of file c3d_render_raytracing.h.

Referenced by C3D_RENDER_RAYTRACING(), Redraw(), reload(), and render().

CCONTAINER2D C3D_RENDER_RAYTRACING::m_containerWithObjectsToDelete
private

This will store the list of created objects special for RT, that will be clear in the end.

Definition at line 150 of file c3d_render_raytracing.h.

Referenced by insert3DPadHole(), insert3DViaHole(), and reload().

CBLINN_PHONG_MATERIAL C3D_RENDER_RAYTRACING::m_Copper

Definition at line 107 of file c3d_render_raytracing.h.

CCOPPERNORMAL C3D_RENDER_RAYTRACING::m_copper_normal_perturbator
private

Definition at line 112 of file c3d_render_raytracing.h.

Referenced by setupMaterials().

CBLINN_PHONG_MATERIAL C3D_RENDER_RAYTRACING::m_EpoxyBoard

Definition at line 106 of file c3d_render_raytracing.h.

SFVEC2UI C3D_RENDER_RAYTRACING::m_fastPreviewModeSize
private

Definition at line 174 of file c3d_render_raytracing.h.

Referenced by initialize_block_positions().

HITINFO_PACKET* C3D_RENDER_RAYTRACING::m_firstHitinfo
private

Definition at line 176 of file c3d_render_raytracing.h.

Referenced by C3D_RENDER_RAYTRACING().

CBLINN_PHONG_MATERIAL C3D_RENDER_RAYTRACING::m_Floor

Definition at line 108 of file c3d_render_raytracing.h.

bool C3D_RENDER_BASE::m_is_opengl_initialized
protectedinherited

flag if the opengl specific for this render was already initialized

Definition at line 97 of file c3d_render_base.h.

Referenced by C3D_RENDER_BASE::C3D_RENDER_BASE(), initializeOpenGL(), C3D_RENDER_OGL_LEGACY::initializeOpenGL(), Redraw(), and C3D_RENDER_OGL_LEGACY::Redraw().

bool C3D_RENDER_RAYTRACING::m_isPreview
private
CLIGHTCONTAINER C3D_RENDER_RAYTRACING::m_lights
private

Definition at line 138 of file c3d_render_raytracing.h.

Referenced by reload(), and shadeHit().

const wxChar * C3D_RENDER_BASE::m_logTrace = wxT( "KI_TRACE_3D_RENDER" )
staticprotectedinherited

Trace mask used to enable or disable the trace output of this class.

The debug output can be turned on by setting the WXTRACE environment variable to "KI_TRACE_3D_RENDER". See the wxWidgets documentation on wxLogTrace for more information.

Definition at line 111 of file c3d_render_base.h.

Referenced by C3D_RENDER_BASE::C3D_RENDER_BASE(), C3D_RENDER_OGL_LEGACY::C3D_RENDER_OGL_LEGACY(), C3D_RENDER_RAYTRACING(), opengl_init_pbo(), C3D_RENDER_OGL_LEGACY::~C3D_RENDER_OGL_LEGACY(), and ~C3D_RENDER_RAYTRACING().

struct { ... } C3D_RENDER_RAYTRACING::m_materials
MAP_MODEL_MATERIALS C3D_RENDER_RAYTRACING::m_model_materials
private

Stores materials of the 3D models.

Definition at line 202 of file c3d_render_raytracing.h.

Referenced by add_3D_models(), and reload().

long C3D_RENDER_RAYTRACING::m_nrBlocksRenderProgress
private

Save the number of blocks progress of the render.

Definition at line 134 of file c3d_render_raytracing.h.

Referenced by C3D_RENDER_RAYTRACING(), restart_render_state(), and rt_render_tracing().

CCONTAINER C3D_RENDER_RAYTRACING::m_object_container
private

Definition at line 146 of file c3d_render_raytracing.h.

Referenced by add_3D_models(), insert3DPadHole(), insert3DViaHole(), and reload().

wxSize C3D_RENDER_RAYTRACING::m_oldWindowsSize
private

used to see if the windows size changed

Definition at line 162 of file c3d_render_raytracing.h.

Referenced by C3D_RENDER_RAYTRACING(), and Redraw().