Egalware/EgtGraphics
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
develop
EgtGraphics/SceneGeom.cpp
T
Dario Sassi 8611f15893 EgtGraphics : 
- aggiunta possibilità di forzare in ogni caso la visualizzazione di parti custom di un oggetto.
2023-11-22 20:22:10 +01:00

1011 lines
39 KiB
C++
Raw Permalink Blame History

//----------------------------------------------------------------------------
// EgalTech 2013-2021
//----------------------------------------------------------------------------
// File : SceneGeom.cpp Data : 11.03.21 Versione : 2.3c1
// Contenuto : Implementazione della gestione geometria della classe scena.
//
//
//
// Modifiche : 10.02.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "Scene.h"
#include "ObjOldGraphics.h"
#include "ObjNewGraphics.h"
#include "ObjMultiGraphics.h"
#include "EGrUtils.h"
#include "DllMain.h"
#include "/EgtDev/Include/EGkFrame3d.h"
#include "/EgtDev/Include/EGkGdbIterator.h"
#include "/EgtDev/Include/EGkGeoVector3d.h"
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkCurve.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
#include "/EgtDev/Include/EGkSurfBezier.h"
#include "/EgtDev/Include/EGkVolZmap.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EGkExtDimension.h"
#include "/EgtDev/Include/EGkGdbFunct.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EgtILogger.h"
using namespace std ;
//------------------------------ Local functions -----------------------------
static ObjEGrGraphics* CreateObjEGrGraphics( int nCount, bool bNewWay) ;
static bool CalcCurveTailMark( const Vector3d& vtRef, const PolyLine& plCrv, PolyLine& plMark) ;
static bool CalcCurveTipArrow( const Vector3d& vtRef, const PolyLine& plCrv, PolyLine& plArr) ;
static bool CalcCurveConnectingLines( const PolyLine& plCrv, const Vector3d& vtTh, bool bDense, PNTVECTOR& vPnt) ;
static bool CalcCurveJoints( const ICurve* pCurve, PNTVECTOR& vPnt) ;
//----------------------------------------------------------------------------
bool
Scene::UpdateExtension( void)
{
BBox3d b3Ext ;
if ( m_pGeomDB == nullptr || ! m_pGeomDB->GetLocalBBox( GDB_ID_ROOT, b3Ext, BBF_ONLY_VISIBLE))
return false ;
return SetExtension( b3Ext) ;
}
//----------------------------------------------------------------------------
bool
Scene::SetMark( Color colMark)
{
m_colMark = colMark ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::SetSelSurf( Color colSelSurf)
{
m_colSelSurf = colSelSurf ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::SetLineWidth( int nW)
{
nW = Clamp( nW, 1, 3) ;
switch ( nW) {
case 1 :
m_dLineWidth = 1 ;
m_dSelLineWidth = 2 ;
m_dMarkLineWidth = 5 ;
m_dPointSize = 3 ;
m_dSelPointSize = 5 ;
m_dMarkPointSize = 7 ;
break ;
case 2 :
m_dLineWidth = 2 ;
m_dSelLineWidth = 4 ;
m_dMarkLineWidth = 7 ;
m_dPointSize = 4 ;
m_dSelPointSize = 7 ;
m_dMarkPointSize = 9 ;
break ;
case 3 :
m_dLineWidth = 3 ;
m_dSelLineWidth = 6 ;
m_dMarkLineWidth = 9 ;
m_dPointSize = 5 ;
m_dSelPointSize = 9 ;
m_dMarkPointSize = 11 ;
break ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::DrawGroup( int nId, int nPass, const MdStMkCol& cParent)
{
// creo un iteratore
PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGeomDB)) ;
if ( IsNull( pIter))
return false ;
// recupero il gruppo
if ( ! pIter->GoTo( nId))
return false ;
// eseguo il disegno
return DrawGroup( *pIter, nPass, cParent) ;
}
//----------------------------------------------------------------------------
bool
Scene::DrawGroup( const IGdbIterator& iIter, int nPass, const MdStMkCol& cParent)
{
// creo un iteratore
PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGeomDB)) ;
if ( IsNull( pIter))
return false ;
// recupero il riferimento del gruppo
Frame3d frFrame ;
if ( ! iIter.GetGroupFrame( frFrame))
return false ;
// se non è identità, lo aggiungo sullo stack delle matrici MODELVIEW di OpenGL
bool bMatrix = ( frFrame.GetType() != Frame3d::TOP || ! frFrame.Orig().IsSmall()) ;
if ( bMatrix) {
glPushMatrix() ;
double Matrix[OGLMAT_DIM] ;
if ( FrameToOpenGlMatrix( frFrame, Matrix))
glMultMatrixd( Matrix) ;
}
// scandisco il gruppo
bool bOk = true ;
for ( bool bNext = pIter->GoToFirstInGroup( iIter) ;
bNext ;
bNext = pIter->GoToNext()) {
// leggo il tipo di oggetto
int nGdbType = pIter->GetGdbType() ;
// recupero e aggiorno il modo dell'oggetto
int nMode = GDB_MD_STD ;
pIter->GetMode( nMode) ;
nMode = ::CalcMode( nMode, cParent.nMode) ;
// recupero e aggiorno lo stato dell'oggetto
int nStat = GDB_ST_ON ;
pIter->GetStatus( nStat) ;
nStat = ::CalcStatus( nStat, cParent.nStat) ;
nStat = ::AdjustStatusWithMode( nStat, nMode) ;
// recupero e aggiorno la marcatura dell'oggetto
int nMark = GDB_MK_OFF ;
pIter->GetMark( nMark) ;
nMark = ::CalcMark( nMark, cParent.nMark) ;
// recupero e aggiorno il colore dell'oggetto
Color colObj = cParent.colObj ;
pIter->GetMaterial( colObj) ;
// se in modalità selezione, verifico sia selezionabile
bool bSel = true ;
if ( m_bSelect && UnselectableFind( pIter->GetId()))
bSel = false ;
// se oggetto geometrico
if ( nGdbType == GDB_TY_GEO) {
// se non nascosto e selezionabile, lo disegno
if ( nStat != GDB_ST_OFF && bSel) {
if ( ! DrawGeoObj( *pIter, nPass, MdStMkCol( nMode, nStat, nMark, colObj)))
bOk = false ;
}
}
// se gruppo
else if ( nGdbType == GDB_TY_GROUP) {
// se non nascosto e selezionabile, lo disegno
if ( nStat != GDB_ST_OFF && bSel) {
if ( ! DrawGroup( *pIter, nPass, MdStMkCol( nMode, nStat, nMark, colObj)))
bOk = false ;
}
}
}
// se necessario, ripristino lo stack delle matrici
if ( bMatrix)
glPopMatrix() ;
return bOk ;
}
//----------------------------------------------------------------------------
static const ISurfTriMesh*
GetSurfTriMeshAux( const IGeoObj* pGeoObj)
{
int nGeoType = pGeoObj->GetType() ;
switch ( nGeoType) {
case SRF_TRIMESH : return GetSurfTriMesh( pGeoObj) ;
case SRF_FLATRGN : return GetSurfFlatRegion( pGeoObj)->GetAuxSurf() ;
case SRF_BEZIER : return GetSurfBezier( pGeoObj)->GetAuxSurf() ;
default : return nullptr ;
}
}
//----------------------------------------------------------------------------
bool
Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
{
// recupero l'oggetto geometrico e il suo tipo
IGeoObj* pGeoObj = (const_cast<IGdbIterator*>(&iIter))->GetGeoObj() ;
if ( pGeoObj == nullptr)
return false ;
int nGeoType = pGeoObj->GetType() ;
// recupero eventuale parte custom
const IUserObj* pUserObj = iIter.GetUserObj() ;
// se non esiste grafica associata, la creo
if ( pGeoObj->GetObjGraphics() == nullptr) {
// oggetto grafico molteplice solo per Zmap o superfici che lo richiedono
int nCount = 0 ;
if ( nGeoType == VOL_ZMAP) {
const IVolZmap* pZmap = GetVolZmap( pGeoObj) ;
if ( pZmap != nullptr) {
if ( ( m_nShowZmap & ZSM_SURF) != 0)
nCount += 2 * pZmap->GetBlockCount() ;
if ( ( m_nShowZmap & ZSM_LINES) != 0 || ( m_nShowZmap & ZSM_NORMALS) != 0)
nCount += 1 ;
}
}
else if (( nGeoType & GEO_SURF) != 0) {
const ISurfTriMesh* pSTM = GetSurfTriMeshAux( pGeoObj) ;
if ( pSTM != nullptr && pSTM->GetMaxTFlag() > 0)
nCount = 2 ;
}
// nuova modalità grafica solo per superfici e testi con molti triangoli o solidi Zmap
const int N_MIN_TRIA_NEWWAY = 100 ;
bool bNewWay = false ;
if ( m_bNewWay) {
if ( ( nGeoType & GEO_SURF) != 0) {
const ISurfTriMesh* pSTM = GetSurfTriMeshAux( pGeoObj) ;
if ( pSTM != nullptr && pSTM->GetTriangleCount() > N_MIN_TRIA_NEWWAY)
bNewWay = true ;
}
else if ( ( nGeoType & GEO_VOLUME) != 0) {
bNewWay = true ;
}
else if ( nGeoType == EXT_TEXT) {
const ISurfTriMesh* pSTM = ( m_nShowText == TXT_FILL ? GetExtText( pGeoObj)->GetAuxSurf() : nullptr) ;
if ( pSTM != nullptr && pSTM->GetTriangleCount() > N_MIN_TRIA_NEWWAY)
bNewWay = true ;
}
}
ObjEGrGraphics* pGraphics = CreateObjEGrGraphics( nCount, bNewWay) ;
if ( pGraphics == nullptr)
return false ;
pGraphics->SetScene( this) ;
pGeoObj->SetObjGraphics( pGraphics) ;
}
// se la grafica associata non è valida la ricalcolo
ObjEGrGraphics* pGraphics = GetObjEGrGraphics( pGeoObj) ;
if ( ! pGraphics->IsValid()) {
const double ANG_TOL_GRAPH_DEG = 15 ;
// se vettore
if ( nGeoType == GEO_VECT3D) {
// recupero il vettore
const IGeoVector3d* pVector = GetGeoVector3d( pGeoObj) ;
if ( pVector == nullptr)
return false ;
// calcolo la grafica
pGraphics->Clear() ;
pGraphics->AddColor( siObj.colObj) ;
int nFactor, nPattern ;
if ( iIter.GetStipple( nFactor, nPattern) && nFactor != 0)
pGraphics->AddLineStipple( nFactor, nPattern) ;
PolyLine PL ;
if ( pVector->GetDrawWithArrowHead( 0.1, 10, PL))
pGraphics->AddPolyLine(PL) ;
else
pGraphics->AddPoint( pVector->GetBase()) ;
}
// se punto
else if ( nGeoType == GEO_PNT3D) {
// recupero il punto
const IGeoPoint3d* pPoint = GetGeoPoint3d( pGeoObj) ;
if ( pPoint == nullptr)
return false ;
// calcolo la grafica
pGraphics->Clear() ;
pGraphics->AddColor( siObj.colObj) ;
int nFactor, nPattern ;
if ( iIter.GetStipple( nFactor, nPattern) && nFactor != 0)
pGraphics->AddLineStipple( nFactor, nPattern) ;
pGraphics->AddPoint( pPoint->GetPoint()) ;
}
// se riferimento
else if ( nGeoType == GEO_FRAME3D) {
// recupero il riferimento
const IGeoFrame3d* pFrame = GetGeoFrame3d( pGeoObj) ;
if ( pFrame == nullptr)
return false ;
// aggiorno la grafica (colori speciali)
PolyLine plX, plY, plZ ;
pFrame->GetDrawWithArrowHeads( 40, 0.1, plX, plY, plZ) ;
pGraphics->Clear() ;
pGraphics->AddColor( RED) ;
pGraphics->AddPolyLine( plX) ;
pGraphics->AddColor( LIME) ;
pGraphics->AddPolyLine( plY) ;
pGraphics->AddColor( BLUE) ;
pGraphics->AddPolyLine( plZ) ;
}
// se curva
else if ( ( nGeoType & GEO_CURVE) != 0) {
// recupero la curva
const ICurve* pCurve = GetCurve( pGeoObj) ;
if ( pCurve == nullptr)
return false ;
// calcolo la grafica
PolyLine PL ;
pCurve->ApproxWithLines( EPS_SMALL, ANG_TOL_GRAPH_DEG, ICurve::APL_SPECIAL, PL) ;
pGraphics->Clear() ;
pGraphics->AddColor( siObj.colObj) ;
int nFactor, nPattern ;
if ( iIter.GetStipple( nFactor, nPattern) && nFactor != 0)
pGraphics->AddLineStipple( nFactor, nPattern) ;
pGraphics->AddPolyLine( PL) ;
// eventuali segni ausiliari (mark, frecce, ...)
Vector3d vtRef ;
if ( ! pCurve->GetExtrusion( vtRef) || vtRef.IsSmall())
vtRef = Z_AX ;
PolyLine PLM ;
if ( CalcCurveTailMark( vtRef, PL, PLM))
pGraphics->AddPolyLine( PLM, true) ;
PolyLine PLA ;
if ( CalcCurveTipArrow( vtRef, PL, PLA))
pGraphics->AddPolyLine( PLA, true) ;
PNTVECTOR vPnt ;
if ( CalcCurveJoints( pCurve, vPnt))
pGraphics->AddPoints( vPnt, true) ;
// eventuale spessore
double dTh ;
Vector3d vtExtr ;
if ( pCurve->GetExtrusion( vtExtr) && ! vtExtr.IsSmall() &&
pCurve->GetThickness( dTh) && abs( dTh) > EPS_SMALL) {
// segmenti di raccordo
PNTVECTOR vPnt ;
bool bDense = ( nGeoType == CRV_ARC || nGeoType == CRV_BEZIER) ;
if ( CalcCurveConnectingLines( PL, dTh * vtExtr, bDense, vPnt))
pGraphics->AddLines( vPnt) ;
// percorso traslato
PL.Translate( dTh * vtExtr) ;
pGraphics->AddPolyLine( PL) ;
}
}
// se superficie
else if ( ( nGeoType & GEO_SURF) != 0) {
// recupero la trimesh da visualizzare
const ISurfTriMesh* pSTM = GetSurfTriMeshAux( pGeoObj) ;
if ( pSTM == nullptr)
return false ;
// superficie con visualizzazione standard
if ( pSTM->GetMaxTFlag() == 0) {
// recupero il materiale
Material mMat ;
if ( ! iIter.GetCalcMaterial( mMat))
mMat.Set( m_colDef) ;
// pulisco
pGraphics->Clear() ;
// se ci sono triangoli
int nTria = pSTM->GetTriangleCount() ;
if ( nTria > 0) {
// assegno i materiali
pGraphics->AddColor( siObj.colObj) ; // per wireframe
pGraphics->AddMaterial( mMat.GetAmbient(), mMat.GetDiffuse(),
mMat.GetSpecular(), mMat.GetShininess()) ;
pGraphics->AddBackMaterial( GetSurfBackColor( mMat.GetDiffuse())) ;
// ciclo sui triangoli della superficie
pGraphics->StartTriangles( nTria) ;
Triangle3dEx Tria ;
int nId = pSTM->GetFirstTriangle( Tria) ;
while ( nId != SVT_NULL) {
// se visualizzazione avanzata : edge solo se boundary e normali ai vertici smussate
if ( m_bShowTriaAdvanced)
pGraphics->AddTriangle( Tria, Tria.GetTriFlags(), Tria.GetTriNormals()) ;
// altrimenti : tutti gli edge e normali ai vertici prendono quella del triangolo
else
pGraphics->AddTriangle( Tria, TriFlags3d(), TriNormals3d( Tria.GetN())) ;
nId = pSTM->GetNextTriangle( nId, Tria) ;
}
pGraphics->EndTriangles() ;
}
}
// altrimenti superficie con due colori
else {
// numero di colori
const int STM_COL = 2 ;
// definizione materiali
Material mMat[STM_COL] ;
Color cCol[STM_COL] ;
// recupero il materiale principale
cCol[0] = siObj.colObj ;
if ( ! iIter.GetCalcMaterial( mMat[0]))
mMat[0].Set( m_colDef) ;
// secondo materiale per parti modificate (tonalità spostata di +22.5 deg)
cCol[1] = cCol[0] ;
mMat[1] = mMat[0] ;
HSV hsv = GetHSVFromColor( siObj.colObj) ;
if ( hsv.dSat > EPS_ZERO)
hsv.dHue += ANG_RIGHT / 4 ;
else
hsv.dVal = 1 - hsv.dVal ;
cCol[1] = GetColorFromHSV( hsv) ;
mMat[1].Set( cCol[1]) ;
// conto i triangoli per tipo (TFlag == 0 e altri)
int nTri[STM_COL] = { 0, 0} ;
nTri[0] = pSTM->GetTriangleCount( 0) ;
nTri[1] = pSTM->GetTriangleCount() - nTri[0] ;
// Ciclo sui colori
for ( int j = 0 ; j < STM_COL ; ++ j) {
// Imposto indice blocco corrente
pGraphics->SetCurrent( j) ;
// lo pulisco
pGraphics->Clear() ;
// se non ci sono triangoli, passo oltre
if ( nTri[j] == 0)
continue ;
// assegno materiali
pGraphics->AddColor( cCol[j]) ; // per wireframe
pGraphics->AddMaterial( mMat[j].GetAmbient(), mMat[j].GetDiffuse(),
mMat[j].GetSpecular(), mMat[j].GetShininess()) ;
pGraphics->AddBackMaterial( GetSurfBackColor( mMat[j].GetDiffuse())) ;
// ciclo sui triangoli della superficie
pGraphics->StartTriangles( nTri[j]) ;
Triangle3dEx Tria ;
int nId = pSTM->GetFirstTriangle( Tria) ;
while ( nId != SVT_NULL) {
if ( ( j == 0 && Tria.GetGrade() == 0) || ( j == 1 && Tria.GetGrade() != 0)) {
// se visualizzazione avanzata : edge solo se boundary e normali ai vertici smussate
if ( m_bShowTriaAdvanced)
pGraphics->AddTriangle( Tria, Tria.GetTriFlags(), Tria.GetTriNormals()) ;
// altrimenti : tutti gli edge e normali ai vertici prendono quella del triangolo
else
pGraphics->AddTriangle( Tria, TriFlags3d(), TriNormals3d( Tria.GetN())) ;
}
nId = pSTM->GetNextTriangle( nId, Tria) ;
}
pGraphics->EndTriangles() ;
}
}
}
// se Zmap
else if ( nGeoType == VOL_ZMAP) {
// recupero il solido Zmap
const IVolZmap* pZmap = GetVolZmap( pGeoObj) ;
if ( pZmap == nullptr)
return false ;
// numero di blocchi
int nCount = 0 ;
// numero di colori
const int ZMAP_COL = 2 ;
// indicazione se tridexel
bool bIsTriDexel = pZmap->IsTriDexel() ;
// se triangoli da disegnare
if ( ( m_nShowZmap & ZSM_SURF) != 0) {
// definizione materiali
Material mMat[ZMAP_COL] ;
Color cCol[ZMAP_COL] ;
// recupero il materiale principale
cCol[0] = siObj.colObj ;
if ( ! iIter.GetCalcMaterial( mMat[0]))
mMat[0].Set( m_colDef) ;
// secondo materiale per parti lavorate (tonalità spostata di +22.5 deg)
cCol[1] = cCol[0] ;
mMat[1] = mMat[0] ;
// se richiesto diverso
if ( ( m_nShowZmap & ZSM_COLORS) != 0) {
HSV hsv = GetHSVFromColor( siObj.colObj) ;
if ( hsv.dSat > EPS_ZERO)
hsv.dHue += ANG_RIGHT / 4 ;
else
hsv.dVal = 1 - hsv.dVal ;
cCol[1] = GetColorFromHSV( hsv) ;
mMat[1].Set( cCol[1]) ;
}
// Ciclo sui blocchi
nCount = pZmap->GetBlockCount() ;
for ( int i = 0 ; i < nCount ; ++ i) {
// Se blocco già aggiornato, vado oltre
pGraphics->SetCurrent( ZMAP_COL * i) ;
if ( pZmap->GetBlockUpdatingCounter( i) <= pGraphics->GetCounter())
continue ;
// Recupero i triangoli del blocco
TRIA3DEXVECTOR vTria ;
pZmap->GetBlockTriangles( i, vTria) ;
// conto i triangoli per tipo (Flag == 0 e altri)
int nTri[ZMAP_COL] = { 0, 0} ;
for ( const auto& Tria : vTria) {
if ( Tria.GetGrade() == 0)
++ nTri[0] ;
else
++ nTri[1] ;
}
// Ciclo sui colori
for ( int j = 0 ; j < ZMAP_COL ; ++ j) {
// Imposto indice blocco corrente
pGraphics->SetCurrent( ZMAP_COL * i + j) ;
// lo pulisco
pGraphics->Clear() ;
// se non ci sono triangoli, passo oltre
if ( nTri[j] == 0)
continue ;
// assegno materiali
pGraphics->AddColor( cCol[j]) ; // per wireframe
pGraphics->AddMaterial( mMat[j].GetAmbient(), mMat[j].GetDiffuse(),
mMat[j].GetSpecular(), mMat[j].GetShininess()) ;
pGraphics->AddBackMaterial( GetSurfBackColor( mMat[j].GetDiffuse())) ;
// passo i triangoli alla grafica
pGraphics->StartTriangles( nTri[j]) ;
for ( const auto& Tria : vTria) {
if ( ( j == 0 && Tria.GetGrade() != 0) || ( j == 1 && Tria.GetGrade() == 0))
continue ;
if ( m_bShowTriaAdvanced && bIsTriDexel)
pGraphics->AddTriangle( Tria, Tria.GetTriFlags(), Tria.GetTriNormals()) ;
else
pGraphics->AddTriangle( Tria, TriFlags3d(), TriNormals3d( Tria.GetN())) ;
}
pGraphics->EndTriangles() ;
// assegno contatore di aggiornamenti
pGraphics->SetCounter( pZmap->GetBlockUpdatingCounter( i)) ;
}
}
}
// visualizzazione spilloni e normali (sempre nell'ultimo blocco)
if ( ( m_nShowZmap & ZSM_LINES) != 0 || ( m_nShowZmap & ZSM_NORMALS) != 0) {
// imposto indice blocco corrente
pGraphics->SetCurrent( ZMAP_COL * nCount) ;
// lo pulisco
pGraphics->Clear() ;
// ciclo sui tre gruppi di spilloni
int nKmin = ( m_nShowZmap & ZSM_LINES) != 0 ? 0 : 3 ;
int nKmax = ( m_nShowZmap & ZSM_NORMALS) != 0 ? 6 : 3 ;
Color vCol[6] = {BLUE, RED, GREEN, BLUE, RED, GREEN} ;
for ( int k = nKmin ; k < nKmax ; ++ k) {
pGraphics->AddColor( vCol[k]) ;
pGraphics->AddMaterial( vCol[k], vCol[k], vCol[k], 10) ;
pGraphics->AddBackMaterial( vCol[k]) ;
PNTVECTOR vPnt ;
for ( int i = 0 ; ; ++ i) {
bool bOutBreak = false ;
for ( int j = 0 ; ; ++ j) {
POLYLINELIST lstPL ;
if ( pZmap->GetDexelLines( k, j, i, lstPL)) {
for ( const auto& PL : lstPL) {
Point3d ptS, ptE ;
bool Found = PL.GetFirstLine( ptS, ptE) ;
while ( Found) {
vPnt.emplace_back( ptS) ;
vPnt.emplace_back( ptE) ;
Found = PL.GetNextLine( ptS, ptE) ;
}
}
}
else {
if ( j == 0)
bOutBreak = true ;
break ;
}
}
if ( bOutBreak)
break ;
}
if ( vPnt.size() > 0)
pGraphics->AddLines( vPnt) ;
}
}
}
// se testo
else if ( nGeoType == EXT_TEXT) {
// recupero il testo
const IExtText* pTXT = GetExtText( pGeoObj) ;
if ( pTXT == nullptr)
return false ;
// calcolo la grafica
const ISurfTriMesh* pSTM = ( m_nShowText == TXT_FILL ? pTXT->GetAuxSurf() : nullptr) ;
if ( pSTM != nullptr) {
// recupero il materiale
Material mMat ;
if ( ! iIter.GetCalcMaterial( mMat))
mMat.Set( m_colDef) ;
// lo pulisco
pGraphics->Clear() ;
// se ci sono triangoli
int nTria = pSTM->GetTriangleCount() ;
if ( nTria > 0) {
// assegno materiali
pGraphics->AddColor( siObj.colObj) ; // per wireframe
pGraphics->AddMaterial( mMat.GetAmbient(), mMat.GetDiffuse(),
mMat.GetSpecular(), mMat.GetShininess()) ;
pGraphics->AddBackMaterial( GetSurfBackColor( mMat.GetDiffuse())) ;
// ciclo sui triangoli della superficie
pGraphics->StartTriangles( nTria) ;
Triangle3dEx Tria ;
int nId = pSTM->GetFirstTriangle( Tria) ;
while ( nId != SVT_NULL) {
// se visualizzazione avanzata : edge solo se boundary e normali ai vertici smussate
if ( m_bShowTriaAdvanced)
pGraphics->AddTriangle( Tria, Tria.GetTriFlags(), Tria.GetTriNormals()) ;
// altrimenti : tutti gli edge e normali ai vertici prendono quella del triangolo
else
pGraphics->AddTriangle( Tria, TriFlags3d(), TriNormals3d( Tria.GetN())) ;
nId = pSTM->GetNextTriangle( nId, Tria) ;
}
pGraphics->EndTriangles() ;
}
}
else {
POLYLINELIST lstPL ;
pTXT->ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_GRAPH_DEG, lstPL) ;
pGraphics->Clear() ;
pGraphics->AddColor( siObj.colObj) ;
for ( const auto& PL : lstPL)
pGraphics->AddPolyLine( PL) ;
}
}
// se quota
else if ( nGeoType == EXT_DIMENSION) {
// recupero la quota
const IExtDimension* pDim = GetExtDimension( pGeoObj) ;
if ( pDim == nullptr)
return false ;
// calcolo la grafica
POLYLINELIST lstPL ;
pDim->ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_GRAPH_DEG, lstPL) ;
pGraphics->Clear() ;
pGraphics->AddColor( siObj.colObj) ;
for ( const auto& PL : lstPL)
pGraphics->AddPolyLine( PL) ;
}
// se esiste parte custom
if ( pUserObj != nullptr) {
POLYLINELIST lstPL ;
if ( pUserObj->GetDrawPolyLines( lstPL)) {
for ( const auto& PL : lstPL)
pGraphics->AddPolyLine( PL, ( PL.GetTempProp() == 0)) ;
}
}
}
// se richiesto, visualizzo la grafica associata
bool bShowAux = false ;
if ( (( nGeoType & GEO_CURVE) != 0 || pUserObj != nullptr) && m_bShowCurveDirection)
bShowAux = true ;
// verifico se oggetto con superficie
bool bSurf = (( nGeoType & ( GEO_SURF | GEO_VOLUME)) != 0) ;
bool bGenSurf = ( bSurf || ( nGeoType == EXT_TEXT && m_nShowText == TXT_FILL && GetExtText( pGeoObj)->GetAuxSurf() != nullptr)) ;
// recupero il valore di opacità (solo per le superfici e i solidi può esserci trasparenza)
int nAlpha = siObj.colObj.GetIntAlpha() ;
// salto in ogni caso le superfici e i solidi completamente trasparenti
if ( nAlpha == 0 && bGenSurf)
return true ;
// se hiddenline e non selezione
if ( m_nShowMode == SM_HIDDENLINE && ! m_bSelect) {
// in prima passata disegno solo le superfici opache
if ( nPass == 1 && ( ! bGenSurf || nAlpha <= ALPHA_LIM))
return true ;
}
// se shading e non modalità selezione
bool bSurfSha = false ;
if ( m_nShowMode == SM_SHADING && ! m_bSelect) {
// in prima passata disegno solo le superfici opache e metto in un vettore quelle semitrasparenti
if ( nPass == 1) {
if ( ! bGenSurf)
return true ;
else {
if ( nAlpha > ALPHA_LIM)
bSurfSha = true ;
else {
// recupero matrice MODELVIEW corrente
GLdouble ModelView[ OGLMAT_DIM] ;
glGetDoublev( GL_MODELVIEW_MATRIX, ModelView) ;
Frame3d frModView ;
OpenGlMatrixToFrame( ModelView, frModView) ;
// recupero il box dell'oggetto e lo porto nel riferimento MODELVIEW
BBox3d b3Box ;
pGraphics->GetLocalBBox( b3Box) ;
b3Box.ToGlob( frModView) ;
// inserisco i dati nel vettore
m_vAlphaSurf.emplace_back( frModView, pGraphics, siObj.nStat, siObj.nMark,
bSurf, nAlpha, bShowAux, b3Box.GetMin().z, b3Box.GetMax().z) ;
return true ;
}
}
}
// in seconda passata disegno solo dimensioni 0 e curve
if ( nPass == 2 && bGenSurf)
return true ;
}
// se in selezione
if ( m_bSelect) {
// vaglio per il filtro di tipo
if ( ( nGeoType & m_nObjFilterForSelect) == 0)
return true ;
// carico il nome
glLoadName( iIter.GetId()) ;
}
// eventuale texture
string sTxrName ;
if ( iIter.GetTextureName( sTxrName)) {
// rendo corrente la texture
GLuint texName ;
double dTextDimS ;
double dTextDimT ;
if ( m_TextMgr.GetTextureData( sTxrName, texName, dTextDimS, dTextDimT)) {
glEnable( GL_TEXTURE_2D) ;
glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ;
glBindTexture( GL_TEXTURE_2D, texName) ;
}
// se esiste parte custom, eventuale recupero dimensioni aggiornate
if ( pUserObj != nullptr)
pUserObj->GetDimensions( dTextDimS, dTextDimT) ;
// recupero il riferimento della texture
Frame3d frTxr ;
iIter.GetTextureFrame( frTxr) ;
// creo piano per la S
GLfloat PlaneS[4] { GLfloat( frTxr.VersX().x / dTextDimS),
GLfloat( frTxr.VersX().y / dTextDimS),
GLfloat( frTxr.VersX().z / dTextDimS),
GLfloat( -frTxr.VersX() * ( frTxr.Orig() - ORIG) / dTextDimS)} ;
// creo piano per la T
GLfloat PlaneT[4] { GLfloat( frTxr.VersY().x / dTextDimT),
GLfloat( frTxr.VersY().y / dTextDimT),
GLfloat( frTxr.VersY().z / dTextDimT),
GLfloat( -frTxr.VersY() * ( frTxr.Orig() - ORIG) / dTextDimT)} ;
// setto generazione automatica coordinate S e T per texture
glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR) ;
glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR) ;
glTexGenfv( GL_S, GL_OBJECT_PLANE, PlaneS) ;
glTexGenfv( GL_T, GL_OBJECT_PLANE, PlaneT) ;
glEnable( GL_TEXTURE_GEN_S) ;
glEnable( GL_TEXTURE_GEN_T) ;
}
// eseguo visualizzazione
bool bOk = pGraphics->Draw( siObj.nStat, siObj.nMark, bSurfSha, bSurf, nAlpha, bShowAux) ;
// disabilito textures
glDisable( GL_TEXTURE_GEN_S) ;
glDisable( GL_TEXTURE_GEN_T) ;
glDisable( GL_TEXTURE_2D) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
Scene::DrawAlphaSurfVector( void)
{
// ordino vettore in senso crescente secondo Zmax (asse Z punta verso osservatore)
sort( m_vAlphaSurf.begin(), m_vAlphaSurf.end(),
[]( const AlphaSurf& a, const AlphaSurf&b) { return a.dZmax < b.dZmax ; }) ;
// eseguo visualizzazione
for ( const auto& AlphaSurf : m_vAlphaSurf) {
// imposto matrice MODELVIEW
double Matrix[OGLMAT_DIM] ;
FrameToOpenGlMatrix( AlphaSurf.frModView, Matrix) ;
glPushMatrix() ;
glLoadMatrixd( Matrix) ;
// eseguo visualizzazione
bool bOk = AlphaSurf.pGraph->Draw( AlphaSurf.nStat, AlphaSurf.nMark, true,
AlphaSurf.bSurf, AlphaSurf.nAlpha, AlphaSurf.bShowAux) ;
// ripristino matrice
glPopMatrix() ;
// in caso di errore, esco
if ( ! bOk)
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::DeleteObjGraphicsGroup( int nId)
{
// creo un iteratore
PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGeomDB)) ;
if ( IsNull( pIter))
return false ;
// scandisco il gruppo
bool bNext = pIter->GoToFirstInGroup( nId) ;
while ( bNext) {
// leggo il tipo di nodo
int nGdbType = pIter->GetGdbType() ;
// se oggetto geometrico
if ( nGdbType == GDB_TY_GEO) {
// lo recupero
IGeoObj* pGeoObj = pIter->GetGeoObj() ;
if ( pGeoObj == nullptr)
return false ;
// ne cancello l'eventuale parte grafica
ObjEGrGraphics* pGraph = GetObjEGrGraphics( pGeoObj) ;
if ( pGraph != nullptr && pGraph->GetScene() == this)
pGeoObj->SetObjGraphics( nullptr) ;
}
// se gruppo
else if ( nGdbType == GDB_TY_GROUP) {
// ripeto sugli oggetti dello stesso
if ( ! DeleteObjGraphicsGroup( pIter->GetId()))
return false ;
}
// passo al successivo
bNext = pIter->GoToNext() ;
}
return true ;
}
//------------------------------ Local functions -----------------------------
//----------------------------------------------------------------------------
static ObjEGrGraphics*
CreateObjEGrGraphics( int nCount, bool bNewWay)
{
if ( nCount > 1)
return ( new( nothrow) ObjMultiGraphics( nCount, bNewWay)) ;
else if ( bNewWay)
return ( new( nothrow) ObjNewGraphics) ;
else
return ( new( nothrow) ObjOldGraphics) ;
}
//----------------------------------------------------------------------------
static bool
CalcCurveTailMark( const Vector3d& vtRef, const PolyLine& plCrv, PolyLine& plMark)
{
// pulisco la polilinea per il segno
plMark.Clear() ;
// verifico effettiva esistenza della polilinea approssimante la curva
if ( plCrv.GetLineNbr() < 1)
return false ;
// dimensioni limite traverso
const double MAX_LEN_TR = 6 ;
const double MIN_LEN_TR = 0.1 ;
// recupero dati primo tratto della curva
Point3d ptTail, ptP ;
if ( ! plCrv.GetFirstLine( ptTail, ptP))
return false ;
Vector3d vtDir = ptP - ptTail ;
double dLen = vtDir.Len() ;
if ( dLen < EPS_SMALL)
return false ;
vtDir /= dLen ;
// se molto piccolo, cerco di allungarmi senza deviare troppo
while ( dLen < MAX_LEN_TR) {
Point3d ptP1, ptP2 ;
if ( ! plCrv.GetNextLine( ptP1, ptP2))
break ;
Vector3d vtNxDir = ptP2 - ptP1 ;
vtNxDir.Normalize() ;
if ( ( vtDir * vtNxDir) > cos( 30 * DEGTORAD))
dLen = (ptP1 - ptTail).Len() ;
else
break ;
}
// recupero lunghezza del percorso
double dLenRef = 0 ;
plCrv.GetApproxLength( dLenRef) ;
// lunghezza della freccia
// calcolo dimensioni traverso
const double TR_COEFF = 0.6 ;
const double LEN_COEFF = 0.15 ;
double dLenTr = TR_COEFF * min( LEN_COEFF * dLenRef, dLen) ;
if ( dLenTr > MAX_LEN_TR)
dLenTr = MAX_LEN_TR ;
else if ( dLenTr < MIN_LEN_TR)
dLenTr = MIN_LEN_TR ;
// disegno traverso
Frame3d frF ;
if ( frF.Set( ptTail, vtDir, vtRef)) {
Point3d ptP0 = GetToGlob( ORIG + Vector3d( 0, 0.5 * dLenTr, 0), frF) ;
plMark.AddUPoint( 0, ptP0) ;
Point3d ptP1 = GetToGlob( ORIG + Vector3d( 0, - 0.5 * dLenTr, 0), frF) ;
plMark.AddUPoint( 1, ptP1) ;
}
else {
frF.Set( ptTail, vtDir) ;
Point3d ptP0 = GetToGlob( ORIG + Vector3d( - 0.5 * dLenTr, - 0.5 * dLenTr, 0), frF) ;
plMark.AddUPoint( 0, ptP0) ;
Point3d ptP1 = GetToGlob( ORIG + Vector3d( 0.5 * dLenTr, - 0.5 * dLenTr, 0), frF) ;
plMark.AddUPoint( 1, ptP1) ;
Point3d ptP2 = GetToGlob( ORIG + Vector3d( 0.5 * dLenTr, 0.5 * dLenTr, 0), frF) ;
plMark.AddUPoint( 2, ptP2) ;
Point3d ptP3 = GetToGlob( ORIG + Vector3d( - 0.5 * dLenTr, 0.5 * dLenTr, 0), frF) ;
plMark.AddUPoint( 3, ptP3) ;
// punto di chiusura coincidente con il primo
plMark.AddUPoint( 4, ptP0) ;
}
return true ;
}
//----------------------------------------------------------------------------
static bool
CalcCurveTipArrow( const Vector3d& vtRef, const PolyLine& plCrv, PolyLine& plArr)
{
// pulisco la polilinea per la freccia
plArr.Clear() ;
// verifico effettiva esistenza della polilinea approssimante la curva
if ( plCrv.GetLineNbr() < 1)
return false ;
// dimensioni freccia limite
const double MAX_LEN_ARR = 10.0 ;
const double MIN_LEN_ARR = 0.1 ;
// recupero dati ultimo tratto della curva
Point3d ptTip, ptP ;
if ( ! plCrv.GetLastLine( ptP, ptTip))
return false ;
Vector3d vtDir = ptTip - ptP ;
double dLen = vtDir.Len() ;
if ( dLen < EPS_SMALL)
return false ;
vtDir /= dLen ;
// se molto piccolo, cerco di allungarmi senza deviare troppo
while ( dLen < MAX_LEN_ARR) {
Point3d ptP1, ptP2 ;
if ( ! plCrv.GetPrevLine( ptP1, ptP2))
break ;
Vector3d vtPrDir = ptP2 - ptP1 ;
vtPrDir.Normalize() ;
if ( ( vtDir * vtPrDir) > cos( 30 * DEGTORAD))
dLen = (ptTip - ptP1).Len() ;
else
break ;
}
// recupero lunghezza del percorso
double dLenRef = 0 ;
plCrv.GetApproxLength( dLenRef) ;
// lunghezza della freccia
const double LEN_COEFF = 0.15 ;
double dLenArr = min( LEN_COEFF * dLenRef, dLen) ;
if ( dLenArr > MAX_LEN_ARR)
dLenArr = MAX_LEN_ARR ;
else if ( dLenArr < MIN_LEN_ARR)
dLenArr = MIN_LEN_ARR ;
// disegno freccia
const double A_WIDTH_COEFF = 0.3 ;
Frame3d frF ;
if ( ! frF.Set( ptTip, vtDir, vtRef))
frF.Set( ptTip, vtDir) ;
plArr.AddUPoint( 0, ptTip) ;
Point3d ptP1 = GetToGlob( ORIG + Vector3d( 0, A_WIDTH_COEFF, -1) * dLenArr, frF) ;
plArr.AddUPoint( 1, ptP1) ;
Point3d ptP2 = GetToGlob( ORIG + Vector3d( 0, - A_WIDTH_COEFF, -1) * dLenArr, frF) ;
plArr.AddUPoint( 2, ptP2) ;
plArr.AddUPoint( 3, ptTip) ;
return true ;
}
//----------------------------------------------------------------------------
static bool
CalcCurveConnectingLines( const PolyLine& plCrv, const Vector3d& vtTh, bool bDense, PNTVECTOR& vPnt)
{
// assegno coefficiente
double dDelta = ( bDense ? 0.25 : 0.5) ;
// ciclo per creare i segmenti di raccordo
double dU, dUprev = - dDelta ;
vPnt.reserve( 5) ;
for ( bool bFound = plCrv.GetFirstU( dU) ; bFound ; bFound = plCrv.GetNextU( dU)) {
if ( ( dU - dUprev) > dDelta - EPS_PARAM || fmod( dU, 1.) < EPS_PARAM) {
Point3d ptP ;
plCrv.GetCurrPoint( ptP) ;
vPnt.push_back( ptP) ;
ptP += vtTh ;
vPnt.push_back( ptP) ;
dUprev = dU ;
}
}
return true ;
}
//----------------------------------------------------------------------------
static bool
CalcCurveJoints( const ICurve* pCurve, PNTVECTOR& vPnt)
{
// pulisco il vettore dei punti
vPnt.clear() ;
// recupero il dominio della curva
double dParS = 0, dParE = 1 ;
pCurve->GetDomain( dParS, dParE) ;
// recupero i punti intermedi
for ( double dPar = dParS + 1 ; dPar < dParE - EPS_PARAM ; dPar += 1) {
Point3d ptP ;
if ( pCurve->GetPointD1D2( dPar, ICurve::FROM_MINUS, ptP))
vPnt.push_back( ptP) ;
}
return true ;
}
Reference in New Issue View Git Blame Copy Permalink