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

3D viewer code cleaning round 1.

This commit is contained in:
Wayne Stambaugh 2020-12-11 08:51:42 -05:00
parent 7cb2d19814
commit d1fe4a0c98
31 changed files with 919 additions and 1086 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cbbox2d.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2017 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -93,11 +93,11 @@ void CBBOX2D::Reset()
void CBBOX2D::Union( const SFVEC2F &aPoint ) void CBBOX2D::Union( const SFVEC2F &aPoint )
{ {
// get the minimun value between the added point and the existent bounding box // get the minimum value between the added point and the existent bounding box
m_min.x = fminf( m_min.x, aPoint.x ); m_min.x = fminf( m_min.x, aPoint.x );
m_min.y = fminf( m_min.y, aPoint.y ); m_min.y = fminf( m_min.y, aPoint.y );
// get the maximun value between the added point and the existent bounding box // get the maximum value between the added point and the existent bounding box
m_max.x = fmaxf( m_max.x, aPoint.x ); m_max.x = fmaxf( m_max.x, aPoint.x );
m_max.y = fmaxf( m_max.y, aPoint.y ); m_max.y = fmaxf( m_max.y, aPoint.y );
} }
@ -105,12 +105,12 @@ void CBBOX2D::Union( const SFVEC2F &aPoint )
void CBBOX2D::Union( const CBBOX2D &aBBox ) void CBBOX2D::Union( const CBBOX2D &aBBox )
{ {
// get the minimun value between the added bounding box and // get the minimum value between the added bounding box and
// the existent bounding box // the existent bounding box
m_min.x = fminf( m_min.x, aBBox.m_min.x ); m_min.x = fminf( m_min.x, aBBox.m_min.x );
m_min.y = fminf( m_min.y, aBBox.m_min.y ); m_min.y = fminf( m_min.y, aBBox.m_min.y );
// get the maximun value between the added bounding box and // get the maximum value between the added bounding box and
// the existent bounding box // the existent bounding box
m_max.x = fmaxf( m_max.x, aBBox.m_max.x ); m_max.x = fmaxf( m_max.x, aBBox.m_max.x );
m_max.y = fmaxf( m_max.y, aBBox.m_max.y ); m_max.y = fmaxf( m_max.y, aBBox.m_max.y );

118
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cbbox2d.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -34,8 +34,7 @@
/** /**
* CBBOX * Manage a bounding box defined by two SFVEC2F min max points.
* manages a bounding box defined by two SFVEC2F min max points.
*/ */
struct CBBOX2D struct CBBOX2D
{ {
@ -43,23 +42,22 @@ struct CBBOX2D
public: public:
/** /**
* Constructor CBBOX2D * Create with default values a bounding box (not initialized).
* Create with default values a bounding box (not inizialized)
*/ */
CBBOX2D(); CBBOX2D();
/** /**
* Constructor CBBOX2D * Initialize a bounding box with a given point.
* Initialize a bounding box with a given point *
* @param aPbInit a point for the bounding box initialization * @param aPbInit a point for the bounding box initialization.
*/ */
explicit CBBOX2D( const SFVEC2F &aPbInit ); explicit CBBOX2D( const SFVEC2F &aPbInit );
/** /**
* Constructor CBBOX2D * Initialize a bounding box with a minimum and a maximum point.
* Initialize a bounding box with a minimon and a maximun point *
* @param aPbMin the minimun point to initialize the bounding box * @param aPbMin the minimum point to initialize the bounding box.
* @param aPbMax the maximun point to initialize the bounding box * @param aPbMax the maximum point to initialize the bounding box.
*/ */
CBBOX2D( const SFVEC2F &aPbMin, const SFVEC2F &aPbMax ); CBBOX2D( const SFVEC2F &aPbMin, const SFVEC2F &aPbMax );
@ -67,138 +65,130 @@ public:
/** /**
* Function Set * Set bounding box with new parameters.
* Set bounding box with new parameters *
* @param aPbMin the minimun point to initialize the bounding box * @param aPbMin the minimum point to initialize the bounding box.
* @param aPbMax the maximun point to initialize the bounding box * @param aPbMax the maximum point to initialize the bounding box.
*/ */
void Set( const SFVEC2F &aPbMin, const SFVEC2F &aPbMax ); void Set( const SFVEC2F &aPbMin, const SFVEC2F &aPbMax );
/** /**
* Function Set * Set bounding box based on another bounding box.
* Set bounding box based on another bounding box *
* @param CBBOX2D a bounding box to initialize this one * @param CBBOX2D a bounding box to initialize this one.
*/ */
void Set( const CBBOX2D &aBBox ); void Set( const CBBOX2D &aBBox );
/** /**
* Function Union * Recalculate the bounding box adding a point.
* recalculate the bounding box adding a point *
* @param aPoint the point to be bounded * @param aPoint the point to be bounded
*/ */
void Union( const SFVEC2F &aPoint ); void Union( const SFVEC2F &aPoint );
/** /**
* Function Union * Recalculate the bounding box adding other bounding box.
* recalculate the bounding box adding other bounding box *
* @param aBBox the bounding box to be bounded * @param aBBox the bounding box to be bounded.
*/ */
void Union( const CBBOX2D &aBBox ); void Union( const CBBOX2D &aBBox );
/** /**
* Function Scale * Scale a bounding box by its center.
* scales a bounding box by its center *
* @param aScale scale factor to apply * @param aScale scale factor to apply
*/ */
void Scale( float aScale ); void Scale( float aScale );
/** /**
* Function ScaleNextUp * Scale a bounding box to the next float representation making it larger.
* scales a bounding box to the next float representation making it larger
*/ */
void ScaleNextUp(); void ScaleNextUp();
/** /**
* Function ScaleNextDown * Scale a bounding box to the next float representation making it smaller.
* scales a bounding box to the next float representation making it smaller
*/ */
void ScaleNextDown(); void ScaleNextDown();
/** /**
* Function Intersects * Test if a bounding box intersects this box.
* test if a bounding box intersects this box *
* @param aBBox the bounding box to check if it inversects * @param aBBox the bounding box to check if it intersects.
*/ */
bool Intersects( const CBBOX2D &aBBox ) const; bool Intersects( const CBBOX2D &aBBox ) const;
/** /**
* Function Intersects * Test if a circle intersects this box.
* test if a circle intersects this box *
* @param aBBox the bounding box to check if it intersects * @param aBBox the bounding box to check if it intersects.
*/ */
bool Intersects( const SFVEC2F &aCenter, float aRadiusSquared ) const; bool Intersects( const SFVEC2F &aCenter, float aRadiusSquared ) const;
/** /**
* Function Inside * Check is a point is inside this bounding box.
* check is a point is inside this bounding box *
* @param aPoint point to test * @param aPoint point to test.
*/ */
bool Inside( const SFVEC2F &aPoint ) const; bool Inside( const SFVEC2F &aPoint ) const;
/** /**
* Function Area * Calculate the area of a bounding box.
* calculate the area of a bounding box *
* @return float - area of this bounding box * @return area of this bounding box.
*/ */
float Area() const; float Area() const;
/** /**
* Function IsInitialized * Check if this bounding box is already initialized.
* check if this bounding box is already initialized *
* @return bool - return true if it was initialized, false if otherwise * @return True if it was initialized, otherwise false.
*/ */
bool IsInitialized() const; bool IsInitialized() const;
/** /**
* Function Reset * Reset the bounding box to zero and uninitialize it.
* reset the bounding box to zero and de-initialized it
*/ */
void Reset(); void Reset();
/** /**
* Function GetCenter * Return the center point of the bounding box.
* return the center point of the bounding box *
* @return SFVEC2F - the position of the center of this bounding box * @return the position of the center of this bounding box.
*/ */
SFVEC2F GetCenter() const; SFVEC2F GetCenter() const;
/** /**
* Function GetExtent
* @return SFVEC2F - max-min * @return SFVEC2F - max-min
*/ */
SFVEC2F GetExtent() const; SFVEC2F GetExtent() const;
/** /**
* Function Min * Return the minimum vertex point.
* return the minimun vertex pointer *
* @return SFVEC2F - the minimun vertice position * @return the minimum vertex position.
*/ */
const SFVEC2F &Min() const { return m_min; } const SFVEC2F &Min() const { return m_min; }
/** /**
* Function Max * Return the maximum vertex point.
* return the maximum vertex pointer * @return the maximum vertex position.
* @return SFVEC2F - the maximun vertice position
*/ */
const SFVEC2F &Max() const { return m_max; } const SFVEC2F &Max() const { return m_max; }
/** /**
* Function MaxDimension * @return the index of the max dimension (0=x, 1=y)
* @return the index of the max dimention (0=x, 1=y)
*/ */
unsigned int MaxDimension() const; unsigned int MaxDimension() const;
/** /**
* Function Perimeter * @return the surface area of the box
* @return the surface are of the box
*/ */
float Perimeter() const; float Perimeter() const;
/** /**
* Function Intersect * @param aRay ray to intersect the box
* @param aRay = ray to intersect the box * @param t distance point of the ray of the intersection (if true)
* @param t = distance point of the ray of the intersection (if true)
* @return true if the ray hits the box * @return true if the ray hits the box
*/ */
bool Intersect( const RAY2D &aRay, float *t ) const; bool Intersect( const RAY2D &aRay, float *t ) const;

17
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cfilledcircle2d.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -35,24 +35,23 @@
class CFILLEDCIRCLE2D : public COBJECT2D class CFILLEDCIRCLE2D : public COBJECT2D
{ {
public: public:
CFILLEDCIRCLE2D( const SFVEC2F &aCenter, float aRadius, const BOARD_ITEM &aBoardItem );
float GetRadius() const { return m_radius; } float GetRadius() const { return m_radius; }
const SFVEC2F &GetCenter() const { return m_center; } const SFVEC2F &GetCenter() const { return m_center; }
float GetRadiusSquared() const { return m_radius_squared; } float GetRadiusSquared() const { return m_radius_squared; }
private:
SFVEC2F m_center;
float m_radius;
float m_radius_squared;
public:
CFILLEDCIRCLE2D( const SFVEC2F &aCenter, float aRadius, const BOARD_ITEM &aBoardItem );
// Imported from COBJECT2D // Imported from COBJECT2D
bool Overlaps( const CBBOX2D &aBBox ) const override; bool Overlaps( const CBBOX2D &aBBox ) const override;
bool Intersects( const CBBOX2D &aBBox ) const override; bool Intersects( const CBBOX2D &aBBox ) const override;
bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override; bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override;
INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override; INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override;
bool IsPointInside( const SFVEC2F &aPoint ) const override; bool IsPointInside( const SFVEC2F &aPoint ) const override;
private:
SFVEC2F m_center;
float m_radius;
float m_radius_squared;
}; };

64
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/citemlayercsg2d.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -31,13 +31,15 @@
#include "3d_fastmath.h" #include "3d_fastmath.h"
#include <wx/debug.h> #include <wx/debug.h>
CITEMLAYERCSG2D::CITEMLAYERCSG2D( const COBJECT2D* aObjectA, CITEMLAYERCSG2D::CITEMLAYERCSG2D( const COBJECT2D* aObjectA,
std::vector<const COBJECT2D*>* aObjectB, const COBJECT2D* aObjectC, std::vector<const COBJECT2D*>* aObjectB,
const BOARD_ITEM& aBoardItem ) const COBJECT2D* aObjectC,
: COBJECT2D( OBJECT2D_TYPE::CSG, aBoardItem ), const BOARD_ITEM& aBoardItem ) :
m_objectA( aObjectA ), COBJECT2D( OBJECT2D_TYPE::CSG, aBoardItem ),
m_objectB( aObjectB ), m_objectA( aObjectA ),
m_objectC( aObjectC ) m_objectB( aObjectB ),
m_objectC( aObjectC )
{ {
wxASSERT( aObjectA ); wxASSERT( aObjectA );
@ -52,8 +54,7 @@ CITEMLAYERCSG2D::CITEMLAYERCSG2D( const COBJECT2D* aObjectA,
CITEMLAYERCSG2D::~CITEMLAYERCSG2D() CITEMLAYERCSG2D::~CITEMLAYERCSG2D()
{ {
if( ((void*)m_objectB != CSGITEM_EMPTY) && if( ( (void*) m_objectB != CSGITEM_EMPTY ) && ( (void*) m_objectB != CSGITEM_FULL ) )
((void*)m_objectB != CSGITEM_FULL) )
{ {
delete m_objectB; delete m_objectB;
m_objectB = NULL; m_objectB = NULL;
@ -61,31 +62,30 @@ CITEMLAYERCSG2D::~CITEMLAYERCSG2D()
} }
bool CITEMLAYERCSG2D::Intersects( const CBBOX2D &aBBox ) const bool CITEMLAYERCSG2D::Intersects( const CBBOX2D& aBBox ) const
{ {
return m_bbox.Intersects( aBBox ); return m_bbox.Intersects( aBBox );
// !TODO: improove this implementation // !TODO: improve this implementation
//return false; //return false;
} }
bool CITEMLAYERCSG2D::Overlaps( const CBBOX2D &aBBox ) const bool CITEMLAYERCSG2D::Overlaps( const CBBOX2D& aBBox ) const
{ {
// NOT IMPLEMENTED // NOT IMPLEMENTED
return false; return false;
} }
// Based on ideas and implementation by Nick Chapman // Based on ideas and implementation by Nick Chapman
// http://homepages.paradise.net.nz/nickamy/raytracer/raytracer.htm // http://homepages.paradise.net.nz/nickamy/raytracer/raytracer.htm
bool CITEMLAYERCSG2D::Intersect( const RAYSEG2D &aSegRay, bool CITEMLAYERCSG2D::Intersect( const RAYSEG2D& aSegRay, float* aOutT, SFVEC2F* aNormalOut ) const
float *aOutT,
SFVEC2F *aNormalOut ) const
{ {
if( m_objectA->GetObjectType() == OBJECT2D_TYPE::DUMMYBLOCK ) if( m_objectA->GetObjectType() == OBJECT2D_TYPE::DUMMYBLOCK )
return false; return false;
SFVEC2F currentRayPos = aSegRay.m_Start; SFVEC2F currentRayPos = aSegRay.m_Start;
SFVEC2F currentNormal; SFVEC2F currentNormal;
RAYSEG2D currentRay = aSegRay; RAYSEG2D currentRay = aSegRay;
if( !m_objectA->IsPointInside( aSegRay.m_Start ) ) if( !m_objectA->IsPointInside( aSegRay.m_Start ) )
@ -102,7 +102,6 @@ bool CITEMLAYERCSG2D::Intersect( const RAYSEG2D &aSegRay,
//wxASSERT( (currentRayDist >= 0.0f) && (currentRayDist <= 1.0f) ); //wxASSERT( (currentRayDist >= 0.0f) && (currentRayDist <= 1.0f) );
// move through the union of subtracted regions // move through the union of subtracted regions
if( m_objectB ) if( m_objectB )
{ {
@ -113,15 +112,14 @@ bool CITEMLAYERCSG2D::Intersect( const RAYSEG2D &aSegRay,
//check against all subbed objects //check against all subbed objects
for( unsigned int i = 0; i < m_objectB->size(); ++i ) for( unsigned int i = 0; i < m_objectB->size(); ++i )
{ {
if( ( (const COBJECT2D *)( *m_objectB)[i] )->IsPointInside( currentRayPos ) ) if( ( (const COBJECT2D*) ( *m_objectB )[i] )->IsPointInside( currentRayPos ) )
{ {
// ray point is inside a subtracted region, so move it to the end of the // ray point is inside a subtracted region, so move it to the end of the
// subtracted region // subtracted region
float hitDist; float hitDist;
SFVEC2F tmpNormal; SFVEC2F tmpNormal;
if( !( (const COBJECT2D *)( *m_objectB)[i] )->Intersect( currentRay, if( !( (const COBJECT2D*) ( *m_objectB )[i] )
&hitDist, ->Intersect( currentRay, &hitDist, &tmpNormal ) )
&tmpNormal ) )
return false; // ray hit main object but did not leave subtracted volume return false; // ray hit main object but did not leave subtracted volume
wxASSERT( hitDist <= 1.0f ); wxASSERT( hitDist <= 1.0f );
@ -130,7 +128,8 @@ bool CITEMLAYERCSG2D::Intersect( const RAYSEG2D &aSegRay,
{ {
wasCrossedSubVol = true; wasCrossedSubVol = true;
currentRayPos = currentRay.atNormalized( glm::min( hitDist + 0.0001f, 1.0f ) ); currentRayPos =
currentRay.atNormalized( glm::min( hitDist + 0.0001f, 1.0f ) );
currentRay = RAYSEG2D( currentRayPos, aSegRay.m_End ); currentRay = RAYSEG2D( currentRayPos, aSegRay.m_End );
@ -148,13 +147,15 @@ bool CITEMLAYERCSG2D::Intersect( const RAYSEG2D &aSegRay,
*aNormalOut = currentNormal; *aNormalOut = currentNormal;
if( aOutT ) if( aOutT )
*aOutT = glm::min( glm::max( glm::length( currentRayPos - aSegRay.m_Start ) / aSegRay.m_Length, 0.0f ), 1.0f ); *aOutT = glm::min(
glm::max( glm::length( currentRayPos - aSegRay.m_Start ) / aSegRay.m_Length, 0.0f ),
1.0f );
return true; return true;
} }
INTERSECTION_RESULT CITEMLAYERCSG2D::IsBBoxInside( const CBBOX2D &aBBox ) const INTERSECTION_RESULT CITEMLAYERCSG2D::IsBBoxInside( const CBBOX2D& aBBox ) const
{ {
// !TODO: // !TODO:
@ -163,19 +164,20 @@ INTERSECTION_RESULT CITEMLAYERCSG2D::IsBBoxInside( const CBBOX2D &aBBox ) const
} }
bool CITEMLAYERCSG2D::IsPointInside( const SFVEC2F &aPoint ) const bool CITEMLAYERCSG2D::IsPointInside( const SFVEC2F& aPoint ) const
{ {
// Perform the operation (A - B) /\ C // Perform the operation (A - B) /\ C
if( m_objectA->IsPointInside( aPoint ) ) if( m_objectA->IsPointInside( aPoint ) )
{ {
if( m_objectB != CSGITEM_EMPTY) if( m_objectB != CSGITEM_EMPTY )
for( unsigned int i = 0; i< m_objectB->size(); i++ ) {
for( unsigned int i = 0; i < m_objectB->size(); i++ )
{ {
if( (*m_objectB)[i]->IsPointInside( aPoint ) ) if( ( *m_objectB )[i]->IsPointInside( aPoint ) )
return false; return false;
} }
}
// !TODO: not yet implemented // !TODO: not yet implemented
//if( m_objectC && m_objectC != CSGITEM_FULL ) //if( m_objectC && m_objectC != CSGITEM_FULL )

25
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/citemlayercsg2d.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -33,9 +33,13 @@
#include "cobject2d.h" #include "cobject2d.h"
#include <vector> #include <vector>
#define CSGITEM_EMPTY 0
#define CSGITEM_FULL (COBJECT2D *)((size_t)(-1))
/** /**
* This class is used to make constructive solig geometry for items * Make constructive solid geometry for items objects on layers.
* objects on layers. *
* The operation is in the form (A - B) /\ C * The operation is in the form (A - B) /\ C
* For almost all of the layers it translate something like: * For almost all of the layers it translate something like:
* A (a via, a track, pad, polygon), B (a via hole, a THT hole, .. ), * A (a via, a track, pad, polygon), B (a via hole, a THT hole, .. ),
@ -71,17 +75,8 @@
* Layers.Paste = P - 0 /\ BODY * Layers.Paste = P - 0 /\ BODY
* Layers.Silk = S - 0 /\ BODY * Layers.Silk = S - 0 /\ BODY
*/ */
#define CSGITEM_EMPTY 0
#define CSGITEM_FULL (COBJECT2D *)((size_t)(-1))
class CITEMLAYERCSG2D : public COBJECT2D class CITEMLAYERCSG2D : public COBJECT2D
{ {
private:
const COBJECT2D *m_objectA;
std::vector<const COBJECT2D *> *m_objectB;
const COBJECT2D *m_objectC;
public: public:
CITEMLAYERCSG2D( const COBJECT2D *aObjectA, CITEMLAYERCSG2D( const COBJECT2D *aObjectA,
std::vector<const COBJECT2D *> *aObjectB, std::vector<const COBJECT2D *> *aObjectB,
@ -96,7 +91,11 @@ public:
bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override; bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override;
INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override; INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override;
bool IsPointInside( const SFVEC2F &aPoint ) const override; bool IsPointInside( const SFVEC2F &aPoint ) const override;
private:
const COBJECT2D *m_objectA;
std::vector<const COBJECT2D *> *m_objectB;
const COBJECT2D *m_objectC;
}; };
#endif // _CITEMLAYERCSG2D_H_ #endif // _CITEMLAYERCSG2D_H_

2
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cobject2d.cpp
View File

@ -67,6 +67,6 @@ void COBJECT2D_STATS::PrintStats()
for( auto& objectType : objectTypeNames ) for( auto& objectType : objectTypeNames )
{ {
wxLogDebug( " %20s %u\n", objectType.second, wxLogDebug( " %20s %u\n", objectType.second,
m_counter[static_cast<int>( objectType.first )] ); m_counter[static_cast<int>( objectType.first )] );
} }
} }

47
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cobject2d.h
View File

@ -61,57 +61,44 @@ enum class OBJECT2D_TYPE
class COBJECT2D class COBJECT2D
{ {
protected:
CBBOX2D m_bbox;
SFVEC2F m_centroid;
OBJECT2D_TYPE m_obj_type;
const BOARD_ITEM &m_boardItem;
public: public:
COBJECT2D( OBJECT2D_TYPE aObjType, const BOARD_ITEM &aBoardItem ); COBJECT2D( OBJECT2D_TYPE aObjType, const BOARD_ITEM &aBoardItem );
virtual ~COBJECT2D() {} virtual ~COBJECT2D() {}
const BOARD_ITEM &GetBoardItem() const { return m_boardItem; } const BOARD_ITEM &GetBoardItem() const { return m_boardItem; }
/** Function Overlaps /**
* @brief Test if the box overlaps the object * Test if the box overlaps the object.
*
* Conformance * Conformance
* The function overlaps implements function Overlaps from the OGC * Implements the Overlaps function from the OGC Simple Feature Specification at
* Simple Feature Specification. * http://www.opengeospatial.org/standards/sfa.
* http://www.opengeospatial.org/standards/sfa
* a.Overlaps(b) ⇔ ( dim(I(a)) = dim(I(b)) = dim(I(a) ∩ I(b))) ∧ (a ∩ b ≠ a) ∧ (a ∩ b ≠ b) * a.Overlaps(b) ⇔ ( dim(I(a)) = dim(I(b)) = dim(I(a) ∩ I(b))) ∧ (a ∩ b ≠ a) ∧ (a ∩ b ≠ b)
* It means that the result dimension of an overlap is the same dimentions * It means that the result dimension of an overlap is the same dimensions
* of the bounding box (so the overlap cannot be a point or a line) and one * of the bounding box (so the overlap cannot be a point or a line) and one
* of the boxes cannot full contain the other box. * of the boxes cannot full contain the other box.
*
* @param aBBox - The bounding box to test * @param aBBox - The bounding box to test
* @return true if the BBox intersects the object or is inside it * @return true if the BBox intersects the object or is inside it
*/ */
virtual bool Overlaps( const CBBOX2D &aBBox ) const = 0; virtual bool Overlaps( const CBBOX2D &aBBox ) const = 0;
/** Function Intersects /**
* @brief Intersects - a.Intersects(b) ⇔ !a.Disjoint(b) ⇔ !(a ∩ b = ∅) * a.Intersects(b) ⇔ !a.Disjoint(b) ⇔ !(a ∩ b = ∅)
* It intersects if the result intersection is not null
* @param aBBox
* @return
*/ */
virtual bool Intersects( const CBBOX2D &aBBox ) const = 0; virtual bool Intersects( const CBBOX2D &aBBox ) const = 0;
/** Function Intersect /**
* @brief Intersect
* @param aSegRay
* @param aOutT a value between 0.0 and 1.0 in relation to the time of the * @param aOutT a value between 0.0 and 1.0 in relation to the time of the
* hit of the segment * hit of the segment
* @param aNormalOut
* @return
*/ */
virtual bool Intersect( const RAYSEG2D &aSegRay, virtual bool Intersect( const RAYSEG2D &aSegRay,
float *aOutT, float *aOutT,
SFVEC2F *aNormalOut ) const = 0; SFVEC2F *aNormalOut ) const = 0;
/** /**
* Function IsBBoxInside * Test this object if it's completely outside, intersects, or is completely inside \a aBBox.
* @brief Tests if the bounding is out, intersects or is complety inside *
* @return INTERSECTION_RESULT * @return INTERSECTION_RESULT
*/ */
virtual INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const = 0; virtual INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const = 0;
@ -123,12 +110,17 @@ public:
const SFVEC2F &GetCentroid() const { return m_centroid; } const SFVEC2F &GetCentroid() const { return m_centroid; }
OBJECT2D_TYPE GetObjectType() const { return m_obj_type; } OBJECT2D_TYPE GetObjectType() const { return m_obj_type; }
protected:
CBBOX2D m_bbox;
SFVEC2F m_centroid;
OBJECT2D_TYPE m_obj_type;
const BOARD_ITEM &m_boardItem;
}; };
/// Implements a class for object statistics
/// using Singleton pattern
class COBJECT2D_STATS class COBJECT2D_STATS
{ {
public: public:
@ -163,7 +155,6 @@ private:
const COBJECT2D_STATS &operator=( const COBJECT2D_STATS &old ); const COBJECT2D_STATS &operator=( const COBJECT2D_STATS &old );
~COBJECT2D_STATS(){} ~COBJECT2D_STATS(){}
private:
unsigned int m_counter[static_cast<int>( OBJECT2D_TYPE::MAX )]; unsigned int m_counter[static_cast<int>( OBJECT2D_TYPE::MAX )];
static COBJECT2D_STATS *s_instance; static COBJECT2D_STATS *s_instance;

325
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cpolygon2d.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2018 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -34,34 +34,30 @@
#include <stdio.h> #include <stdio.h>
#endif #endif
// CPOLYGONBLOCK2D
// /////////////////////////////////////////////////////////////////////////////
static bool polygon_IsPointInside( const SEGMENTS &aSegments, const SFVEC2F &aPoint ) static bool polygon_IsPointInside( const SEGMENTS& aSegments, const SFVEC2F& aPoint )
{ {
wxASSERT( aSegments.size() >= 3 ); wxASSERT( aSegments.size() >= 3 );
unsigned int i; unsigned int i;
unsigned int j = aSegments.size() - 1; unsigned int j = aSegments.size() - 1;
bool oddNodes = false; bool oddNodes = false;
for( i = 0; i < aSegments.size(); j = i++ ) for( i = 0; i < aSegments.size(); j = i++ )
{ {
const float polyJY = aSegments[j].m_Start.y; const float polyJY = aSegments[j].m_Start.y;
const float polyIY = aSegments[i].m_Start.y; const float polyIY = aSegments[i].m_Start.y;
if( ((polyIY <= aPoint.y) && (polyJY >= aPoint.y)) || if( ( ( polyIY <= aPoint.y ) && ( polyJY >= aPoint.y ) )
((polyJY <= aPoint.y) && (polyIY >= aPoint.y)) || ( ( polyJY <= aPoint.y ) && ( polyIY >= aPoint.y ) ) )
)
{ {
const float polyJX = aSegments[j].m_Start.x; const float polyJX = aSegments[j].m_Start.x;
const float polyIX = aSegments[i].m_Start.x; const float polyIX = aSegments[i].m_Start.x;
if( (polyIX <= aPoint.x) || (polyJX <= aPoint.x) ) if( ( polyIX <= aPoint.x ) || ( polyJX <= aPoint.x ) )
oddNodes ^= ( ( polyIX + oddNodes ^= ( ( polyIX + ( ( aPoint.y - polyIY ) * aSegments[i].m_inv_JY_minus_IY )
( ( aPoint.y - polyIY ) * * aSegments[i].m_JX_minus_IX )
aSegments[i].m_inv_JY_minus_IY ) * < aPoint.x );
aSegments[i].m_JX_minus_IX ) < aPoint.x );
} }
} }
@ -87,29 +83,28 @@ CPOLYGONBLOCK2D::CPOLYGONBLOCK2D( const SEGMENTS_WIDTH_NORMALS& aOpenSegmentList
for( unsigned int i = 0; i < m_outers_and_holes.m_Outers.size(); i++ ) for( unsigned int i = 0; i < m_outers_and_holes.m_Outers.size(); i++ )
{ {
for( unsigned int j = 0; j < m_outers_and_holes.m_Outers[i].size(); j++ ) for( unsigned int j = 0; j < m_outers_and_holes.m_Outers[i].size(); j++ )
m_bbox.Union( ((SEGMENTS)m_outers_and_holes.m_Outers[i])[j].m_Start ); m_bbox.Union( ( (SEGMENTS) m_outers_and_holes.m_Outers[i] )[j].m_Start );
} }
m_bbox.ScaleNextUp(); m_bbox.ScaleNextUp();
m_centroid = m_bbox.GetCenter(); m_centroid = m_bbox.GetCenter();
// Some checks // Some checks
wxASSERT( m_open_segments.size() == aOpenSegmentList.size() ); wxASSERT( m_open_segments.size() == aOpenSegmentList.size() );
wxASSERT( m_open_segments.size() > 0 ); wxASSERT( m_open_segments.size() > 0 );
wxASSERT( m_outers_and_holes.m_Outers.size() > 0 ); wxASSERT( m_outers_and_holes.m_Outers.size() > 0 );
wxASSERT( m_outers_and_holes.m_Outers.size() == aOuter_and_holes.m_Outers.size() ); wxASSERT( m_outers_and_holes.m_Outers.size() == aOuter_and_holes.m_Outers.size() );
wxASSERT( m_outers_and_holes.m_Holes.size() == aOuter_and_holes.m_Holes.size() ); wxASSERT( m_outers_and_holes.m_Holes.size() == aOuter_and_holes.m_Holes.size() );
wxASSERT( m_outers_and_holes.m_Outers[0].size() >= 3 ); wxASSERT( m_outers_and_holes.m_Outers[0].size() >= 3 );
wxASSERT( m_outers_and_holes.m_Outers[0].size() == wxASSERT( m_outers_and_holes.m_Outers[0].size() == aOuter_and_holes.m_Outers[0].size() );
aOuter_and_holes.m_Outers[0].size() );
wxASSERT( m_bbox.IsInitialized() ); wxASSERT( m_bbox.IsInitialized() );
} }
bool CPOLYGONBLOCK2D::Intersects( const CBBOX2D &aBBox ) const bool CPOLYGONBLOCK2D::Intersects( const CBBOX2D& aBBox ) const
{ {
return m_bbox.Intersects( aBBox ); return m_bbox.Intersects( aBBox );
@ -119,67 +114,64 @@ bool CPOLYGONBLOCK2D::Intersects( const CBBOX2D &aBBox ) const
} }
bool CPOLYGONBLOCK2D::Overlaps( const CBBOX2D &aBBox ) const bool CPOLYGONBLOCK2D::Overlaps( const CBBOX2D& aBBox ) const
{ {
// NOT IMPLEMENTED // NOT IMPLEMENTED
return false; return false;
} }
bool CPOLYGONBLOCK2D::Intersect( const RAYSEG2D &aSegRay, bool CPOLYGONBLOCK2D::Intersect( const RAYSEG2D& aSegRay, float* aOutT, SFVEC2F* aNormalOut ) const
float *aOutT,
SFVEC2F *aNormalOut ) const
{ {
int hitIndex = -1; int hitIndex = -1;
float hitU = 0.0f; float hitU = 0.0f;
float tMin = 0.0f; float tMin = 0.0f;
for( unsigned int i = 0; i < m_open_segments.size(); i++ ) for( unsigned int i = 0; i < m_open_segments.size(); i++ )
{ {
const SFVEC2F &s = m_open_segments[i].m_Precalc_slope; const SFVEC2F& s = m_open_segments[i].m_Precalc_slope;
const SFVEC2F &q = m_open_segments[i].m_Start; const SFVEC2F& q = m_open_segments[i].m_Start;
float rxs = aSegRay.m_End_minus_start.x * s.y - float rxs = aSegRay.m_End_minus_start.x * s.y - aSegRay.m_End_minus_start.y * s.x;
aSegRay.m_End_minus_start.y * s.x;
if( fabs(rxs) > FLT_EPSILON ) if( fabs( rxs ) > FLT_EPSILON )
{ {
const float inv_rxs = 1.0f / rxs; const float inv_rxs = 1.0f / rxs;
const SFVEC2F pq = q - aSegRay.m_Start; const SFVEC2F pq = q - aSegRay.m_Start;
const float t = (pq.x * s.y - pq.y * s.x) * inv_rxs; const float t = ( pq.x * s.y - pq.y * s.x ) * inv_rxs;
if( (t < 0.0f) || (t > 1.0f) ) if( ( t < 0.0f ) || ( t > 1.0f ) )
continue; continue;
const float u = ( pq.x * aSegRay.m_End_minus_start.y - const float u =
pq.y * aSegRay.m_End_minus_start.x ) * inv_rxs; ( pq.x * aSegRay.m_End_minus_start.y - pq.y * aSegRay.m_End_minus_start.x )
* inv_rxs;
if( (u < 0.0f) || (u > 1.0f) ) if( ( u < 0.0f ) || ( u > 1.0f ) )
continue; continue;
if( ( hitIndex == -1 ) || ( t <= tMin ) ) if( ( hitIndex == -1 ) || ( t <= tMin ) )
{ {
tMin = t; tMin = t;
hitIndex = i; hitIndex = i;
hitU = u; hitU = u;
} }
} }
} }
if( hitIndex >= 0 ) if( hitIndex >= 0 )
{ {
wxASSERT( (tMin >= 0.0f) && (tMin <= 1.0f) ); wxASSERT( ( tMin >= 0.0f ) && ( tMin <= 1.0f ) );
if( aOutT ) if( aOutT )
*aOutT = tMin; *aOutT = tMin;
if( aNormalOut ) if( aNormalOut )
*aNormalOut = glm::normalize( *aNormalOut = glm::normalize( m_open_segments[hitIndex].m_Normals.m_Start * hitU +
m_open_segments[hitIndex].m_Normals.m_Start * hitU + m_open_segments[hitIndex].m_Normals.m_End *
m_open_segments[hitIndex].m_Normals.m_End * ( 1.0f - hitU ) );
(1.0f - hitU) );
return true; return true;
} }
@ -188,14 +180,14 @@ bool CPOLYGONBLOCK2D::Intersect( const RAYSEG2D &aSegRay,
} }
INTERSECTION_RESULT CPOLYGONBLOCK2D::IsBBoxInside( const CBBOX2D &aBBox ) const INTERSECTION_RESULT CPOLYGONBLOCK2D::IsBBoxInside( const CBBOX2D& aBBox ) const
{ {
return INTERSECTION_RESULT::MISSES; return INTERSECTION_RESULT::MISSES;
} }
bool CPOLYGONBLOCK2D::IsPointInside( const SFVEC2F &aPoint ) const bool CPOLYGONBLOCK2D::IsPointInside( const SFVEC2F& aPoint ) const
{ {
// NOTE: we could add here a test for the bounding box, but because in the // NOTE: we could add here a test for the bounding box, but because in the
// 3d object it already checked for a 3d bbox. // 3d object it already checked for a 3d bbox.
@ -219,11 +211,8 @@ bool CPOLYGONBLOCK2D::IsPointInside( const SFVEC2F &aPoint ) const
} }
// CDUMMYBLOCK2D CDUMMYBLOCK2D::CDUMMYBLOCK2D( const SFVEC2F& aPbMin, const SFVEC2F& aPbMax,
// ///////////////////////////////////////////////////////////////////////////// const BOARD_ITEM& aBoardItem )
CDUMMYBLOCK2D::CDUMMYBLOCK2D(
const SFVEC2F& aPbMin, const SFVEC2F& aPbMax, const BOARD_ITEM& aBoardItem )
: COBJECT2D( OBJECT2D_TYPE::DUMMYBLOCK, aBoardItem ) : COBJECT2D( OBJECT2D_TYPE::DUMMYBLOCK, aBoardItem )
{ {
m_bbox.Set( aPbMin, aPbMax ); m_bbox.Set( aPbMin, aPbMax );
@ -241,22 +230,20 @@ CDUMMYBLOCK2D::CDUMMYBLOCK2D( const CBBOX2D& aBBox, const BOARD_ITEM& aBoardItem
} }
bool CDUMMYBLOCK2D::Intersects( const CBBOX2D &aBBox ) const bool CDUMMYBLOCK2D::Intersects( const CBBOX2D& aBBox ) const
{ {
return m_bbox.Intersects( aBBox ); return m_bbox.Intersects( aBBox );
} }
bool CDUMMYBLOCK2D::Overlaps( const CBBOX2D &aBBox ) const bool CDUMMYBLOCK2D::Overlaps( const CBBOX2D& aBBox ) const
{ {
// Not implemented // Not implemented
return false; return false;
} }
bool CDUMMYBLOCK2D::Intersect( const RAYSEG2D &aSegRay, bool CDUMMYBLOCK2D::Intersect( const RAYSEG2D& aSegRay, float* aOutT, SFVEC2F* aNormalOut ) const
float *aOutT,
SFVEC2F *aNormalOut ) const
{ {
// The dummy block will be never intersected because it have no edges, // The dummy block will be never intersected because it have no edges,
// only it have a plan surface of the size of the bounding box // only it have a plan surface of the size of the bounding box
@ -264,14 +251,14 @@ bool CDUMMYBLOCK2D::Intersect( const RAYSEG2D &aSegRay,
} }
INTERSECTION_RESULT CDUMMYBLOCK2D::IsBBoxInside( const CBBOX2D &aBBox ) const INTERSECTION_RESULT CDUMMYBLOCK2D::IsBBoxInside( const CBBOX2D& aBBox ) const
{ {
//!TODO: //!TODO:
return INTERSECTION_RESULT::MISSES; return INTERSECTION_RESULT::MISSES;
} }
bool CDUMMYBLOCK2D::IsPointInside( const SFVEC2F &aPoint ) const bool CDUMMYBLOCK2D::IsPointInside( const SFVEC2F& aPoint ) const
{ {
// The dummy is filled in all his bounding box, so if it hit the bbox // The dummy is filled in all his bounding box, so if it hit the bbox
// it will hit this dummy // it will hit this dummy
@ -282,17 +269,13 @@ bool CDUMMYBLOCK2D::IsPointInside( const SFVEC2F &aPoint ) const
} }
// Polygon process and conversion
// ////////////////////////////////////////////////////////////////////////////
typedef std::vector<SFVEC2F> KF_POINTS; typedef std::vector<SFVEC2F> KF_POINTS;
#define MAX_NR_DIVISIONS 96 #define MAX_NR_DIVISIONS 96
static bool intersect( const SEGMENT_WITH_NORMALS &aSeg, static bool intersect( const SEGMENT_WITH_NORMALS& aSeg, const SFVEC2F& aStart,
const SFVEC2F &aStart, const SFVEC2F& aEnd )
const SFVEC2F &aEnd )
{ {
const SFVEC2F r = aEnd - aStart; const SFVEC2F r = aEnd - aStart;
const SFVEC2F s = aSeg.m_Precalc_slope; const SFVEC2F s = aSeg.m_Precalc_slope;
@ -300,20 +283,20 @@ static bool intersect( const SEGMENT_WITH_NORMALS &aSeg,
const float rxs = r.x * s.y - r.y * s.x; const float rxs = r.x * s.y - r.y * s.x;
if( fabs(rxs) > glm::epsilon<float>() ) if( fabs( rxs ) > glm::epsilon<float>() )
{ {
const float inv_rxs = 1.0f / rxs; const float inv_rxs = 1.0f / rxs;
const SFVEC2F pq = q - aStart; const SFVEC2F pq = q - aStart;
const float t = (pq.x * s.y - pq.y * s.x) * inv_rxs; const float t = ( pq.x * s.y - pq.y * s.x ) * inv_rxs;
if( (t < 0.0f) || (t > 1.0f) ) if( ( t < 0.0f ) || ( t > 1.0f ) )
return false; return false;
const float u = (pq.x * r.y - pq.y * r.x) * inv_rxs; const float u = ( pq.x * r.y - pq.y * r.x ) * inv_rxs;
if( (u < 0.0f) || (u > 1.0f) ) if( ( u < 0.0f ) || ( u > 1.0f ) )
return false; return false;
return true; return true;
@ -323,11 +306,10 @@ static bool intersect( const SEGMENT_WITH_NORMALS &aSeg,
} }
static void extractPathsFrom( const SEGMENTS_WIDTH_NORMALS &aSegList, static void extractPathsFrom( const SEGMENTS_WIDTH_NORMALS& aSegList, const CBBOX2D& aBBox,
const CBBOX2D &aBBox, SEGMENTS_WIDTH_NORMALS& aOutSegThatIntersect )
SEGMENTS_WIDTH_NORMALS &aOutSegThatIntersect )
{ {
wxASSERT( aSegList.size () >= 3 ); wxASSERT( aSegList.size() >= 3 );
unsigned int i; unsigned int i;
unsigned int j = aSegList.size() - 1; unsigned int j = aSegList.size() - 1;
@ -341,8 +323,7 @@ static void extractPathsFrom( const SEGMENTS_WIDTH_NORMALS &aSegList,
for( i = 0; i < aSegList.size(); j = i++ ) for( i = 0; i < aSegList.size(); j = i++ )
{ {
if( aBBox.Inside( aSegList[i].m_Start ) || if( aBBox.Inside( aSegList[i].m_Start ) || aBBox.Inside( aSegList[j].m_Start ) )
aBBox.Inside( aSegList[j].m_Start ) )
{ {
// if the segment points are inside the bounding box then this // if the segment points are inside the bounding box then this
// segment is touching the bbox. // segment is touching the bbox.
@ -353,18 +334,15 @@ static void extractPathsFrom( const SEGMENTS_WIDTH_NORMALS &aSegList,
// Check if a segment intersects the bounding box // Check if a segment intersects the bounding box
// Make a bounding box based on the segments start and end // Make a bounding box based on the segments start and end
CBBOX2D segmentBBox( aSegList[i].m_Start, CBBOX2D segmentBBox( aSegList[i].m_Start, aSegList[j].m_Start );
aSegList[j].m_Start );
if( aBBox.Intersects( segmentBBox ) ) if( aBBox.Intersects( segmentBBox ) )
{ {
const SEGMENT_WITH_NORMALS &seg = aSegList[i]; const SEGMENT_WITH_NORMALS& seg = aSegList[i];
if( intersect( seg, p1, p2 ) || if( intersect( seg, p1, p2 ) || intersect( seg, p2, p3 ) || intersect( seg, p3, p4 )
intersect( seg, p2, p3 ) || || intersect( seg, p4, p1 ) )
intersect( seg, p3, p4 ) ||
intersect( seg, p4, p1 ) )
{ {
aOutSegThatIntersect.push_back( seg ); aOutSegThatIntersect.push_back( seg );
} }
@ -374,45 +352,38 @@ static void extractPathsFrom( const SEGMENTS_WIDTH_NORMALS &aSegList,
} }
static void polygon_Convert( const SHAPE_LINE_CHAIN &aPath, static void polygon_Convert( const SHAPE_LINE_CHAIN& aPath, SEGMENTS& aOutSegment,
SEGMENTS &aOutSegment,
float aBiuTo3DunitsScale ) float aBiuTo3DunitsScale )
{ {
aOutSegment.resize( aPath.PointCount() ); aOutSegment.resize( aPath.PointCount() );
for( int j = 0; j < aPath.PointCount(); j++ ) for( int j = 0; j < aPath.PointCount(); j++ )
{ {
const VECTOR2I &a = aPath.CPoint( j ); const VECTOR2I& a = aPath.CPoint( j );
aOutSegment[j].m_Start = SFVEC2F( (float) a.x * aBiuTo3DunitsScale, aOutSegment[j].m_Start = SFVEC2F( (float) a.x * aBiuTo3DunitsScale,
(float)-a.y * aBiuTo3DunitsScale ); (float) -a.y * aBiuTo3DunitsScale );
} }
unsigned int i; unsigned int i;
unsigned int j = aOutSegment.size () - 1; unsigned int j = aOutSegment.size() - 1;
for( i = 0; i < aOutSegment.size (); j = i++ ) for( i = 0; i < aOutSegment.size(); j = i++ )
{ {
// Calculate constants for each segment // Calculate constants for each segment
aOutSegment[i].m_inv_JY_minus_IY = 1.0f / ( aOutSegment[j].m_Start.y - aOutSegment[i].m_inv_JY_minus_IY = 1.0f /
aOutSegment[i].m_Start.y ); ( aOutSegment[j].m_Start.y - aOutSegment[i].m_Start.y );
aOutSegment[i].m_JX_minus_IX = (aOutSegment[j].m_Start.x - aOutSegment[i].m_JX_minus_IX = ( aOutSegment[j].m_Start.x - aOutSegment[i].m_Start.x );
aOutSegment[i].m_Start.x);
} }
} }
void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks( void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks( const SHAPE_POLY_SET& aMainPath,
const SHAPE_POLY_SET &aMainPath, CGENERICCONTAINER2D& aDstContainer, float aBiuTo3DunitsScale, float aDivFactor,
CGENERICCONTAINER2D &aDstContainer, const BOARD_ITEM& aBoardItem, int aPolyIndex )
float aBiuTo3DunitsScale,
float aDivFactor,
const BOARD_ITEM &aBoardItem,
int aPolyIndex )
{ {
// Get the path // Get the path
wxASSERT( aPolyIndex < aMainPath.OutlineCount() ); wxASSERT( aPolyIndex < aMainPath.OutlineCount() );
const SHAPE_LINE_CHAIN& path = aMainPath.COutline( aPolyIndex ); const SHAPE_LINE_CHAIN& path = aMainPath.COutline( aPolyIndex );
@ -438,13 +409,12 @@ void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(
{ {
const VECTOR2I& a = path.CPoint( i ); const VECTOR2I& a = path.CPoint( i );
const SFVEC2F point ( (float)( a.x) * aBiuTo3DunitsScale, const SFVEC2F point( (float) ( a.x ) * aBiuTo3DunitsScale,
(float)(-a.y) * aBiuTo3DunitsScale ); (float) ( -a.y ) * aBiuTo3DunitsScale );
// Only add points that are not coincident // Only add points that are not coincident
if( (i == 0) || if( ( i == 0 ) || ( fabs( prevPoint.x - point.x ) > FLT_EPSILON )
(fabs(prevPoint.x - point.x) > FLT_EPSILON) || || ( fabs( prevPoint.y - point.y ) > FLT_EPSILON ) )
(fabs(prevPoint.y - point.y) > FLT_EPSILON) )
{ {
prevPoint = point; prevPoint = point;
@ -462,33 +432,32 @@ void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(
bbox.ScaleNextUp(); bbox.ScaleNextUp();
// Calc the slopes, normals and some statistics about this polygon // Calc the slopes, normals and some statistics about this polygon
unsigned int i; unsigned int i;
unsigned int j = segments_and_normals.size() - 1; unsigned int j = segments_and_normals.size() - 1;
// Temporary normal to the segment, it will later be used for interpolation // Temporary normal to the segment, it will later be used for interpolation
std::vector< SFVEC2F > tmpSegmentNormals; std::vector<SFVEC2F> tmpSegmentNormals;
tmpSegmentNormals.resize( segments_and_normals.size() ); tmpSegmentNormals.resize( segments_and_normals.size() );
float medOfTheSquaresSegmentLength = 0.0f; float medOfTheSquaresSegmentLength = 0.0f;
#ifdef PRINT_STATISTICS_3D_VIEWER #ifdef PRINT_STATISTICS_3D_VIEWER
float minLength = FLT_MAX; float minLength = FLT_MAX;
#endif #endif
for( i = 0; i < segments_and_normals.size(); j = i++ ) for( i = 0; i < segments_and_normals.size(); j = i++ )
{ {
const SFVEC2F slope = segments_and_normals[j].m_Start - const SFVEC2F slope = segments_and_normals[j].m_Start - segments_and_normals[i].m_Start;
segments_and_normals[i].m_Start;
segments_and_normals[i].m_Precalc_slope = slope; segments_and_normals[i].m_Precalc_slope = slope;
// Calculate constants for each segment // Calculate constants for each segment
segments[i].m_inv_JY_minus_IY = 1.0f / ( segments_and_normals[j].m_Start.y - segments[i].m_inv_JY_minus_IY =
segments_and_normals[i].m_Start.y ); 1.0f / ( segments_and_normals[j].m_Start.y - segments_and_normals[i].m_Start.y );
segments[i].m_JX_minus_IX = ( segments_and_normals[j].m_Start.x - segments[i].m_JX_minus_IX =
segments_and_normals[i].m_Start.x ); ( segments_and_normals[j].m_Start.x - segments_and_normals[i].m_Start.x );
// The normal orientation expect a fixed polygon orientation (!TODO: which one?) // The normal orientation expect a fixed polygon orientation (!TODO: which one?)
//tmpSegmentNormals[i] = glm::normalize( SFVEC2F( -slope.y, +slope.x ) ); //tmpSegmentNormals[i] = glm::normalize( SFVEC2F( -slope.y, +slope.x ) );
@ -513,33 +482,32 @@ void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(
medOfTheSquaresSegmentLength /= segments_and_normals.size(); medOfTheSquaresSegmentLength /= segments_and_normals.size();
medOfTheSquaresSegmentLength = sqrt( medOfTheSquaresSegmentLength ); medOfTheSquaresSegmentLength = sqrt( medOfTheSquaresSegmentLength );
// Compute the normal interpolation // Compute the normal interpolation
// If calculate the dot between the segments, if they are above/below some // If calculate the dot between the segments, if they are above/below some
// threshould it will not interpolated it (ex: if you are in a edge corner // threshold it will not interpolated it (ex: if you are in a edge corner
// or in a smooth transaction) // or in a smooth transaction)
j = segments_and_normals.size() - 1; j = segments_and_normals.size() - 1;
for( i = 0; i < segments_and_normals.size(); j = i++ ) for( i = 0; i < segments_and_normals.size(); j = i++ )
{ {
const SFVEC2F normalBeforeSeg = tmpSegmentNormals[j]; const SFVEC2F normalBeforeSeg = tmpSegmentNormals[j];
const SFVEC2F normalSeg = tmpSegmentNormals[i]; const SFVEC2F normalSeg = tmpSegmentNormals[i];
const SFVEC2F normalAfterSeg = tmpSegmentNormals[ (i + 1) % const SFVEC2F normalAfterSeg = tmpSegmentNormals[( i + 1 ) % segments_and_normals.size()];
segments_and_normals.size() ];
const float dotBefore = glm::dot( normalBeforeSeg, normalSeg ); const float dotBefore = glm::dot( normalBeforeSeg, normalSeg );
const float dotAfter = glm::dot( normalAfterSeg, normalSeg ); const float dotAfter = glm::dot( normalAfterSeg, normalSeg );
if( dotBefore < 0.7f ) if( dotBefore < 0.7f )
segments_and_normals[i].m_Normals.m_Start = normalSeg; segments_and_normals[i].m_Normals.m_Start = normalSeg;
else else
segments_and_normals[i].m_Normals.m_Start = segments_and_normals[i].m_Normals.m_Start =
glm::normalize( (normalBeforeSeg * dotBefore ) + normalSeg ); glm::normalize( ( normalBeforeSeg * dotBefore ) + normalSeg );
if( dotAfter < 0.7f ) if( dotAfter < 0.7f )
segments_and_normals[i].m_Normals.m_End = normalSeg; segments_and_normals[i].m_Normals.m_End = normalSeg;
else else
segments_and_normals[i].m_Normals.m_End = segments_and_normals[i].m_Normals.m_End =
glm::normalize( (normalAfterSeg * dotAfter ) + normalSeg ); glm::normalize( ( normalAfterSeg * dotAfter ) + normalSeg );
} }
SFVEC2UI grid_divisions; SFVEC2UI grid_divisions;
@ -553,55 +521,46 @@ void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(
if( aDivFactor <= FLT_EPSILON ) if( aDivFactor <= FLT_EPSILON )
aDivFactor = medOfTheSquaresSegmentLength; aDivFactor = medOfTheSquaresSegmentLength;
grid_divisions.x = (unsigned int) ( ( bbox.GetExtent().x / aDivFactor ) );
grid_divisions.y = (unsigned int) ( ( bbox.GetExtent().y / aDivFactor ) );
grid_divisions.x = (unsigned int)( ( bbox.GetExtent().x / aDivFactor ) ); grid_divisions = glm::clamp(
grid_divisions.y = (unsigned int)( ( bbox.GetExtent().y / aDivFactor ) ); grid_divisions, SFVEC2UI( 1, 1 ), SFVEC2UI( MAX_NR_DIVISIONS, MAX_NR_DIVISIONS ) );
grid_divisions = glm::clamp( grid_divisions ,
SFVEC2UI( 1, 1 ),
SFVEC2UI( MAX_NR_DIVISIONS, MAX_NR_DIVISIONS ) );
} }
// Calculate the steps advance of the grid // Calculate the steps advance of the grid
SFVEC2F blockAdvance; SFVEC2F blockAdvance;
blockAdvance.x = bbox.GetExtent().x / (float)grid_divisions.x; blockAdvance.x = bbox.GetExtent().x / (float) grid_divisions.x;
blockAdvance.y = bbox.GetExtent().y / (float)grid_divisions.y; blockAdvance.y = bbox.GetExtent().y / (float) grid_divisions.y;
wxASSERT( blockAdvance.x > 0.0f ); wxASSERT( blockAdvance.x > 0.0f );
wxASSERT( blockAdvance.y > 0.0f ); wxASSERT( blockAdvance.y > 0.0f );
const int leftToRight_inc = (pathBounds.GetRight() - pathBounds.GetLeft()) / const int leftToRight_inc = ( pathBounds.GetRight() - pathBounds.GetLeft() ) / grid_divisions.x;
grid_divisions.x;
const int topToBottom_inc = (pathBounds.GetBottom() - pathBounds.GetTop()) / const int topToBottom_inc = ( pathBounds.GetBottom() - pathBounds.GetTop() ) / grid_divisions.y;
grid_divisions.y;
// Statistics // Statistics
unsigned int stats_n_empty_blocks = 0; unsigned int stats_n_empty_blocks = 0;
unsigned int stats_n_dummy_blocks = 0; unsigned int stats_n_dummy_blocks = 0;
unsigned int stats_n_poly_blocks = 0; unsigned int stats_n_poly_blocks = 0;
unsigned int stats_sum_size_of_polygons = 0; unsigned int stats_sum_size_of_polygons = 0;
// Step by each block of a grid trying to extract segments and create polygon blocks
// Step by each block of a grid trying to extract segments and create int topToBottom = pathBounds.GetTop();
// polygon blocks float blockY = bbox.Max().y;
int topToBottom = pathBounds.GetTop();
float blockY = bbox.Max().y;
for( unsigned int iy = 0; iy < grid_divisions.y; iy++ ) for( unsigned int iy = 0; iy < grid_divisions.y; iy++ )
{ {
int leftToRight = pathBounds.GetLeft(); int leftToRight = pathBounds.GetLeft();
float blockX = bbox.Min().x; float blockX = bbox.Min().x;
for( unsigned int ix = 0; ix < grid_divisions.x; ix++ ) for( unsigned int ix = 0; ix < grid_divisions.x; ix++ )
{ {
CBBOX2D blockBox( SFVEC2F( blockX, CBBOX2D blockBox( SFVEC2F( blockX, blockY - blockAdvance.y ),
blockY - blockAdvance.y ), SFVEC2F( blockX + blockAdvance.x, blockY ) );
SFVEC2F( blockX + blockAdvance.x,
blockY ) );
// Make the box large to it will catch (intersect) the edges // Make the box large to it will catch (intersect) the edges
blockBox.ScaleNextUp(); blockBox.ScaleNextUp();
@ -612,7 +571,6 @@ void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(
extractPathsFrom( segments_and_normals, blockBox, extractedSegments ); extractPathsFrom( segments_and_normals, blockBox, extractedSegments );
if( extractedSegments.empty() ) if( extractedSegments.empty() )
{ {
@ -621,22 +579,20 @@ void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(
SFVEC2F p3( blockBox.Max().x, blockBox.Max().y ); SFVEC2F p3( blockBox.Max().x, blockBox.Max().y );
SFVEC2F p4( blockBox.Min().x, blockBox.Max().y ); SFVEC2F p4( blockBox.Min().x, blockBox.Max().y );
if( polygon_IsPointInside( segments, p1 ) || if( polygon_IsPointInside( segments, p1 ) || polygon_IsPointInside( segments, p2 )
polygon_IsPointInside( segments, p2 ) || || polygon_IsPointInside( segments, p3 )
polygon_IsPointInside( segments, p3 ) || || polygon_IsPointInside( segments, p4 ) )
polygon_IsPointInside( segments, p4 ) )
{ {
// In this case, the segments are not intersecting the // In this case, the segments are not intersecting the
// polygon, so it means that if any point is inside it, // polygon, so it means that if any point is inside it,
// then all other are inside the polygon. // then all other are inside the polygon.
// This is a full bbox inside, so add a dummy box // This is a full bbox inside, so add a dummy box
aDstContainer.Add( new CDUMMYBLOCK2D( blockBox, aBoardItem ) ); aDstContainer.Add( new CDUMMYBLOCK2D( blockBox, aBoardItem ) );
stats_n_dummy_blocks++; stats_n_dummy_blocks++;
} }
else else
{ {
// Points are outside, so this block complety missed the polygon // Points are outside, so this block completely missed the polygon
// In this case, no objects need to be added // In this case, no objects need to be added
stats_n_empty_blocks++; stats_n_empty_blocks++;
} }
@ -663,9 +619,8 @@ void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(
// We need here a strictly simple polygon with outlines and holes // We need here a strictly simple polygon with outlines and holes
SHAPE_POLY_SET solution; SHAPE_POLY_SET solution;
solution.BooleanIntersection( aMainPath, solution.BooleanIntersection(
subBlockPoly, aMainPath, subBlockPoly, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
OUTERS_AND_HOLES outersAndHoles; OUTERS_AND_HOLES outersAndHoles;
@ -674,7 +629,7 @@ void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(
for( int idx = 0; idx < solution.OutlineCount(); idx++ ) for( int idx = 0; idx < solution.OutlineCount(); idx++ )
{ {
const SHAPE_LINE_CHAIN & outline = solution.Outline( idx ); const SHAPE_LINE_CHAIN& outline = solution.Outline( idx );
SEGMENTS solutionSegment; SEGMENTS solutionSegment;
@ -683,23 +638,19 @@ void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(
stats_sum_size_of_polygons += solutionSegment.size(); stats_sum_size_of_polygons += solutionSegment.size();
for( int holeIdx = 0; for( int holeIdx = 0; holeIdx < solution.HoleCount( idx ); holeIdx++ )
holeIdx < solution.HoleCount( idx );
holeIdx++ )
{ {
const SHAPE_LINE_CHAIN & hole = solution.Hole( idx, holeIdx ); const SHAPE_LINE_CHAIN& hole = solution.Hole( idx, holeIdx );
polygon_Convert( hole, solutionSegment, aBiuTo3DunitsScale ); polygon_Convert( hole, solutionSegment, aBiuTo3DunitsScale );
outersAndHoles.m_Holes.push_back( solutionSegment ); outersAndHoles.m_Holes.push_back( solutionSegment );
stats_sum_size_of_polygons += solutionSegment.size(); stats_sum_size_of_polygons += solutionSegment.size();
} }
} }
if( !outersAndHoles.m_Outers.empty() ) if( !outersAndHoles.m_Outers.empty() )
{ {
aDstContainer.Add( new CPOLYGONBLOCK2D( extractedSegments, aDstContainer.Add( new CPOLYGONBLOCK2D( extractedSegments, outersAndHoles,
outersAndHoles,
aBoardItem ) ); aBoardItem ) );
stats_n_poly_blocks++; stats_n_poly_blocks++;
} }
@ -716,30 +667,30 @@ void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(
#ifdef DEBUG #ifdef DEBUG
static void polygon_Convert( const ClipperLib::Path &aPath, static void polygon_Convert( const ClipperLib::Path& aPath, SEGMENTS& aOutSegment,
SEGMENTS &aOutSegment,
float aBiuTo3DunitsScale ) float aBiuTo3DunitsScale )
{ {
aOutSegment.resize( aPath.size() ); aOutSegment.resize( aPath.size() );
for( unsigned i = 0; i < aPath.size(); i++ ) for( unsigned i = 0; i < aPath.size(); i++ )
{ {
aOutSegment[i].m_Start = SFVEC2F( (float) aPath[i].X * aBiuTo3DunitsScale, aOutSegment[i].m_Start = SFVEC2F(
(float)-aPath[i].Y * aBiuTo3DunitsScale ); (float) aPath[i].X * aBiuTo3DunitsScale, (float) -aPath[i].Y * aBiuTo3DunitsScale );
} }
unsigned int i; unsigned int i;
unsigned int j = aOutSegment.size () - 1; unsigned int j = aOutSegment.size() - 1;
for( i = 0; i < aOutSegment.size (); j = i++ ) for( i = 0; i < aOutSegment.size(); j = i++ )
{ {
// Calculate constants for each segment // Calculate constants for each segment
aOutSegment[i].m_inv_JY_minus_IY = 1.0f / ( aOutSegment[j].m_Start.y - aOutSegment[i].m_inv_JY_minus_IY =
aOutSegment[i].m_Start.y ); 1.0f / ( aOutSegment[j].m_Start.y - aOutSegment[i].m_Start.y );
aOutSegment[i].m_JX_minus_IX = (aOutSegment[j].m_Start.x - aOutSegment[i].m_Start.x); aOutSegment[i].m_JX_minus_IX = ( aOutSegment[j].m_Start.x - aOutSegment[i].m_Start.x );
} }
} }
void Polygon2d_TestModule() void Polygon2d_TestModule()
{ {
// "This structure contains a sequence of IntPoint vertices defining a // "This structure contains a sequence of IntPoint vertices defining a
@ -751,9 +702,9 @@ void Polygon2d_TestModule()
aPath.resize( 4 ); aPath.resize( 4 );
aPath[0] = ClipperLib::IntPoint( -2, -2 ); aPath[0] = ClipperLib::IntPoint( -2, -2 );
aPath[1] = ClipperLib::IntPoint( 2, -2 ); aPath[1] = ClipperLib::IntPoint( 2, -2 );
aPath[2] = ClipperLib::IntPoint( 2, 2 ); aPath[2] = ClipperLib::IntPoint( 2, 2 );
aPath[3] = ClipperLib::IntPoint( -2, 2 ); aPath[3] = ClipperLib::IntPoint( -2, 2 );
// It must be an outer polygon // It must be an outer polygon
wxASSERT( ClipperLib::Orientation( aPath ) ); wxASSERT( ClipperLib::Orientation( aPath ) );
@ -762,20 +713,20 @@ void Polygon2d_TestModule()
wxASSERT( aPath.size() == aSegments.size() ); wxASSERT( aPath.size() == aSegments.size() );
wxASSERT( aSegments[0].m_Start == SFVEC2F( -2.0f, 2.0f ) ); wxASSERT( aSegments[0].m_Start == SFVEC2F( -2.0f, 2.0f ) );
wxASSERT( aSegments[1].m_Start == SFVEC2F( 2.0f, 2.0f ) ); wxASSERT( aSegments[1].m_Start == SFVEC2F( 2.0f, 2.0f ) );
wxASSERT( aSegments[2].m_Start == SFVEC2F( 2.0f, -2.0f ) ); wxASSERT( aSegments[2].m_Start == SFVEC2F( 2.0f, -2.0f ) );
wxASSERT( aSegments[3].m_Start == SFVEC2F( -2.0f, -2.0f ) ); wxASSERT( aSegments[3].m_Start == SFVEC2F( -2.0f, -2.0f ) );
wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( 0.0f, 0.0f ) ) ); wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( 0.0f, 0.0f ) ) );
wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( -1.9f, -1.9f ) ) ); wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( -1.9f, -1.9f ) ) );
wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( -1.9f, 1.9f ) ) ); wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( -1.9f, 1.9f ) ) );
wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( 1.9f, 1.9f ) ) ); wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( 1.9f, 1.9f ) ) );
wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( 1.9f, -1.9f ) ) ); wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( 1.9f, -1.9f ) ) );
wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( -2.1f, -2.0f ) ) == false ); wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( -2.1f, -2.0f ) ) == false );
wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( -2.1f, 2.0f ) ) == false ); wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( -2.1f, 2.0f ) ) == false );
wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( 2.1f, 2.0f ) ) == false ); wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( 2.1f, 2.0f ) ) == false );
wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( 2.1f, -2.0f ) ) == false ); wxASSERT( polygon_IsPointInside( aSegments, SFVEC2F( 2.1f, -2.0f ) ) == false );
} }
#endif #endif

93
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cpolygon2d.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2018 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -41,14 +41,14 @@ typedef struct
SFVEC2F m_Start; SFVEC2F m_Start;
float m_inv_JY_minus_IY; float m_inv_JY_minus_IY;
float m_JX_minus_IX; float m_JX_minus_IX;
}POLYSEGMENT; } POLYSEGMENT;
typedef struct typedef struct
{ {
SFVEC2F m_Start; SFVEC2F m_Start;
SFVEC2F m_End; SFVEC2F m_End;
}SEG_NORMALS; } SEG_NORMALS;
typedef struct typedef struct
@ -56,45 +56,43 @@ typedef struct
SFVEC2F m_Start; SFVEC2F m_Start;
SFVEC2F m_Precalc_slope; SFVEC2F m_Precalc_slope;
SEG_NORMALS m_Normals; SEG_NORMALS m_Normals;
}SEGMENT_WITH_NORMALS; } SEGMENT_WITH_NORMALS;
typedef std::vector< POLYSEGMENT > SEGMENTS; typedef std::vector< POLYSEGMENT > SEGMENTS;
/// This list will be used to test ray2d intersections. It will be a subset /**
/// of an original polygon. The normals will be passed already interpolated. * List used to test ray2d intersections.
*
* It will be a subset of an original polygon. The normals will be passed already interpolated.
*/
typedef std::vector< SEGMENT_WITH_NORMALS > SEGMENTS_WIDTH_NORMALS; typedef std::vector< SEGMENT_WITH_NORMALS > SEGMENTS_WIDTH_NORMALS;
/// This structured will be used to handle a sub set of a polygon. /**
/// It can contain multiple closed polygons and holes. * Handle a subset of a polygon.
/// It will be used to test if points are inside. A point will be inside the *
/// polygon if it is not inside a hole and it is inside a Outer polygon. * It can contain multiple closed polygons and holes and us used to test if points are inside.
* A point will be inside the polygon if it is not inside a hole and it is inside an outer polygon.
*/
typedef struct typedef struct
{ {
std::vector<SEGMENTS> m_Outers; std::vector<SEGMENTS> m_Outers;
std::vector<SEGMENTS> m_Holes; std::vector<SEGMENTS> m_Holes;
}OUTERS_AND_HOLES; } OUTERS_AND_HOLES;
/// This class represents a sub polygon block. This polygon block was created /**
/// from a general polygon definition that was sub divided and create blocks of * Represent a sub polygon block.
/// polygons. This polygon class represent a sub part of that main polygon. *
/// There is information for the contours (used to test the ray2d intersection) * This polygon block was created from a general polygon definition that was sub divided and
/// and a close definition of the block polygon to test if a point is inside. * to create blocks of polygons. This polygon class represent a sub part of that main polygon.
* There is information for the contours (used to test the ray2d intersection) and a close
* definition of the block polygon to test if a point is inside.
*/
class CPOLYGONBLOCK2D : public COBJECT2D class CPOLYGONBLOCK2D : public COBJECT2D
{ {
private:
/// This is the outer part of the polygon. This list is used to test a ray
/// intersection with the boundaries of this sub polygon.
/// It contains also the interpolated normals that are passed from the main
/// polygon.
SEGMENTS_WIDTH_NORMALS m_open_segments;
/// A polygon block can have multiple polygon and holes
OUTERS_AND_HOLES m_outers_and_holes;
public: public:
CPOLYGONBLOCK2D( const SEGMENTS_WIDTH_NORMALS &aOpenSegmentList, CPOLYGONBLOCK2D( const SEGMENTS_WIDTH_NORMALS &aOpenSegmentList,
const OUTERS_AND_HOLES &aOuter_and_holes, const OUTERS_AND_HOLES &aOuter_and_holes,
@ -106,17 +104,30 @@ public:
bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override; bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override;
INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override; INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override;
bool IsPointInside( const SFVEC2F &aPoint ) const override; bool IsPointInside( const SFVEC2F &aPoint ) const override;
private:
/**
* The outer part of the polygon.
*
* This list is used to test a ray intersection with the boundaries of this sub polygon.
* It contains also the interpolated normals that are passed from the main polygon.
*/
SEGMENTS_WIDTH_NORMALS m_open_segments;
///< A polygon block can have multiple polygon and holes
OUTERS_AND_HOLES m_outers_and_holes;
}; };
/// This dummy block will be defined by a 2d box size. If the point is inside /**
/// the bounding box it will return allways true. However, the intersection with * A dummy block defined by a 2d box size.
/// a ray will return allways false. *
/// This is used as a sub block extrated from polygon (pcb polygon areas) and * If the point is inside the bounding box it will return always true. However, the
/// represents an area that is full filled. * intersection with a ray will return always false. This is used as a sub block
* extracted from polygon (pcb polygon areas) and represents an area that is full filled.
*/
class CDUMMYBLOCK2D : public COBJECT2D class CDUMMYBLOCK2D : public COBJECT2D
{ {
public: public:
CDUMMYBLOCK2D( const SFVEC2F &aPbMin, CDUMMYBLOCK2D( const SFVEC2F &aPbMin,
const SFVEC2F &aPbMax, const SFVEC2F &aPbMax,
@ -132,16 +143,16 @@ public:
bool IsPointInside( const SFVEC2F &aPoint ) const override; bool IsPointInside( const SFVEC2F &aPoint ) const override;
}; };
/** /**
* @brief Convert_path_polygon_to_polygon_blocks_and_dummy_blocks * Use a polygon in the format of the ClipperLib::Path and process it and create multiple 2d
* This function will use a polygon in the format of the ClipperLib::Path * objects (CPOLYGONBLOCK2D and CDUMMYBLOCK2D) that can be used to represent this polygon area.
* will process it and will create multiple 2d objects (CPOLYGONBLOCK2D and *
* CDUMMYBLOCK2D) that can be used to represent this polygon area. * @param aMainPath the polygon are that was converted from the pcb board
* @param aMainPath - the polygon are that was converted from the pcb board * @param aDstContainer the destination container to put the created sub blocks
* @param aDstContainer - the destination container to put the created sub blocks * @param aBiuTo3DunitsScale the rendering target 3d scale
* @param aBiuTo3DunitsScale - the rendering target 3d scale * @param aDivFactor a division factor (in 3Dunits) to divide the polygon plane,
* @param aDivFactor - a division factor (in 3Dunits) to divide the polygon plane, * 0.0f will use the internal polygon segm statistics
* 0.0f will use the internal polygon segm statistics
*/ */
void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks( void Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(
const SHAPE_POLY_SET &aMainPath, const SHAPE_POLY_SET &aMainPath,

63
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cpolygon4pts2d.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -32,9 +32,9 @@
CPOLYGON4PTS2D::CPOLYGON4PTS2D( const SFVEC2F& v1, const SFVEC2F& v2, const SFVEC2F& v3, CPOLYGON4PTS2D::CPOLYGON4PTS2D( const SFVEC2F& v1, const SFVEC2F& v2, const SFVEC2F& v3,
const SFVEC2F& v4, const BOARD_ITEM& aBoardItem ) const SFVEC2F& v4, const BOARD_ITEM& aBoardItem ) :
: COBJECT2D( OBJECT2D_TYPE::POLYGON4PT, aBoardItem ) COBJECT2D( OBJECT2D_TYPE::POLYGON4PT, aBoardItem )
{/* { /*
if( (v1.x > v2.x) || (v1.y < v2.y) ) if( (v1.x > v2.x) || (v1.y < v2.y) )
{ {
m_segments[0] = v4; m_segments[0] = v4;
@ -44,20 +44,20 @@ CPOLYGON4PTS2D::CPOLYGON4PTS2D( const SFVEC2F& v1, const SFVEC2F& v2, const SFVE
} }
else else
{*/ {*/
m_segments[0] = v1; m_segments[0] = v1;
m_segments[1] = v4; m_segments[1] = v4;
m_segments[2] = v3; m_segments[2] = v3;
m_segments[3] = v2; m_segments[3] = v2;
// } // }
unsigned int i; unsigned int i;
unsigned int j = 4 - 1; unsigned int j = 4 - 1;
for( i = 0; i < 4; j = i++ ) for( i = 0; i < 4; j = i++ )
{ {
SFVEC2F slope = m_segments[j] - m_segments[i]; SFVEC2F slope = m_segments[j] - m_segments[i];
m_precalc_slope[i] = slope; m_precalc_slope[i] = slope;
m_seg_normal[i] = glm::normalize( SFVEC2F( -slope.y, +slope.x ) ); m_seg_normal[i] = glm::normalize( SFVEC2F( -slope.y, +slope.x ) );
} }
m_bbox.Reset(); m_bbox.Reset();
@ -76,7 +76,7 @@ CPOLYGON4PTS2D::CPOLYGON4PTS2D( const SFVEC2F& v1, const SFVEC2F& v2, const SFVE
} }
bool CPOLYGON4PTS2D::Intersects( const CBBOX2D &aBBox ) const bool CPOLYGON4PTS2D::Intersects( const CBBOX2D& aBBox ) const
{ {
return m_bbox.Intersects( aBBox ); return m_bbox.Intersects( aBBox );
@ -125,37 +125,37 @@ bool CPOLYGON4PTS2D::Intersects( const CBBOX2D &aBBox ) const
} }
bool CPOLYGON4PTS2D::Overlaps( const CBBOX2D &aBBox ) const bool CPOLYGON4PTS2D::Overlaps( const CBBOX2D& aBBox ) const
{ {
// NOT IMPLEMENTED // NOT IMPLEMENTED
return true; return true;
} }
bool CPOLYGON4PTS2D::Intersect( const RAYSEG2D &aSegRay, bool CPOLYGON4PTS2D::Intersect( const RAYSEG2D& aSegRay, float* aOutT, SFVEC2F* aNormalOut ) const
float *aOutT,
SFVEC2F *aNormalOut ) const
{ {
bool hited = false; bool hited = false;
unsigned int hitIndex; unsigned int hitIndex;
float bestHitT; float bestHitT;
for( unsigned int i = 0; i < 4; i++ ) for( unsigned int i = 0; i < 4; i++ )
{ {
float t; float t;
if( aSegRay.IntersectSegment( m_segments[i], m_precalc_slope[i], &t ) ) if( aSegRay.IntersectSegment( m_segments[i], m_precalc_slope[i], &t ) )
if( (hited == false) || ( t < bestHitT) ) {
if( ( hited == false ) || ( t < bestHitT ) )
{ {
hited = true; hited = true;
hitIndex = i; hitIndex = i;
bestHitT = t; bestHitT = t;
} }
}
} }
if( hited ) if( hited )
{ {
wxASSERT( (bestHitT >= 0.0f) && (bestHitT <= 1.0f) ); wxASSERT( ( bestHitT >= 0.0f ) && ( bestHitT <= 1.0f ) );
if( aOutT ) if( aOutT )
*aOutT = bestHitT; *aOutT = bestHitT;
@ -170,7 +170,7 @@ bool CPOLYGON4PTS2D::Intersect( const RAYSEG2D &aSegRay,
} }
INTERSECTION_RESULT CPOLYGON4PTS2D::IsBBoxInside( const CBBOX2D &aBBox ) const INTERSECTION_RESULT CPOLYGON4PTS2D::IsBBoxInside( const CBBOX2D& aBBox ) const
{ {
// !TODO: // !TODO:
@ -178,29 +178,28 @@ INTERSECTION_RESULT CPOLYGON4PTS2D::IsBBoxInside( const CBBOX2D &aBBox ) const
} }
bool CPOLYGON4PTS2D::IsPointInside( const SFVEC2F &aPoint ) const bool CPOLYGON4PTS2D::IsPointInside( const SFVEC2F& aPoint ) const
{ {
unsigned int i; unsigned int i;
unsigned int j = 4 - 1; unsigned int j = 4 - 1;
bool oddNodes = false; bool oddNodes = false;
for( i = 0; i < 4; j = i++ ) for( i = 0; i < 4; j = i++ )
{ {
const float polyJY = m_segments[j].y; const float polyJY = m_segments[j].y;
const float polyIY = m_segments[i].y; const float polyIY = m_segments[i].y;
if( ((polyIY <= aPoint.y) && (polyJY >= aPoint.y)) || if( ( ( polyIY <= aPoint.y ) && ( polyJY >= aPoint.y ) )
((polyJY <= aPoint.y) && (polyIY >= aPoint.y)) || ( ( polyJY <= aPoint.y ) && ( polyIY >= aPoint.y ) ) )
)
{ {
const float polyJX = m_segments[j].x; const float polyJX = m_segments[j].x;
const float polyIX = m_segments[i].x; const float polyIX = m_segments[i].x;
if( (polyIX <= aPoint.x) || (polyJX <= aPoint.x) ) if( ( polyIX <= aPoint.x ) || ( polyJX <= aPoint.x ) )
{ {
oddNodes ^= ( ( polyIX + oddNodes ^= ( ( polyIX + ( ( aPoint.y - polyIY ) / ( polyJY - polyIY ) )
( ( aPoint.y - polyIY ) / ( polyJY - polyIY ) ) * * ( polyJX - polyIX ) )
( polyJX - polyIX ) ) < aPoint.x ); < aPoint.x );
} }
} }
} }

19
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cpolygon4pts2d.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -33,17 +33,13 @@
#include "cobject2d.h" #include "cobject2d.h"
/** /**
* This handles simple polygons with 4 points. Used for pads. * Simple polygons with 4 points.
* (rectangles, trapezoids, with rotation.etc) *
* This is a simplified version of the cpolygon2d class * Used for footprint pads. (rectangles, trapezoids, with rotation.etc). This is a
* simplified version of the #CPOLYGON2D class.
*/ */
class CPOLYGON4PTS2D : public COBJECT2D class CPOLYGON4PTS2D : public COBJECT2D
{ {
private:
SFVEC2F m_segments[4];
SFVEC2F m_precalc_slope[4];
SFVEC2F m_seg_normal[4];
public: public:
CPOLYGON4PTS2D( const SFVEC2F &v1, CPOLYGON4PTS2D( const SFVEC2F &v1,
const SFVEC2F &v2, const SFVEC2F &v2,
@ -67,6 +63,11 @@ public:
bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override; bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override;
INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override; INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override;
bool IsPointInside( const SFVEC2F &aPoint ) const override; bool IsPointInside( const SFVEC2F &aPoint ) const override;
private:
SFVEC2F m_segments[4];
SFVEC2F m_precalc_slope[4];
SFVEC2F m_seg_normal[4];
}; };

17
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cring2d.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -33,8 +33,8 @@
CRING2D::CRING2D( const SFVEC2F& aCenter, float aInnerRadius, float aOuterRadius, CRING2D::CRING2D( const SFVEC2F& aCenter, float aInnerRadius, float aOuterRadius,
const BOARD_ITEM& aBoardItem ) const BOARD_ITEM& aBoardItem ) :
: COBJECT2D( OBJECT2D_TYPE::RING, aBoardItem ) COBJECT2D( OBJECT2D_TYPE::RING, aBoardItem )
{ {
wxASSERT( aInnerRadius < aOuterRadius ); wxASSERT( aInnerRadius < aOuterRadius );
@ -51,7 +51,6 @@ CRING2D::CRING2D( const SFVEC2F& aCenter, float aInnerRadius, float aOuterRadius
m_bbox.ScaleNextUp(); m_bbox.ScaleNextUp();
m_centroid = m_bbox.GetCenter(); m_centroid = m_bbox.GetCenter();
wxASSERT( m_bbox.IsInitialized() ); wxASSERT( m_bbox.IsInitialized() );
} }
@ -65,7 +64,7 @@ bool CRING2D::Overlaps( const CBBOX2D &aBBox ) const
bool CRING2D::Intersects( const CBBOX2D &aBBox ) const bool CRING2D::Intersects( const CBBOX2D &aBBox ) const
{ {
// !TODO: check the inside for a great improovment // !TODO: check the inside for a great improvement
return aBBox.Intersects( m_center, m_outer_radius_squared ); return aBBox.Intersects( m_center, m_outer_radius_squared );
} }
@ -86,7 +85,6 @@ bool CRING2D::Intersect( const RAYSEG2D &aSegRay,
// solving the quadratic equation for t at the pts of intersection // solving the quadratic equation for t at the pts of intersection
// dd*t^2 + (2*qd)*t + (qq-r^2) = 0 // dd*t^2 + (2*qd)*t + (qq-r^2) = 0
const float discriminantsqr = qd * qd - qq; const float discriminantsqr = qd * qd - qq;
const float discriminantsqr_outer = discriminantsqr + m_outer_radius_squared; const float discriminantsqr_outer = discriminantsqr + m_outer_radius_squared;
@ -129,10 +127,14 @@ bool CRING2D::Intersect( const RAYSEG2D &aSegRay,
} }
} }
else else
{
return false; return false;
}
} }
else else
{
return false; return false;
}
} }
wxASSERT( (t > 0.0f) && (t <= aSegRay.m_Length) ); wxASSERT( (t > 0.0f) && (t <= aSegRay.m_Length) );
@ -196,8 +198,7 @@ bool CRING2D::IsPointInside( const SFVEC2F &aPoint ) const
const float dot = glm::dot( v, v ); const float dot = glm::dot( v, v );
if( (dot <= m_outer_radius_squared) && if( (dot <= m_outer_radius_squared) && (dot >= m_inner_radius_squared) )
(dot >= m_inner_radius_squared) )
return true; return true;
return false; return false;

23
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/cring2d.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -35,6 +35,16 @@
class CRING2D : public COBJECT2D class CRING2D : public COBJECT2D
{ {
public: public:
CRING2D( const SFVEC2F &aCenter, float aInnerRadius, float aOuterRadius,
const BOARD_ITEM &aBoardItem );
// Imported from COBJECT2D
bool Overlaps( const CBBOX2D &aBBox ) const override;
bool Intersects( const CBBOX2D &aBBox ) const override;
bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override;
INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override;
bool IsPointInside( const SFVEC2F &aPoint ) const override;
const SFVEC2F &GetCenter() const { return m_center; } const SFVEC2F &GetCenter() const { return m_center; }
float GetInnerRadius() const { return m_inner_radius; } float GetInnerRadius() const { return m_inner_radius; }
float GetOuterRadius() const { return m_outer_radius; } float GetOuterRadius() const { return m_outer_radius; }
@ -48,17 +58,6 @@ private:
float m_outer_radius; float m_outer_radius;
float m_inner_radius_squared; float m_inner_radius_squared;
float m_outer_radius_squared; float m_outer_radius_squared;
public:
CRING2D( const SFVEC2F &aCenter, float aInnerRadius, float aOuterRadius,
const BOARD_ITEM &aBoardItem );
// Imported from COBJECT2D
bool Overlaps( const CBBOX2D &aBBox ) const override;
bool Intersects( const CBBOX2D &aBBox ) const override;
bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override;
INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override;
bool IsPointInside( const SFVEC2F &aPoint ) const override;
}; };

77
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/croundsegment2d.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -31,9 +31,10 @@
#include <wx/debug.h> #include <wx/debug.h>
CROUNDSEGMENT2D::CROUNDSEGMENT2D( CROUNDSEGMENT2D::CROUNDSEGMENT2D( const SFVEC2F& aStart, const SFVEC2F& aEnd, float aWidth,
const SFVEC2F& aStart, const SFVEC2F& aEnd, float aWidth, const BOARD_ITEM& aBoardItem ) const BOARD_ITEM& aBoardItem ) :
: COBJECT2D( OBJECT2D_TYPE::ROUNDSEG, aBoardItem ), m_segment( aStart, aEnd ) COBJECT2D( OBJECT2D_TYPE::ROUNDSEG, aBoardItem ),
m_segment( aStart, aEnd )
{ {
wxASSERT( aStart != aEnd ); wxASSERT( aStart != aEnd );
@ -41,8 +42,7 @@ CROUNDSEGMENT2D::CROUNDSEGMENT2D(
m_radius_squared = m_radius * m_radius; m_radius_squared = m_radius * m_radius;
m_width = aWidth; m_width = aWidth;
SFVEC2F leftRadiusOffset( -m_segment.m_Dir.y * m_radius, SFVEC2F leftRadiusOffset( -m_segment.m_Dir.y * m_radius, m_segment.m_Dir.x * m_radius );
m_segment.m_Dir.x * m_radius );
m_leftStart = aStart + leftRadiusOffset; m_leftStart = aStart + leftRadiusOffset;
m_leftEnd = aEnd + leftRadiusOffset; m_leftEnd = aEnd + leftRadiusOffset;
@ -72,11 +72,8 @@ bool CROUNDSEGMENT2D::Intersects( const CBBOX2D &aBBox ) const
if( !m_bbox.Intersects( aBBox ) ) if( !m_bbox.Intersects( aBBox ) )
return false; return false;
if( (aBBox.Max().x > m_bbox.Max().x) && if( ( aBBox.Max().x > m_bbox.Max().x ) && ( aBBox.Max().y > m_bbox.Max().y )
(aBBox.Max().y > m_bbox.Max().y) && && ( aBBox.Min().x < m_bbox.Min().x ) && ( aBBox.Min().y < m_bbox.Min().y ) )
(aBBox.Min().x < m_bbox.Min().x) &&
(aBBox.Min().y < m_bbox.Min().y)
)
return true; return true;
SFVEC2F v[4]; SFVEC2F v[4];
@ -172,20 +169,24 @@ bool CROUNDSEGMENT2D::Intersect( const RAYSEG2D &aSegRay,
if( rightSegmentHit ) if( rightSegmentHit )
{ {
if( !start_is_inside ) if( !start_is_inside )
if( (hitted == false) || (rightSegT < closerHitT) )
{ {
closerHitT = rightSegT; if( (hitted == false) || (rightSegT < closerHitT) )
closerHitNormal = SFVEC2F( -m_rightDir.y, m_rightDir.x ); {
} closerHitT = rightSegT;
closerHitNormal = SFVEC2F( -m_rightDir.y, m_rightDir.x );
}
if( start_is_inside ) if( start_is_inside )
if( (hitted == false) || (rightSegT > farHitT) ) {
{ if( (hitted == false) || (rightSegT > farHitT) )
farHitT = rightSegT; {
farHitNormal = SFVEC2F( -m_rightDir.y, m_rightDir.x ); farHitT = rightSegT;
} farHitNormal = SFVEC2F( -m_rightDir.y, m_rightDir.x );
}
}
hitted = true; hitted = true;
}
} }
float circleStart_T0; float circleStart_T0;
@ -202,17 +203,21 @@ bool CROUNDSEGMENT2D::Intersect( const RAYSEG2D &aSegRay,
if( circleStart_T0 > 0.0f ) if( circleStart_T0 > 0.0f )
{ {
if( !start_is_inside ) if( !start_is_inside )
if( (hitted == false) || (circleStart_T0 < closerHitT) )
{ {
closerHitT = circleStart_T0; if( (hitted == false) || (circleStart_T0 < closerHitT) )
closerHitNormal = circleStart_N0; {
closerHitT = circleStart_T0;
closerHitNormal = circleStart_N0;
}
} }
if( start_is_inside ) if( start_is_inside )
if( (hitted == false) || (circleStart_T1 > farHitT) )
{ {
farHitT = circleStart_T1; if( (hitted == false) || (circleStart_T1 > farHitT) )
farHitNormal = circleStart_N1; {
farHitT = circleStart_T1;
farHitNormal = circleStart_N1;
}
} }
} }
else else
@ -241,17 +246,21 @@ bool CROUNDSEGMENT2D::Intersect( const RAYSEG2D &aSegRay,
if( circleEnd_T0 > 0.0f ) if( circleEnd_T0 > 0.0f )
{ {
if( !start_is_inside ) if( !start_is_inside )
if( (hitted == false) || (circleEnd_T0 < closerHitT) )
{ {
closerHitT = circleEnd_T0; if( (hitted == false) || (circleEnd_T0 < closerHitT) )
closerHitNormal = circleEnd_N0; {
closerHitT = circleEnd_T0;
closerHitNormal = circleEnd_N0;
}
} }
if( start_is_inside ) if( start_is_inside )
if( (hitted == false) || (circleEnd_T1 > farHitT) )
{ {
farHitT = circleEnd_T1; if( (hitted == false) || (circleEnd_T1 > farHitT) )
farHitNormal = circleEnd_N1; {
farHitT = circleEnd_T1;
farHitNormal = circleEnd_N1;
}
} }
} }
else else

46
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/croundsegment2d.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -37,23 +37,6 @@ class CROUNDSEGMENT2D : public COBJECT2D
friend class CROUNDSEG; friend class CROUNDSEG;
private:
RAYSEG2D m_segment;
SFVEC2F m_leftStart;
SFVEC2F m_leftEnd;
SFVEC2F m_leftEndMinusStart;
SFVEC2F m_leftDir;
SFVEC2F m_rightStart;
SFVEC2F m_rightEnd;
SFVEC2F m_rightEndMinusStart;
SFVEC2F m_rightDir;
float m_radius;
float m_radius_squared;
float m_width;
public: public:
CROUNDSEGMENT2D( const SFVEC2F &aStart, const SFVEC2F &aEnd, float aWidth, CROUNDSEGMENT2D( const SFVEC2F &aStart, const SFVEC2F &aEnd, float aWidth,
const BOARD_ITEM &aBoardItem ); const BOARD_ITEM &aBoardItem );
@ -83,15 +66,32 @@ public:
bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override; bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override;
INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override; INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override;
bool IsPointInside( const SFVEC2F &aPoint ) const override; bool IsPointInside( const SFVEC2F &aPoint ) const override;
private:
RAYSEG2D m_segment;
SFVEC2F m_leftStart;
SFVEC2F m_leftEnd;
SFVEC2F m_leftEndMinusStart;
SFVEC2F m_leftDir;
SFVEC2F m_rightStart;
SFVEC2F m_rightEnd;
SFVEC2F m_rightEndMinusStart;
SFVEC2F m_rightDir;
float m_radius;
float m_radius_squared;
float m_width;
}; };
static const float s_min_dot = (FLT_EPSILON * 4.0f * FLT_EPSILON * 4.0f) ; static const float s_min_dot = (FLT_EPSILON * 4.0f * FLT_EPSILON * 4.0f) ;
/** /**
* @brief Segment_is_a_circle - check if segment start and end is very close to each other * Check if segment start and end is very close to each other.
* should used to check if the segment should be converted to a circle instead *
* @param aStart * This should used to check if the segment should be converted to a circle instead.
* @param aEnd *
* @return true is it is better to convert the segment to circle * @return true is it is better to convert the segment to circle
*/ */
inline bool Is_segment_a_circle( const SFVEC2F &aStart, const SFVEC2F &aEnd ) inline bool Is_segment_a_circle( const SFVEC2F &aStart, const SFVEC2F &aEnd )
@ -99,7 +99,7 @@ inline bool Is_segment_a_circle( const SFVEC2F &aStart, const SFVEC2F &aEnd )
const SFVEC2F vec = aEnd - aStart; const SFVEC2F vec = aEnd - aStart;
return (aStart == aEnd) || return (aStart == aEnd) ||
// This is the same as calc the lenght squared (without the sqrt) // This is the same as calc the length squared (without the sqrt)
// and compare with a small value // and compare with a small value
( glm::dot( vec, vec ) <= s_min_dot ); ( glm::dot( vec, vec ) <= s_min_dot );
} }

31
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/ctriangle2d.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -34,26 +34,26 @@
#include <wx/debug.h> #include <wx/debug.h>
#include <wx/glcanvas.h> // CALLBACK definition, needed on Windows #include <wx/glcanvas.h> // CALLBACK definition, needed on Windows
// alse needed on OSX to define __DARWIN__ // also needed on OSX to define __DARWIN__
#include <geometry/polygon_triangulation.h> #include <geometry/polygon_triangulation.h>
#include "../../../3d_fastmath.h" #include "../../../3d_fastmath.h"
CTRIANGLE2D::CTRIANGLE2D( CTRIANGLE2D::CTRIANGLE2D( const SFVEC2F& aV1, const SFVEC2F& aV2, const SFVEC2F& aV3,
const SFVEC2F& aV1, const SFVEC2F& aV2, const SFVEC2F& aV3, const BOARD_ITEM& aBoardItem ) const BOARD_ITEM& aBoardItem ) :
: COBJECT2D( OBJECT2D_TYPE::TRIANGLE, aBoardItem ) COBJECT2D( OBJECT2D_TYPE::TRIANGLE, aBoardItem )
{ {
p1 = aV1; p1 = aV1;
p2 = aV2; p2 = aV2;
p3 = aV3; p3 = aV3;
// Pre-Calc values // Pre-Calc values
m_inv_denominator = 1.0f / ( (p2.y - p3.y) * (p1.x - p3.x) + m_inv_denominator = 1.0f / ( ( p2.y - p3.y ) * ( p1.x - p3.x ) +
(p3.x - p2.x) * (p1.y - p3.y)); ( p3.x - p2.x ) * ( p1.y - p3.y ) );
m_p2y_minus_p3y = (p2.y - p3.y); m_p2y_minus_p3y = ( p2.y - p3.y );
m_p3x_minus_p2x = (p3.x - p2.x); m_p3x_minus_p2x = ( p3.x - p2.x );
m_p3y_minus_p1y = (p3.y - p1.y); m_p3y_minus_p1y = ( p3.y - p1.y );
m_p1x_minus_p3x = (p1.x - p3.x); m_p1x_minus_p3x = ( p1.x - p3.x );
m_bbox.Reset(); m_bbox.Reset();
m_bbox.Union( aV1 ); m_bbox.Union( aV1 );
@ -70,6 +70,7 @@ bool CTRIANGLE2D::Intersects( const CBBOX2D &aBBox ) const
{ {
if( !m_bbox.Intersects( aBBox ) ) if( !m_bbox.Intersects( aBBox ) )
return false; return false;
//!TODO: Optimize //!TODO: Optimize
return true; return true;
} }
@ -94,6 +95,7 @@ INTERSECTION_RESULT CTRIANGLE2D::IsBBoxInside( const CBBOX2D &aBBox ) const
{ {
if( !m_bbox.Intersects( aBBox ) ) if( !m_bbox.Intersects( aBBox ) )
return INTERSECTION_RESULT::MISSES; return INTERSECTION_RESULT::MISSES;
// !TODO: // !TODO:
return INTERSECTION_RESULT::MISSES; return INTERSECTION_RESULT::MISSES;
} }
@ -129,6 +131,9 @@ void Convert_shape_line_polygon_to_triangles( SHAPE_POLY_SET &aPolyList,
float aBiuTo3DunitsScale , float aBiuTo3DunitsScale ,
const BOARD_ITEM &aBoardItem ) const BOARD_ITEM &aBoardItem )
{ {
VECTOR2I a;
VECTOR2I b;
VECTOR2I c;
aPolyList.CacheTriangulation( false ); aPolyList.CacheTriangulation( false );
const double conver_d = (double)aBiuTo3DunitsScale; const double conver_d = (double)aBiuTo3DunitsScale;
@ -139,9 +144,6 @@ void Convert_shape_line_polygon_to_triangles( SHAPE_POLY_SET &aPolyList,
for( size_t i = 0; i < triPoly->GetTriangleCount(); i++ ) for( size_t i = 0; i < triPoly->GetTriangleCount(); i++ )
{ {
VECTOR2I a;
VECTOR2I b;
VECTOR2I c;
triPoly->GetTriangle( i, a, b, c ); triPoly->GetTriangle( i, a, b, c );
aDstContainer.Add( new CTRIANGLE2D( SFVEC2F( a.x * conver_d, aDstContainer.Add( new CTRIANGLE2D( SFVEC2F( a.x * conver_d,
@ -152,6 +154,5 @@ void Convert_shape_line_polygon_to_triangles( SHAPE_POLY_SET &aPolyList,
-c.y * conver_d ), -c.y * conver_d ),
aBoardItem ) ); aBoardItem ) );
} }
} }
} }

24
3d-viewer/3d_rendering/3d_render_raytracing/shapes2D/ctriangle2d.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -38,17 +38,6 @@
class CTRIANGLE2D : public COBJECT2D class CTRIANGLE2D : public COBJECT2D
{ {
private:
SFVEC2F p1;
SFVEC2F p2;
SFVEC2F p3;
float m_inv_denominator;
float m_p2y_minus_p3y;
float m_p3x_minus_p2x;
float m_p3y_minus_p1y;
float m_p1x_minus_p3x;
public: public:
CTRIANGLE2D ( const SFVEC2F &aV1, CTRIANGLE2D ( const SFVEC2F &aV1,
const SFVEC2F &aV2, const SFVEC2F &aV2,
@ -65,6 +54,17 @@ public:
bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override; bool Intersect( const RAYSEG2D &aSegRay, float *aOutT, SFVEC2F *aNormalOut ) const override;
INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override; INTERSECTION_RESULT IsBBoxInside( const CBBOX2D &aBBox ) const override;
bool IsPointInside( const SFVEC2F &aPoint ) const override; bool IsPointInside( const SFVEC2F &aPoint ) const override;
private:
SFVEC2F p1;
SFVEC2F p2;
SFVEC2F p3;
float m_inv_denominator;
float m_p2y_minus_p3y;
float m_p3x_minus_p2x;
float m_p3y_minus_p1y;
float m_p1x_minus_p3x;
}; };

12
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cbbox.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2017 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2017 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2017 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -105,12 +105,12 @@ void CBBOX::Reset()
void CBBOX::Union( const SFVEC3F &aPoint ) void CBBOX::Union( const SFVEC3F &aPoint )
{ {
// get the minimun value between the added point and the existent bounding box // get the minimum value between the added point and the existent bounding box
m_min.x = fminf( m_min.x, aPoint.x ); m_min.x = fminf( m_min.x, aPoint.x );
m_min.y = fminf( m_min.y, aPoint.y ); m_min.y = fminf( m_min.y, aPoint.y );
m_min.z = fminf( m_min.z, aPoint.z ); m_min.z = fminf( m_min.z, aPoint.z );
// get the maximun value between the added point and the existent bounding box // get the maximum value between the added point and the existent bounding box
m_max.x = fmaxf( m_max.x, aPoint.x ); m_max.x = fmaxf( m_max.x, aPoint.x );
m_max.y = fmaxf( m_max.y, aPoint.y ); m_max.y = fmaxf( m_max.y, aPoint.y );
m_max.z = fmaxf( m_max.z, aPoint.z ); m_max.z = fmaxf( m_max.z, aPoint.z );
@ -121,12 +121,12 @@ void CBBOX::Union( const CBBOX &aBBox )
{ {
wxASSERT( aBBox.IsInitialized() ); wxASSERT( aBBox.IsInitialized() );
// get the minimun value between the added bounding box and the existent bounding box // get the minimum value between the added bounding box and the existent bounding box
m_min.x = fmin( m_min.x, aBBox.m_min.x ); m_min.x = fmin( m_min.x, aBBox.m_min.x );
m_min.y = fmin( m_min.y, aBBox.m_min.y ); m_min.y = fmin( m_min.y, aBBox.m_min.y );
m_min.z = fmin( m_min.z, aBBox.m_min.z ); m_min.z = fmin( m_min.z, aBBox.m_min.z );
// get the maximun value between the added bounding box and the existent bounding box // get the maximum value between the added bounding box and the existent bounding box
m_max.x = fmax( m_max.x, aBBox.m_max.x ); m_max.x = fmax( m_max.x, aBBox.m_max.x );
m_max.y = fmax( m_max.y, aBBox.m_max.y ); m_max.y = fmax( m_max.y, aBBox.m_max.y );
m_max.z = fmax( m_max.z, aBBox.m_max.z ); m_max.z = fmax( m_max.z, aBBox.m_max.z );
@ -397,5 +397,5 @@ void CBBOX::ApplyTransformationAA( glm::mat4 aTransformMatrix )
void CBBOX::debug() const void CBBOX::debug() const
{ {
wxLogDebug( "min(%f, %f, %f) - max(%f, %f, %f)\n", m_min.x, m_min.y, m_min.z, wxLogDebug( "min(%f, %f, %f) - max(%f, %f, %f)\n", m_min.x, m_min.y, m_min.z,
m_max.x, m_max.y, m_max.z ); m_max.x, m_max.y, m_max.z );
} }

157
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cbbox.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -33,32 +33,28 @@
#include "../ray.h" #include "../ray.h"
/** /**
* CBBOX * Manage a bounding box defined by two SFVEC3F min max points.
* manages a bounding box defined by two SFVEC3F min max points.
*/ */
struct CBBOX struct CBBOX
{ {
public: public:
/** /**
* Constructor CBBOX * Create with default values a bounding box (not initialized)
* Create with default values a bounding box (not inizialized)
*/ */
CBBOX(); CBBOX();
/** /**
* Constructor CBBOX * Initialize a bounding box with a given point.
* Initialize a bounding box with a given point *
* @param aPbInit a point for the bounding box initialization * @param aPbInit a point for the bounding box initialization.
*/ */
explicit CBBOX( const SFVEC3F &aPbInit ); explicit CBBOX( const SFVEC3F &aPbInit );
/** /**
* Constructor CBBOX * Initialize a bounding box with a minimum and a maximum point.
* Initialize a bounding box with a minimon and a maximun point *
* @param aPbMin the minimun point to initialize the bounding box * @param aPbMin the minimum point to initialize the bounding box.
* @param aPbMax the maximun point to initialize the bounding box * @param aPbMax the maximum point to initialize the bounding box.
*/ */
CBBOX( const SFVEC3F &aPbMin, const SFVEC3F &aPbMax ); CBBOX( const SFVEC3F &aPbMin, const SFVEC3F &aPbMax );
@ -66,10 +62,10 @@ public:
/** /**
* Function Set * Set bounding box with new parameters.
* Set bounding box with new parameters *
* @param aPbMin the minimun point to initialize the bounding box * @param aPbMin the minimum point to initialize the bounding box.
* @param aPbMax the maximun point to initialize the bounding box * @param aPbMax the maximum point to initialize the bounding box.
*/ */
void Set( const SFVEC3F &aPbMin, const SFVEC3F &aPbMax ); void Set( const SFVEC3F &aPbMin, const SFVEC3F &aPbMax );
@ -80,177 +76,166 @@ public:
* @param aPbMin * @param aPbMin
* @param aPbMax * @param aPbMax
*/ */
void Set( const SFVEC3F &aPoint ); void Set( const SFVEC3F& aPoint );
/** /**
* Function Union * Recalculate the bounding box adding a point.
* recalculate the bounding box adding a point *
* @param aPoint the point to be bounded * @param aPoint the point to be bounded.
*/ */
void Union( const SFVEC3F &aPoint ); void Union( const SFVEC3F &aPoint );
/** /**
* Function Union * Recalculate the bounding box adding other bounding box.
* recalculate the bounding box adding other bounding box *
* @param aBBox the bounding box to be bounded * @param aBBox the bounding box to be bounded.
*/ */
void Union( const CBBOX &aBBox ); void Union( const CBBOX &aBBox );
/** /**
* Function Scale * Scales a bounding box by its center.
* scales a bounding box by its center *
* @param aScale scale factor to apply * @param aScale scale factor to apply.
*/ */
void Scale( float aScale ); void Scale( float aScale );
/** /**
* Function ScaleNextUp * Scale a bounding box to the next float representation making it larger.
* scales a bounding box to the next float representation making it larger
*/ */
void ScaleNextUp(); void ScaleNextUp();
/** /**
* Function ScaleNextDown * Scale a bounding box to the next float representation making it smaller.
* scales a bounding box to the next float representation making it smaller
*/ */
void ScaleNextDown(); void ScaleNextDown();
/** /**
* Function Intersects * Test if a bounding box intersects this box.
* test if a bounding box intersects this box *
* @param aBBox the bounding box to check if it intersects * @param aBBox the bounding box to check if it intersects.
*/ */
bool Intersects( const CBBOX &aBBox ) const; bool Intersects( const CBBOX &aBBox ) const;
/** /**
* Function Inside * Check if a point is inside this bounding box.
* check is a point is inside this bounding box *
* @param aPoint point to test * @param aPoint point to test.
*/ */
bool Inside( const SFVEC3F &aPoint ) const; bool Inside( const SFVEC3F &aPoint ) const;
/** /**
* Function ApplyTransformation * Apply a transformation matrix to the box points.
* apply a transformation matrix to the box points *
* @param aTransformMatrix matrix to apply to the points of the bounding box * @param aTransformMatrix matrix to apply to the points of the bounding box
*/ */
void ApplyTransformation( glm::mat4 aTransformMatrix ); void ApplyTransformation( glm::mat4 aTransformMatrix );
/** /**
* Function ApplyTransformationAA * Apply a transformation matrix to the box points and recalculate it
* apply a transformation matrix to the box points and recalculate it * to fit an axis aligned bounding box.
* to fit an axis aligned bounding box *
* @param aTransformMatrix matrix to apply to the points of the bounding box * @param aTransformMatrix matrix to apply to the points of the bounding box.
*/ */
void ApplyTransformationAA( glm::mat4 aTransformMatrix ); void ApplyTransformationAA( glm::mat4 aTransformMatrix );
/** /**
* Function Volume * Calculate the volume of a bounding box.
* calculate the volume of a bounding box *
* @return float - volume of this bounding box * @return float - volume of this bounding box.
*/ */
float Volume() const; float Volume() const;
/** /**
* Function debug * Output this CBBOX to the stdout.
* output to stdout
*/ */
void debug() const; void debug() const;
/** /**
* Function IsInitialized * Check if this bounding box is already initialized.
* check if this bounding box is already initialized *
* @return bool - return true if it was initialized, false if otherwise * @return bool - return true if it was initialized, false if otherwise.
*/ */
bool IsInitialized() const; bool IsInitialized() const;
/** /**
* Function Reset * Reset the bounding box to zero and de-initialized it.
* reset the bounding box to zero and de-initialized it
*/ */
void Reset(); void Reset();
/** /**
* Function GetCenter * Return the center point of the bounding box.
* return the center point of the bounding box *
* @return SFVEC3F - the position of the center of this bounding box * @return SFVEC3F - the position of the center of this bounding box.
*/ */
SFVEC3F GetCenter() const; SFVEC3F GetCenter() const;
/** /**
* Function GetCenter * Return the center point of the bounding box for one axis (0, 1 or 2).
* return the center point of the bounding box for one Axis (0, 1 or 2) *
* @return float - the position of the center of this bounding box for the axis * @return float - the position of the center of this bounding box for the axis
*/ */
float GetCenter( unsigned int aAxis ) const; float GetCenter( unsigned int aAxis ) const;
/** Function Offset /**
* * @return SFVEC3F - return the offset relative to max-min.
* @return SFVEC3F - return the offset relative to max-min
*/ */
SFVEC3F Offset( const SFVEC3F &p ) const; SFVEC3F Offset( const SFVEC3F &p ) const;
/** /**
* Function GetExtent * @return SFVEC3F - max-min.
* @return SFVEC3F - max-min
*/ */
const SFVEC3F GetExtent() const; const SFVEC3F GetExtent() const;
/** /**
* Function Min * Return the minimum vertex pointer.
* return the minimun vertex pointer *
* @return SFVEC3F - the minimun vertice position * @return SFVEC3F - the minimum vertex position.
*/ */
const SFVEC3F &Min() const { return m_min; } const SFVEC3F &Min() const { return m_min; }
/** /**
* Function Max * Return the maximum vertex pointer.
* return the maximum vertex pointer *
* @return SFVEC3F - the maximun vertice position * @return SFVEC3F - the maximum vertex position.
*/ */
const SFVEC3F &Max() const { return m_max; } const SFVEC3F &Max() const { return m_max; }
/** /**
* Function MaxDimension * @return the index of the max dimension (0=x, 1=y, 2=z).
* @return the index of the max dimention (0=x, 1=y, 2=z)
*/ */
unsigned int MaxDimension() const; unsigned int MaxDimension() const;
/** /**
* @brief GetMaxDimension * @return the max dimension.
* @return the max dimension
*/ */
float GetMaxDimension() const; float GetMaxDimension() const;
/** /**
* Function SurfaceArea * @return the surface are of the box.
* @return the surface are of the box
*/ */
float SurfaceArea() const; float SurfaceArea() const;
/** /**
* Function Intersect * @param aRay The ray to intersect the box.
* @param aRay = ray to intersect the box * @param t The distance point of the ray of the intersection (if true).
* @param t = distance point of the ray of the intersection (if true) * @return true if the ray hits the box.
* @return true if the ray hits the box
*/ */
bool Intersect( const RAY &aRay, float *t ) const; bool Intersect( const RAY &aRay, float *t ) const;
bool Intersect( const RAY &aRay ) const; bool Intersect( const RAY &aRay ) const;
/** /**
* Function Intersect - Useful for get the enter and exit position * Fetch the enter and exit position when a ray starts inside the bounding box.
* If the ray starts inside the bbox, it will return aOutHitt0 = 0.0 *
* @param aRay = ray to intersect the box * @param aRay The ray to intersect the box.
* @param aOutHitt0 = distance point of the ray of the intersection (if true) * @param aOutHitt0 The distance point of the ray of the intersection (if true).
* @param aOutHitt1 = distance point of the ray of the exit (if true) * @param aOutHitt1 The distance point of the ray of the exit (if true).
* @return true if the ray hits the box * @return true if the ray hits the box
*/ */
bool Intersect( const RAY &aRay, float *aOutHitt0, float *aOutHitt1 ) const; bool Intersect( const RAY &aRay, float *aOutHitt0, float *aOutHitt1 ) const;
private: private:
SFVEC3F m_min; ///< (12) point of the lower position of the bounding box SFVEC3F m_min; ///< (12) point of the lower position of the bounding box
SFVEC3F m_max; ///< (12) point of the higher position of the bounding box SFVEC3F m_max; ///< (12) point of the higher position of the bounding box
}; };

716
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cbbox_ray.cpp
View File

File diff suppressed because it is too large Load Diff

3
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/ccylinder.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -180,6 +180,7 @@ bool CVCYLINDER::Intersects( const CBBOX &aBBox ) const
return m_bbox.Intersects( aBBox ); return m_bbox.Intersects( aBBox );
} }
SFVEC3F CVCYLINDER::GetDiffuseColor( const HITINFO &aHitInfo ) const SFVEC3F CVCYLINDER::GetDiffuseColor( const HITINFO &aHitInfo ) const
{ {
(void)aHitInfo; // unused (void)aHitInfo; // unused

3
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/ccylinder.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -40,7 +40,6 @@ class CVCYLINDER : public COBJECT
public: public:
/** /**
* Constructor CVCYLINDER
* @param aCenterPoint = position of the vertical cylinder axis in the XY plane * @param aCenterPoint = position of the vertical cylinder axis in the XY plane
* @param aZmin = bottom position (Z axis) * @param aZmin = bottom position (Z axis)
* @param aZmax = top position (Z axis) * @param aZmax = top position (Z axis)

10
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cdummyblock.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -33,22 +33,22 @@
#include "cobject.h" #include "cobject.h"
/** /**
* A dummy block is used to fill the polygons. It will only will be intersepted * A dummy block is used to fill the polygons. It will only will be intercepted
* from top or from bottom * from top or from bottom.
*/ */
class CDUMMYBLOCK : public COBJECT class CDUMMYBLOCK : public COBJECT
{ {
public: public:
explicit CDUMMYBLOCK( const CBBOX &aBBox ); explicit CDUMMYBLOCK( const CBBOX &aBBox );
void SetColor( SFVEC3F aObjColor ) { m_diffusecolor = aObjColor; } void SetColor( SFVEC3F aObjColor ) { m_diffusecolor = aObjColor; }
// Imported from COBJECT // Imported from COBJECT
bool Intersect( const RAY &aRay, HITINFO &aHitInfo ) const override; bool Intersect( const RAY &aRay, HITINFO &aHitInfo ) const override;
bool IntersectP(const RAY &aRay , float aMaxDistance ) const override; bool IntersectP(const RAY &aRay , float aMaxDistance ) const override;
bool Intersects( const CBBOX &aBBox ) const override; bool Intersects( const CBBOX &aBBox ) const override;
SFVEC3F GetDiffuseColor( const HITINFO &aHitInfo ) const override; SFVEC3F GetDiffuseColor( const HITINFO &aHitInfo ) const override;
private: private:
SFVEC3F m_diffusecolor; SFVEC3F m_diffusecolor;
}; };

7
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/clayeritem.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -199,13 +199,12 @@ bool CLAYERITEM::Intersect( const RAY &aRay, HITINFO &aHitInfo ) const
else else
{ {
// At this point, the ray miss the two planes but it still // At this point, the ray miss the two planes but it still
// hits the box. It means that the rays are "(almost)paralell" // hits the box. It means that the rays are "(almost)parallel"
// to the planes, so must calc the intersection // to the planes, so must calc the intersection
} }
} }
} }
SFVEC3F boxHitPointStart = aRay.at( tBBoxStart ); SFVEC3F boxHitPointStart = aRay.at( tBBoxStart );
SFVEC3F boxHitPointEnd = aRay.at( tBBoxEnd ); SFVEC3F boxHitPointEnd = aRay.at( tBBoxEnd );
@ -431,7 +430,7 @@ bool CLAYERITEM::IntersectP( const RAY &aRay , float aMaxDistance ) const
else else
{ {
// At this point, the ray miss the two planes but it still // At this point, the ray miss the two planes but it still
// hits the box. It means that the rays are "(almost)paralell" // hits the box. It means that the rays are "(almost)parallel"
// to the planes, so must calc the intersection // to the planes, so must calc the intersection
} }
} }

9
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/clayeritem.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -36,11 +36,7 @@
class CLAYERITEM : public COBJECT class CLAYERITEM : public COBJECT
{ {
protected:
const COBJECT2D *m_object2d;
public: public:
CLAYERITEM( const COBJECT2D *aObject2D, float aZMin, float aZMax ); CLAYERITEM( const COBJECT2D *aObject2D, float aZMin, float aZMax );
void SetColor( SFVEC3F aObjColor ) { m_diffusecolor = aObjColor; } void SetColor( SFVEC3F aObjColor ) { m_diffusecolor = aObjColor; }
@ -51,6 +47,9 @@ public:
bool Intersects( const CBBOX &aBBox ) const override; bool Intersects( const CBBOX &aBBox ) const override;
SFVEC3F GetDiffuseColor( const HITINFO &aHitInfo ) const override; SFVEC3F GetDiffuseColor( const HITINFO &aHitInfo ) const override;
protected:
const COBJECT2D *m_object2d;
private: private:
SFVEC3F m_diffusecolor; SFVEC3F m_diffusecolor;
}; };

3
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cobject.cpp
View File

@ -36,6 +36,7 @@ COBJECT3D_STATS *COBJECT3D_STATS::s_instance = 0;
static const CBLINN_PHONG_MATERIAL s_defaultMaterial = CBLINN_PHONG_MATERIAL(); static const CBLINN_PHONG_MATERIAL s_defaultMaterial = CBLINN_PHONG_MATERIAL();
COBJECT::COBJECT( OBJECT3D_TYPE aObjType ) COBJECT::COBJECT( OBJECT3D_TYPE aObjType )
{ {
m_obj_type = aObjType; m_obj_type = aObjType;
@ -69,6 +70,6 @@ void COBJECT3D_STATS::PrintStats()
for( auto& objectType : objectTypeNames ) for( auto& objectType : objectTypeNames )
{ {
wxLogDebug( " %20s %u\n", objectType.second, wxLogDebug( " %20s %u\n", objectType.second,
m_counter[static_cast<int>( objectType.first )] ); m_counter[static_cast<int>( objectType.first )] );
} }
} }

51
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cobject.h
View File

@ -48,22 +48,9 @@ enum class OBJECT3D_TYPE
}; };
class COBJECT class COBJECT
{ {
protected:
CBBOX m_bbox;
SFVEC3F m_centroid;
OBJECT3D_TYPE m_obj_type;
const CMATERIAL *m_material;
BOARD_ITEM *m_boardItem;
// m_modelTransparency combines the material and model opacity
// 0.0 full opaque, 1.0 full transparent.
float m_modelTransparency;
public: public:
explicit COBJECT( OBJECT3D_TYPE aObjType ); explicit COBJECT( OBJECT3D_TYPE aObjType );
const void SetBoardItem( BOARD_ITEM *aBoardItem ) { m_boardItem = aBoardItem; } const void SetBoardItem( BOARD_ITEM *aBoardItem ) { m_boardItem = aBoardItem; }
@ -77,32 +64,29 @@ public:
const CMATERIAL *GetMaterial() const { return m_material; } const CMATERIAL *GetMaterial() const { return m_material; }
float GetModelTransparency() const { return m_modelTransparency; } float GetModelTransparency() const { return m_modelTransparency; }
void SetModelTransparency( float aModelTransparency ) { m_modelTransparency = aModelTransparency; } void SetModelTransparency( float aModelTransparency )
{
m_modelTransparency = aModelTransparency;
}
virtual SFVEC3F GetDiffuseColor( const HITINFO &aHitInfo ) const = 0; virtual SFVEC3F GetDiffuseColor( const HITINFO &aHitInfo ) const = 0;
virtual ~COBJECT() {} virtual ~COBJECT() {}
/** Function Intersects /**
* @brief Intersects - a.Intersects(b) ⇔ !a.Disjoint(b) ⇔ !(a ∩ b = ∅) * Intersects - a.Intersects(b) ⇔ !a.Disjoint(b) ⇔ !(a ∩ b = ∅).
*
* It intersects if the result intersection is not null * It intersects if the result intersection is not null
* @param aBBox
* @return
*/ */
virtual bool Intersects( const CBBOX &aBBox ) const = 0; virtual bool Intersects( const CBBOX &aBBox ) const = 0;
/** Functions Intersect /**
* @brief Intersect
* @param aRay
* @param aHitInfo
* @return true if the aRay intersects the object * @return true if the aRay intersects the object
*/ */
virtual bool Intersect( const RAY &aRay, HITINFO &aHitInfo ) const = 0; virtual bool Intersect( const RAY &aRay, HITINFO &aHitInfo ) const = 0;
/** Functions Intersect for shadow test /**
* @brief Intersect
* @param aRay
* @param aMaxDistance - max distance of the test * @param aMaxDistance - max distance of the test
* @return true if the aRay intersects the object * @return true if the aRay intersects the object
*/ */
@ -111,6 +95,18 @@ public:
const CBBOX &GetBBox() const { return m_bbox; } const CBBOX &GetBBox() const { return m_bbox; }
const SFVEC3F &GetCentroid() const { return m_centroid; } const SFVEC3F &GetCentroid() const { return m_centroid; }
protected:
CBBOX m_bbox;
SFVEC3F m_centroid;
OBJECT3D_TYPE m_obj_type;
const CMATERIAL *m_material;
BOARD_ITEM *m_boardItem;
// m_modelTransparency combines the material and model opacity
// 0.0 full opaque, 1.0 full transparent.
float m_modelTransparency;
}; };
@ -148,9 +144,8 @@ private:
COBJECT3D_STATS(){ ResetStats(); } COBJECT3D_STATS(){ ResetStats(); }
COBJECT3D_STATS( const COBJECT3D_STATS &old ); COBJECT3D_STATS( const COBJECT3D_STATS &old );
const COBJECT3D_STATS &operator=( const COBJECT3D_STATS &old ); const COBJECT3D_STATS &operator=( const COBJECT3D_STATS &old );
~COBJECT3D_STATS(){} ~COBJECT3D_STATS() {}
private:
unsigned int m_counter[static_cast<int>( OBJECT3D_TYPE::MAX )]; unsigned int m_counter[static_cast<int>( OBJECT3D_TYPE::MAX )];
static COBJECT3D_STATS *s_instance; static COBJECT3D_STATS *s_instance;

4
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/cplane.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -37,12 +37,10 @@
*/ */
class CXYPLANE : public COBJECT class CXYPLANE : public COBJECT
{ {
public: public:
explicit CXYPLANE( const CBBOX &aBBox ); explicit CXYPLANE( const CBBOX &aBBox );
/** /**
* Constructor CXYPLANE
* @param aCenterPoint = position of the center of the plane * @param aCenterPoint = position of the center of the plane
* @param aXSize = size by X axis * @param aXSize = size by X axis
* @param aYSize = size by Y axis * @param aYSize = size by Y axis

9
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/croundseg.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -29,6 +29,7 @@
#include "croundseg.h" #include "croundseg.h"
CROUNDSEG::CROUNDSEG( const CROUNDSEGMENT2D& aSeg2D, float aZmin, float aZmax ) CROUNDSEG::CROUNDSEG( const CROUNDSEGMENT2D& aSeg2D, float aZmin, float aZmax )
: COBJECT( OBJECT3D_TYPE::ROUNDSEG ), m_segment( aSeg2D.m_segment ) : COBJECT( OBJECT3D_TYPE::ROUNDSEG ), m_segment( aSeg2D.m_segment )
{ {
@ -60,7 +61,7 @@ CROUNDSEG::CROUNDSEG( const CROUNDSEGMENT2D& aSeg2D, float aZmin, float aZmax )
bool CROUNDSEG::Intersect( const RAY &aRay, HITINFO &aHitInfo ) const bool CROUNDSEG::Intersect( const RAY &aRay, HITINFO &aHitInfo ) const
{ {
// Top / Botton plane // Top / Bottom plane
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
float zPlanePos = aRay.m_dirIsNeg[2]? m_bbox.Max().z : m_bbox.Min().z; float zPlanePos = aRay.m_dirIsNeg[2]? m_bbox.Max().z : m_bbox.Min().z;
@ -279,7 +280,7 @@ bool CROUNDSEG::Intersect( const RAY &aRay, HITINFO &aHitInfo ) const
bool CROUNDSEG::IntersectP( const RAY &aRay, float aMaxDistance ) const bool CROUNDSEG::IntersectP( const RAY &aRay, float aMaxDistance ) const
{ {
// Top / Botton plane // Top / Bottom plane
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
const float zPlanePos = aRay.m_dirIsNeg[2]? m_bbox.Max().z : m_bbox.Min().z; const float zPlanePos = aRay.m_dirIsNeg[2]? m_bbox.Max().z : m_bbox.Min().z;
@ -434,7 +435,7 @@ bool CROUNDSEG::IntersectP( const RAY &aRay, float aMaxDistance ) const
bool CROUNDSEG::Intersects( const CBBOX &aBBox ) const bool CROUNDSEG::Intersects( const CBBOX &aBBox ) const
{ {
//!TODO: improove //!TODO: improve
return m_bbox.Intersects( aBBox ); return m_bbox.Intersects( aBBox );
} }

14
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/croundseg.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt> * Copyright (C) 2015-2016 Mario Luzeiro <mrluzeiro@ua.pt>
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -33,16 +33,9 @@
#include "cobject.h" #include "cobject.h"
#include "../shapes2D/croundsegment2d.h" #include "../shapes2D/croundsegment2d.h"
/**
*
*/
class CROUNDSEG : public COBJECT class CROUNDSEG : public COBJECT
{ {
public: public:
/**
* Constructor CROUNDSEG
*/
CROUNDSEG( const CROUNDSEGMENT2D &aSeg2D, float aZmin, float aZmax ); CROUNDSEG( const CROUNDSEGMENT2D &aSeg2D, float aZmin, float aZmax );
void SetColor( SFVEC3F aObjColor ) { m_diffusecolor = aObjColor; } void SetColor( SFVEC3F aObjColor ) { m_diffusecolor = aObjColor; }
@ -69,6 +62,7 @@ private:
SFVEC3F m_diffusecolor; SFVEC3F m_diffusecolor;
}; };
#if 0 #if 0
/** /**
* This is a object similar to a round segment but with a ring * This is a object similar to a round segment but with a ring
@ -77,9 +71,6 @@ private:
class COBLONGRING : public COBJECT class COBLONGRING : public COBJECT
{ {
public: public:
/**
* Constructor CROUNDSEG
*/
CROUNDSEG( const SFVEC2F &aStart, CROUNDSEG( const SFVEC2F &aStart,
const SFVEC2F &aEnd, const SFVEC2F &aEnd,
float aInnerRadius, float aInnerRadius,
@ -109,4 +100,5 @@ private:
float m_seglen_over_two_squared; float m_seglen_over_two_squared;
}; };
#endif #endif
#endif // _CROUNDSEG_H_ #endif // _CROUNDSEG_H_

6
3d-viewer/3d_rendering/3d_render_raytracing/shapes3D/ctriangle.h
View File

@ -39,16 +39,15 @@
/** /**
* A triangle object * A triangle object
*/ */
class CTRIANGLE : public COBJECT class CTRIANGLE : public COBJECT
{ {
public: public:
CTRIANGLE( const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3 ); CTRIANGLE( const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3 );
CTRIANGLE( const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3, CTRIANGLE( const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3,
const SFVEC3F &aFaceNormal ); const SFVEC3F &aFaceNormal );
CTRIANGLE( const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3, CTRIANGLE( const SFVEC3F &aV1, const SFVEC3F &aV2, const SFVEC3F &aV3,
const SFVEC3F &aN1, const SFVEC3F &aN2, const SFVEC3F &aN3 ); const SFVEC3F &aN1, const SFVEC3F &aN2, const SFVEC3F &aN3 );
void SetColor( const SFVEC3F &aColor ); void SetColor( const SFVEC3F &aColor );
@ -72,7 +71,6 @@ public:
private: private:
void pre_calc_const(); void pre_calc_const();
private:
SFVEC3F m_normal[3]; // 36 SFVEC3F m_normal[3]; // 36
SFVEC3F m_vertex[3]; // 36 SFVEC3F m_vertex[3]; // 36
SFVEC3F m_n; // 12 SFVEC3F m_n; // 12