Egalware/EgtGraphics
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: Egalware/EgtGraphics:master
Branches Tags
Egalware/EgtGraphics:master Egalware/EgtGraphics:Cube Egalware/EgtGraphics:develop Egalware/EgtGraphics:ThreeJS
Egalware/EgtGraphics:AutoSave_2024/10/01 Egalware/EgtGraphics:AutoSave_2024/03/08 Egalware/EgtGraphics:AutoSave_2024/02/02
...
pull from: Egalware/EgtGraphics:Cube
Branches Tags
Egalware/EgtGraphics:master Egalware/EgtGraphics:Cube Egalware/EgtGraphics:develop Egalware/EgtGraphics:ThreeJS
Egalware/EgtGraphics:AutoSave_2024/10/01 Egalware/EgtGraphics:AutoSave_2024/03/08 Egalware/EgtGraphics:AutoSave_2024/02/02

12 Commits
master ... Cube

Author SHA1 Message Date
Riccardo Elitropi 26587e39db Merge commit '199ef1e26d47302b1e7e93f831fc6326164c64cc' into Cube 2026-02-18 08:42:06 +01:00
Riccardo Elitropi bc248d7f24 EgtGraphics : 
- rimozione warning.
 2024-03-07 11:05:02 +01:00
Riccardo Elitropi d80435c4df EgtGraphics : 
- pulizia codice da merge.
 2024-03-04 15:15:07 +01:00
Riccardo Elitropi ada682cba3 Merge commit '49dac32893ce1a6c894eea9057049208579c1206' into Cube 2024-03-04 13:39:01 +01:00
Riccardo Elitropi 93ec29f2fd EgtGraphics : 
- piccola modifica dimensioni cubetto.
 2023-10-04 09:48:16 +02:00
Riccardo Elitropi ebda47089d Merge commit '00a81d6e0461bcb1ad8cab1b0fd81ba14de55ef0' into Cube 2023-08-22 13:17:44 +02:00
Riccardo Elitropi 9d32f3e7cc Merge commit '1704b40c1793c2d355d0ba14fa9c6e713304b1c7' into Cube 2023-06-30 09:37:01 +02:00
Riccardo Elitropi 0794fded30 Merge commit '30b56dbfc86b23419281ecb2917127d2b74ebbe2' into Cube 2023-06-01 13:03:34 +02:00
Riccardo Elitropi 147964cf6a EgtGraphics : 
- Cubetto
- Assi
- Griglia
- Zoom.
 2023-06-01 13:03:24 +02:00
Riccardo Elitropi 3c1e9e8790 Merge commit '59ddf028879536f921b749fa59dc460757d9f911' into Cube 2023-05-11 11:57:35 +02:00
Riccardo Elitropi e5a7ec2ff6 EgtExchange : 
- impostazione parametri del cubo
- Visualizzazione del cubo
 2022-10-17 08:40:53 +02:00
Riccardo Elitropi 7294508074 EgtGraphics : 
- visualizzazione e controllo del cubetto.
 2022-10-12 10:13:47 +02:00
19 changed files with 1395 additions and 762 deletions
Expand all files Collapse all files
EgtGraphics.rc
BIN
View File
Binary file not shown.
EgtGraphics.vcxproj
+8 -7
View File
@@ -22,14 +22,14 @@
<ProjectGuid>{4EC970B1-B4D9-4088-8A31-B462CF72116E}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>EgtGraphics</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
<WindowsTargetPlatformVersion>10.0.20348.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
<PlatformToolset>v141_xp</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
@@ -42,7 +42,7 @@
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
<PlatformToolset>v141_xp</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
@@ -108,7 +108,7 @@
<CompileAs>CompileAsCpp</CompileAs>
<DisableSpecificWarnings>
</DisableSpecificWarnings>
<LanguageStandard>stdcpp20</LanguageStandard>
<LanguageStandard>stdcpp17</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
@@ -135,7 +135,7 @@ copy $(TargetPath) \EgtProg\DllD32</Command>
<OpenMPSupport>true</OpenMPSupport>
<DisableSpecificWarnings>
</DisableSpecificWarnings>
<LanguageStandard>stdcpp20</LanguageStandard>
<LanguageStandard>stdcpp17</LanguageStandard>
<AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
</ClCompile>
<Link>
@@ -171,7 +171,7 @@ copy $(TargetPath) \EgtProg\DllD64</Command>
<EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
<PrecompiledHeader>Use</PrecompiledHeader>
<LanguageStandard>stdcpp20</LanguageStandard>
<LanguageStandard>stdcpp17</LanguageStandard>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
@@ -209,7 +209,7 @@ copy $(TargetPath) \EgtProg\Dll32</Command>
<EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
<CompileAs>CompileAsCpp</CompileAs>
<LanguageStandard>stdcpp20</LanguageStandard>
<LanguageStandard>stdcpp17</LanguageStandard>
<AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
</ClCompile>
<Link>
@@ -263,6 +263,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClCompile Include="SceneCamera.cpp" />
<ClCompile Include="SceneGeom.cpp" />
<ClCompile Include="SceneDirect.cpp" />
<ClCompile Include="SceneGlobCube.cpp" />
<ClCompile Include="SceneGlobFrame.cpp" />
<ClCompile Include="SceneGrid.cpp" />
<ClCompile Include="SceneImage.cpp" />
EgtGraphics.vcxproj.filters
+3
View File
@@ -140,6 +140,9 @@
<ClCompile Include="ImageMgr.cpp">
<Filter>File di origine</Filter>
</ClCompile>
<ClCompile Include="SceneGlobCube.cpp">
<Filter>File di origine</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="EgtGraphics.rc">
ObjEGrGraphics.h
+5 -6
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2024
// EgalTech 2014-2023
//----------------------------------------------------------------------------
// File : ObjEGrGraphics.h Data : 09.03.24 Versione : 2.6c2
// File : ObjEGrGraphics.h Data : 08.07.23 Versione : 2.5g1
// Contenuto : Dichiarazione della classe grafica di un oggetto geometrico.
//
//
@@ -31,9 +31,8 @@ class ObjEGrGraphics : public IObjGraphics
virtual bool IsValid( void) = 0 ;
virtual void SetScene( Scene* pScene) = 0 ;
virtual Scene* GetScene( void) = 0 ;
virtual bool SetCurrent( int nCurr) = 0 ;
virtual bool SetCurrent( int nCurr) { return false ; }
virtual void Clear( void) = 0 ;
virtual bool Validate( void) = 0 ;
virtual bool AddColor( const Color& colC) = 0 ;
virtual bool AddMaterial( const Color& colAmb, const Color& colDiff,
const Color& colSpec, float fShin) = 0 ;
@@ -41,8 +40,8 @@ class ObjEGrGraphics : public IObjGraphics
virtual bool AddLineStipple( int nFactor, int nPattern) = 0 ;
virtual bool AddPoint( const Point3d& ptP, bool bAux = false) = 0 ;
virtual bool AddPoints( const PNTVECTOR& vPnt, bool bAux = false) = 0 ;
virtual bool AddLines( const PNTVECTOR& vPnt, bool bAux = false, bool bSurfSha = false) = 0 ;
virtual bool AddPolyLine( const PolyLine& PL, bool bAux = false, bool bSurfSha = false) = 0 ;
virtual bool AddLines( const PNTVECTOR& vPnt, bool bAux = false) = 0 ;
virtual bool AddPolyLine( const PolyLine& PL, bool bAux = false) = 0 ;
virtual bool StartTriangles( int nNum, bool bAux = false) = 0 ;
virtual bool AddTriangle( const Triangle3d& Tria, const TriFlags3d& TFlags, const TriNormals3d& TNrms) = 0 ;
virtual bool EndTriangles( void) = 0 ;
ObjMultiGraphics.cpp
+8 -19
View File
@@ -13,6 +13,7 @@
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "/EgtDev/Include/EGkColor.h"
#include "ObjMultiGraphics.h"
#include "ObjNewGraphics.h"
#include "ObjOldGraphics.h"
@@ -33,7 +34,7 @@ void
ObjMultiGraphics::Reset( void)
{
m_bValid = false ;
m_nCurr = -1 ;
m_nCurr = - 1 ;
}
//----------------------------------------------------------------------------
@@ -51,8 +52,8 @@ void
ObjMultiGraphics::SetScene( Scene* pScene)
{
m_pScene = pScene ;
for ( auto& pOEGR : m_vOEGR)
pOEGR->SetScene( pScene) ;
for ( size_t i = 0 ; i < m_vOEGR.size() ; ++ i)
m_vOEGR[i]->SetScene( pScene) ;
}
//----------------------------------------------------------------------------
@@ -77,18 +78,6 @@ ObjMultiGraphics::Clear( void)
m_vOEGR[m_nCurr]->Clear() ;
}
//----------------------------------------------------------------------------
bool
ObjMultiGraphics::Validate( void)
{
if ( ! m_bValid) {
if ( m_nCurr < 0 || m_nCurr >= int( m_vOEGR.size()))
return false ;
m_bValid = m_vOEGR[m_nCurr]->Validate() ;
}
return m_bValid ;
}
//----------------------------------------------------------------------------
bool
ObjMultiGraphics::AddColor( const Color& colC)
@@ -148,22 +137,22 @@ ObjMultiGraphics::AddPoints( const PNTVECTOR& vPnt, bool bAux)
//----------------------------------------------------------------------------
bool
ObjMultiGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux, bool bSurfSha)
ObjMultiGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux)
{
if ( m_nCurr < 0 || m_nCurr >= int( m_vOEGR.size()))
return false ;
m_bValid = true ;
return m_vOEGR[m_nCurr]->AddLines( vPnt, bAux, bSurfSha) ;
return m_vOEGR[m_nCurr]->AddLines( vPnt, bAux) ;
}
//----------------------------------------------------------------------------
bool
ObjMultiGraphics::AddPolyLine( const PolyLine& PL, bool bAux, bool bSurfSha)
ObjMultiGraphics::AddPolyLine( const PolyLine& PL, bool bAux)
{
if ( m_nCurr < 0 || m_nCurr >= int( m_vOEGR.size()))
return false ;
m_bValid = true ;
return m_vOEGR[m_nCurr]->AddPolyLine( PL, bAux, bSurfSha) ;
return m_vOEGR[m_nCurr]->AddPolyLine( PL, bAux) ;
}
//----------------------------------------------------------------------------
ObjMultiGraphics.h
+2 -3
View File
@@ -32,7 +32,6 @@ class ObjMultiGraphics : public ObjEGrGraphics
{ return m_pScene ; }
bool SetCurrent( int nCurr) override ;
void Clear( void) override ;
bool Validate( void) override ;
bool AddColor( const Color& colC) override ;
bool AddMaterial( const Color& colAmb, const Color& colDiff,
const Color& colSpec, float fShin) override ;
@@ -40,8 +39,8 @@ class ObjMultiGraphics : public ObjEGrGraphics
bool AddLineStipple( int nFactor, int nPattern) override ;
bool AddPoint( const Point3d& ptP, bool bAux = false) override ;
bool AddPoints( const PNTVECTOR& vPnt, bool bAux = false) override ;
bool AddLines( const PNTVECTOR& vPnt, bool bAux = false, bool bSurfSha = false) override ;
bool AddPolyLine( const PolyLine& PL, bool bAux = false, bool bSurfSha = false) override ;
bool AddLines( const PNTVECTOR& vPnt, bool bAux = false) override ;
bool AddPolyLine( const PolyLine& PL, bool bAux = false) override ;
bool StartTriangles( int nNum, bool bAux = false) override ;
bool AddTriangle( const Triangle3d& Tria, const TriFlags3d& TFlags, const TriNormals3d& TNrms) override ;
bool EndTriangles( void) override ;
ObjNewGraphics.cpp
+9 -25
View File
@@ -52,15 +52,6 @@ ObjNewGraphics::Clear( void)
m_nCurrMode = GL_NONE ;
}
//----------------------------------------------------------------------------
bool
ObjNewGraphics::Validate( void)
{
if ( ! m_bValid)
m_bValid = m_ngaVect.empty() ;
return m_bValid ;
}
//----------------------------------------------------------------------------
bool
ObjNewGraphics::AddColor( const Color& colC)
@@ -174,7 +165,7 @@ ObjNewGraphics::AddPoints( const PNTVECTOR& vPnt, bool bAux)
//----------------------------------------------------------------------------
bool
ObjNewGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux, bool bSurfSha)
ObjNewGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux)
{
if ( m_pScene == nullptr || ! m_pScene->MakeCurrent())
return false ;
@@ -204,7 +195,7 @@ ObjNewGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux, bool bSurfSha)
glEnableClientState( GL_VERTEX_ARRAY) ;
glBindVertexArray( 0) ;
// aggiungo i dati in lista
AddNgaVerts( GL_LINES, nCount, nVaoId, nVboId, bAux, bSurfSha) ;
AddNgaVerts( GL_LINES, nCount, nVaoId, nVboId, bAux) ;
// dichiaro valida la grafica
m_bValid = true ;
@@ -213,7 +204,7 @@ ObjNewGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux, bool bSurfSha)
//----------------------------------------------------------------------------
bool
ObjNewGraphics::AddPolyLine( const PolyLine& PL, bool bAux, bool bSurfSha)
ObjNewGraphics::AddPolyLine( const PolyLine& PL, bool bAux)
{
if ( m_pScene == nullptr || ! m_pScene->MakeCurrent())
return false ;
@@ -245,7 +236,7 @@ ObjNewGraphics::AddPolyLine( const PolyLine& PL, bool bAux, bool bSurfSha)
glEnableClientState( GL_VERTEX_ARRAY) ;
glBindVertexArray( 0) ;
// aggiungo i dati in lista
AddNgaVerts( GL_LINE_STRIP, nCount, nVaoId, nVboId, bAux, bSurfSha) ;
AddNgaVerts( GL_LINE_STRIP, nCount, nVaoId, nVboId, bAux) ;
// dichiaro valida la grafica
m_bValid = true ;
@@ -386,9 +377,9 @@ ObjNewGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
float fSelMarkCol[4] = { 1, 1, 1, 1} ;
float fSelMarkBackCol[4] = { 0.75, 0.75, 0.75, 1} ;
if ( bSurfSha) {
if ( nMark == GDB_MK_ON || nMark == GDB_MK_ON_2) {
if ( nMark == GDB_MK_ON) {
bStdCol = false ;
Color colMark = m_pScene->GetMark( nMark) ;
Color colMark = m_pScene->GetMark() ;
colMark.SetAlpha( nAlpha) ;
colMark.GetFloat( fSelMarkCol) ;
Color colMarkBack = GetSurfBackColor( colMark) ;
@@ -433,13 +424,6 @@ ObjNewGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
glBindVertexArray( 0) ;
}
break ;
case NgAtom::VERTS_S :
if ( bSurfSha && Nga.m_nCount > 0 && Nga.m_nVaoId != 0) {
glBindVertexArray( Nga.m_nVaoId) ;
glDrawArrays( Nga.m_nMode, 0, Nga.m_nCount) ;
glBindVertexArray( 0) ;
}
break ;
case NgAtom::COLOR :
glColor4fv( ( bStdCol ? AdjustColor( Nga.m_fCol, bDark) : fSelMarkCol)) ;
break ;
@@ -477,7 +461,7 @@ ObjNewGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
}
// se marcato e non superficie in shading, disegno halo
if ( ( nMark == GDB_MK_ON || nMark == GDB_MK_ON_2) && ! bSurfSha) {
if ( nMark == GDB_MK_ON && ! bSurfSha) {
// cambio test di depth per non sovrascrivere il disegno appena fatto
glDepthFunc( GL_LESS) ;
@@ -486,7 +470,7 @@ ObjNewGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
glLineWidth( (float) m_pScene->GetMarkLineWidth()) ;
// colore di marcatura
Color colMark = m_pScene->GetMark( nMark) ;
Color colMark = m_pScene->GetMark() ;
glColor4f( colMark.GetRed(), colMark.GetGreen(), colMark.GetBlue(), colMark.GetAlpha()) ;
// ciclo di disegno
@@ -530,7 +514,7 @@ ObjNewGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
}
// se necessario, ripristino la normale visualizzazione
if ( nStat == GDB_ST_SEL || nMark == GDB_MK_ON || nMark == GDB_MK_ON_2) {
if ( nStat == GDB_ST_SEL || nMark == GDB_MK_ON) {
glPointSize( (float) m_pScene->GetPointSize()) ;
glLineWidth( (float) m_pScene->GetLineWidth()) ;
}
ObjNewGraphics.h
+10 -11
View File
@@ -14,7 +14,7 @@
#pragma once
#include "ObjEGrGraphics.h"
#include "OpenGL.h"
//----------------------------------------------------------------------------
// Definizione di NgAtom
@@ -23,8 +23,8 @@ class NgAtom {
NgAtom( void) : m_nType( NONE), m_nMode( 0), m_nCount( 0), m_nVaoId( 0), m_nVboId( 0) {}
public :
enum GrType { NONE = 0, VERTS = 1, VERTS_A = 2, VERTS_S = 3, COLOR = 4,
MAT_A = 5, MAT_D = 6, MAT_S = 7, MAT_SH = 8, MAT_B = 9, LINE_STIPPLE = 10} ;
enum GrType { NONE = 0, VERTS = 1, VERTS_A = 2, COLOR = 3,
MAT_A = 4, MAT_D = 5, MAT_S = 6, MAT_SH = 7, MAT_B = 8, LINE_STIPPLE = 9} ;
public :
GrType m_nType ;
@@ -69,10 +69,7 @@ class ObjNewGraphics : public ObjEGrGraphics
{ m_pScene = pScene ; }
Scene* GetScene( void) override
{ return m_pScene ; }
bool SetCurrent( int nCurr) override
{ return ( nCurr == 0) ; }
void Clear( void) override ;
bool Validate( void) override ;
bool AddColor( const Color& colC) override ;
bool AddMaterial( const Color& colAmb, const Color& colDiff,
const Color& colSpec, float fShin) override ;
@@ -80,17 +77,19 @@ class ObjNewGraphics : public ObjEGrGraphics
bool AddLineStipple( int nFactor, int nPattern) override ;
bool AddPoint( const Point3d& ptP, bool bAux = false) override ;
bool AddPoints( const PNTVECTOR& vPnt, bool bAux = false) override ;
bool AddLines( const PNTVECTOR& vPnt, bool bAux = false, bool bSurfSha = false) override ;
bool AddPolyLine( const PolyLine& PL, bool bAux = false, bool bSurfSha = false) override ;
bool AddLines( const PNTVECTOR& vPnt, bool bAux = false) override ;
bool AddPolyLine( const PolyLine& PL, bool bAux = false) override ;
bool StartTriangles( int nNum, bool bAux = false) override ;
bool AddTriangle( const Triangle3d& Tria, const TriFlags3d& TFlags, const TriNormals3d& TNrms) override ;
bool EndTriangles( void) override ;
bool Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlpha, bool bShowAux) override ;
bool GetLocalBBox( BBox3d& b3Loc) const override
{ b3Loc = m_b3Loc ; return ! m_b3Loc.IsEmpty() ; }
public :
ObjNewGraphics( void) : m_pScene( nullptr), m_bValid( false), m_nCurrMode( GL_NONE) {}
ObjNewGraphics( void) : m_pScene( nullptr), m_bValid( false) {}
private :
bool DeleteVaoVbo( void) ;
@@ -98,9 +97,9 @@ class ObjNewGraphics : public ObjEGrGraphics
{ try { m_ngaVect.push_back( nga) ; }
catch(...) { return false ; }
return true ; }
bool AddNgaVerts( int nMode, int nCount, unsigned int nVaoId, unsigned int nVboId, bool bAux = false, bool bSurfSha = false)
bool AddNgaVerts( int nMode, int nCount, unsigned int nVaoId, unsigned int nVboId, bool bAux = false)
{ NgAtom nga ;
nga.m_nType = ( bSurfSha ? NgAtom::VERTS_S : ( bAux ? NgAtom::VERTS_A : NgAtom::VERTS)) ;
nga.m_nType = ( bAux ? NgAtom::VERTS_A : NgAtom::VERTS) ;
nga.m_nMode = nMode ; nga.m_nCount = nCount ;
nga.m_nVaoId = nVaoId ; nga.m_nVboId = nVboId ;
return AddNgAtom( nga) ; }
ObjOldGraphics.cpp
+19 -42
View File
@@ -48,15 +48,6 @@ ObjOldGraphics::Clear( void)
m_nCurrMode = GL_NONE ;
}
//----------------------------------------------------------------------------
bool
ObjOldGraphics::Validate( void)
{
if ( ! m_bValid)
m_bValid = m_ogaVect.empty() ;
return m_bValid ;
}
//----------------------------------------------------------------------------
bool
ObjOldGraphics::AddColor( const Color& colC)
@@ -138,7 +129,7 @@ ObjOldGraphics::AddPoints( const PNTVECTOR& vPnt, bool bAux)
//----------------------------------------------------------------------------
bool
ObjOldGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux, bool bSurfSha)
ObjOldGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux)
{
// modo corrente deve essere nullo
if ( m_nCurrMode != GL_NONE)
@@ -146,7 +137,7 @@ ObjOldGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux, bool bSurfSha)
// riservo memoria per vettore
m_ogaVect.reserve( VECT_HEAP + vPnt.size()) ;
// start
AddOgaStart( GL_LINES, bAux, bSurfSha) ;
AddOgaStart( GL_LINES, bAux) ;
// inserisco i vertici + aggiorno bbox
for ( int i = 0 ; i < int( vPnt.size()) ; ++ i) {
AddOgaVert3f( vPnt[i]) ;
@@ -162,7 +153,7 @@ ObjOldGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux, bool bSurfSha)
//----------------------------------------------------------------------------
bool
ObjOldGraphics::AddPolyLine( const PolyLine& PL, bool bAux, bool bSurfSha)
ObjOldGraphics::AddPolyLine( const PolyLine& PL, bool bAux)
{
// modo corrente deve essere nullo
if ( m_nCurrMode != GL_NONE)
@@ -170,7 +161,7 @@ ObjOldGraphics::AddPolyLine( const PolyLine& PL, bool bAux, bool bSurfSha)
// riservo memoria per vettore
m_ogaVect.reserve( VECT_HEAP + PL.GetPointNbr()) ;
// start
AddOgaStart( GL_LINE_STRIP, bAux, bSurfSha) ;
AddOgaStart( GL_LINE_STRIP, bAux) ;
// inserisco i nuovi vertici + aggiorno bbox
Point3d ptP ;
for ( bool bFound = PL.GetFirstPoint( ptP) ; bFound ; bFound = PL.GetNextPoint( ptP)) {
@@ -254,9 +245,6 @@ AdjustColor( const float fCol[4], bool bDark)
bool
ObjOldGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlpha, bool bShowAux)
{
if ( ! m_bValid || m_pScene == nullptr || ! m_pScene->MakeCurrent())
return false ;
// se vuoto non faccio alcunché
if ( m_ogaVect.size() == 0)
return true ;
@@ -274,9 +262,9 @@ ObjOldGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
float fSelMarkCol[4] = { 1, 1, 1, 1} ;
float fSelMarkBackCol[4] = { 0.75, 0.75, 0.75, 1} ;
if ( bSurfSha) {
if ( nMark == GDB_MK_ON || nMark == GDB_MK_ON_2) {
if ( nMark == GDB_MK_ON) {
bStdCol = false ;
Color colMark = m_pScene->GetMark( nMark) ;
Color colMark = ( ( GetScene() != nullptr) ? GetScene()->GetMark() : Color( 255, 255, 0)) ;
colMark.SetAlpha( nAlpha) ;
colMark.GetFloat( fSelMarkCol) ;
Color colMarkBack = GetSurfBackColor( colMark) ;
@@ -285,7 +273,7 @@ ObjOldGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
}
else if ( nStat == GDB_ST_SEL) {
bStdCol = false ;
Color colSelSurf = m_pScene->GetSelSurf() ;
Color colSelSurf = ( ( GetScene() != nullptr) ? GetScene()->GetSelSurf() : Color( 255, 255, 192)) ;
colSelSurf.SetAlpha( nAlpha) ;
colSelSurf.GetFloat( fSelMarkCol) ;
Color colSelSurfBack = GetSurfBackColor( colSelSurf) ;
@@ -304,45 +292,34 @@ ObjOldGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
}
// ciclo di disegno
bool bSkip = false ;
bool bStartA = false ;
bool bLineStipple = false ;
for ( const auto& Oga : m_ogaVect) {
switch ( Oga.m_nType) {
case OgAtom::START :
glBegin( Oga.m_nMode) ;
bSkip = false ;
bStartA = false ;
break ;
case OgAtom::START_A :
if ( bShowAux) {
if ( bShowAux)
glBegin( Oga.m_nMode) ;
bSkip = false ;
}
else
bSkip = true ;
break ;
case OgAtom::START_S :
if ( bSurfSha) {
glBegin( Oga.m_nMode) ;
bSkip = false ;
}
else
bSkip = true ;
bStartA = true ;
break ;
case OgAtom::END :
if ( ! bSkip)
if ( ! bStartA || bShowAux)
glEnd() ;
bSkip = false ;
bStartA = false ;
break ;
case OgAtom::VERT :
if ( ! bSkip)
if ( ! bStartA || bShowAux)
glVertex3fv( Oga.m_fVal) ;
break ;
case OgAtom::BND_FLAG :
if ( ! bSkip )
if ( ! bStartA || bShowAux)
glEdgeFlag( Oga.m_nFlag) ;
break ;
case OgAtom::NORMAL :
if ( ! bSkip)
if ( ! bStartA || bShowAux)
glNormal3fv( Oga.m_fVal) ;
break ;
case OgAtom::COLOR :
@@ -382,7 +359,7 @@ ObjOldGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
}
// se marcato e non superficie in shading, disegno halo
if ( ( nMark == GDB_MK_ON || nMark == GDB_MK_ON_2) && ! bSurfSha) {
if ( nMark == GDB_MK_ON && ! bSurfSha) {
// cambio test di depth per non sovrascrivere il disegno appena fatto
glDepthFunc( GL_LESS) ;
@@ -391,7 +368,7 @@ ObjOldGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
glLineWidth( (float) m_pScene->GetMarkLineWidth()) ;
// colore di marcatura
Color colMark = m_pScene->GetMark( nMark) ;
Color colMark = ( ( GetScene() != nullptr) ? GetScene()->GetMark() : Color( 192, 192, 0)) ;
glColor4f( colMark.GetRed(), colMark.GetGreen(), colMark.GetBlue(), colMark.GetAlpha()) ;
// ciclo di disegno
@@ -445,7 +422,7 @@ ObjOldGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
}
// se necessario, ripristino la normale visualizzazione
if ( nStat == GDB_ST_SEL || nMark == GDB_MK_ON || nMark == GDB_MK_ON_2) {
if ( nStat == GDB_ST_SEL || nMark == GDB_MK_ON) {
glPointSize( (float) m_pScene->GetPointSize()) ;
glLineWidth( (float) m_pScene->GetLineWidth()) ;
}
ObjOldGraphics.h
+7 -9
View File
@@ -26,8 +26,8 @@ class OgAtom {
OgAtom( void) : m_nType( NONE), m_fX( 0), m_fY( 0), m_fZ( 0), m_fW( 1) {}
public :
enum GrType { NONE = 0, START = 1, START_A = 2, START_S = 3, END = 4, VERT = 5, BND_FLAG = 6, NORMAL = 7,
COLOR = 8, MAT_A = 9, MAT_D = 10, MAT_S = 11, MAT_SH = 12, MAT_B = 13, LINE_STIPPLE = 14} ;
enum GrType { NONE = 0, START = 1, START_A = 2, END = 3, VERT = 4, BND_FLAG = 5, NORMAL = 6,
COLOR = 7, MAT_A = 8, MAT_D = 9, MAT_S = 10, MAT_SH = 11, MAT_B = 12, LINE_STIPPLE = 13} ;
public :
GrType m_nType ;
@@ -74,10 +74,7 @@ class ObjOldGraphics : public ObjEGrGraphics
{ m_pScene = pScene ; }
Scene* GetScene( void) override
{ return m_pScene ; }
bool SetCurrent( int nCurr) override
{ return ( nCurr == 0) ; }
void Clear( void) override ;
bool Validate( void) override ;
bool AddColor( const Color& colC) override ;
bool AddMaterial( const Color& colAmb, const Color& colDiff,
const Color& colSpec, float fShin) override ;
@@ -85,12 +82,13 @@ class ObjOldGraphics : public ObjEGrGraphics
bool AddLineStipple( int nFactor, int nPattern) override ;
bool AddPoint( const Point3d& ptP, bool bAux = false) override ;
bool AddPoints( const PNTVECTOR& vPnt, bool bAux = false) override ;
bool AddLines( const PNTVECTOR& vPnt, bool bAux = false, bool bSurfSha = false) override ;
bool AddPolyLine( const PolyLine& PL, bool bAux = false, bool bSurfSha = false) override ;
bool AddLines( const PNTVECTOR& vPnt, bool bAux = false) override ;
bool AddPolyLine( const PolyLine& PL, bool bAux = false) override ;
bool StartTriangles( int nNum, bool bAux = false) override ;
bool AddTriangle( const Triangle3d& Tria, const TriFlags3d& TFlags, const TriNormals3d& TNrms) override ;
bool EndTriangles( void) override ;
bool Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlpha, bool bShowAux) override ;
bool GetLocalBBox( BBox3d& b3Loc) const override
{ b3Loc = m_b3Loc ; return ! m_b3Loc.IsEmpty() ; }
@@ -102,9 +100,9 @@ class ObjOldGraphics : public ObjEGrGraphics
{ try { m_ogaVect.push_back( oga) ; }
catch(...) { return false ; }
return true ; }
bool AddOgaStart( int nMode, bool bAux = false, bool bSurfSha = false)
bool AddOgaStart( int nMode, bool bAux = false)
{ OgAtom oga ;
oga.m_nType = ( bSurfSha ? OgAtom::START_S : ( bAux ? OgAtom::START_A : OgAtom::START)) ;
oga.m_nType = ( bAux ? OgAtom::START_A : OgAtom::START) ;
oga.m_nMode = nMode ;
return AddOgAtom( oga) ; }
bool AddOgaEnd( void)
Scene.h
+51 -23
View File
@@ -111,9 +111,11 @@ class Scene : public IEGrScene
bool ZoomChange( double dCoeff) override ;
bool ZoomOnPoint( const Point3d& ptWin, double dCoeff) override ;
bool ZoomWin( const Point3d& ptWin1, const Point3d& ptWin2) override ;
bool RotateCameraWithCube() ;
bool RotateCameraWithBlockedAngle( Vector3d vDirS, Vector3d vDirE, double dDist, int nAdaptSpeed,
int nBlockedAngle, double dTheta_orig, double dPhi_orig,
double& dTheta_new, double& dPhi_new) ;
void GetOrthoCamParam( double* pdWidth, double* pdHeight, double* pdNear, double* pdFar) const override ;
bool SetCameraType( bool bOrthoOrPersp) override ;
bool SetZoomType( int nZoomMode) override ;
// ShowMode
bool SetShowMode( int nShowMode) override
{ if ( nShowMode != SM_WIREFRAME &&
@@ -140,11 +142,16 @@ class Scene : public IEGrScene
{ m_nShowText = nMode ; }
int GetShowText( void) const override
{ return m_nShowText ; }
// Colors
void SetSceneColors( Color cColX, Color cColY, Color cColZ, Color cColXm, Color cColYm, Color cColZm,
Color cColEdge, Color cColCorner) override
{ m_cColX = cColX ; m_cColY = cColY ; m_cColZ = cColZ ;
m_cColXm = cColXm ; m_cColYm = cColYm ; m_cColZm = cColZm ;
m_cColEdge = cColEdge ; m_cColCorner = cColCorner ; }
// Geometry
bool SetExtension( const BBox3d& b3Ext) override ;
bool UpdateExtension( void) override ;
bool SetMark( Color colMark) override ;
bool SetMark2( Color colMark) override ;
bool SetSelSurf( Color colSelSurf) override ;
bool SetLineWidth( int nW) override ;
// Grid
@@ -155,8 +162,17 @@ class Scene : public IEGrScene
bool SetGridColor( Color colMinLine, Color colMajLine) override ;
void GetGridParam( double& dSnapStep, int& nExtStep) const override ;
bool GetShowGrid() override ;
// Glob Frame
// Axis Frame
bool SetGlobFrameShow( bool bShow) override ;
bool SetGlobFrameParameters( int nPosFlag, double dDistX, double dDistY,
double dLenLine, double dWidthLine) override ;
// Glob Cube
bool DrawCube( bool bSurf) override ;
bool CreateFlatPart( ISurfTriMesh* pSrf) override ;
bool CreateEdgePart( ISurfTriMesh* pSrf) override ;
bool CreateCornerPart( ISurfTriMesh* pSrf) override ;
bool GetAngleByCubeFace( int nFaceId, double& dTheta, double& dPhi) ;
bool SetGlobCubeParameters( int nPosFlag, double dDistX, double dDistY, double dLenEdge) override ;
// Direct
bool SetGeoLineAttribs( Color GLcol) override ;
bool SetGeoLine( const Point3d& ptP1, const Point3d& ptP2) override ;
@@ -231,8 +247,8 @@ class Scene : public IEGrScene
double GetFrameLineWidth( void) const
{ return m_dFrameLineWidth ; }
// Geometry
Color GetMark( int nMark) const
{ return ( nMark == GDB_MK_ON_2 ? m_colMark2 : m_colMark) ; }
Color GetMark( void) const
{ return m_colMark ; }
Color GetSelSurf( void) const
{ return m_colSelSurf ; }
@@ -246,13 +262,10 @@ class Scene : public IEGrScene
bool MyDraw( bool bSwapBF) ;
bool Background( void) ;
bool Prepare( void) ;
bool GetPixelZ( const Point3d& ptWin, double& dWinZ) ;
// Camera
bool VerifyCamera( bool bUseOrizzOffsCamera = false) ;
bool CalcDirUp( bool bUseOrizzOffsCamera = false) ;
bool CalcCameraFrame( Frame3d& frView) ;
double CalcMinCameraDistance() ;
bool CalcDistCamera() ;
// Geometry
bool DrawGroup( int nId, int nPass, const MdStMkCol& siParent) ;
bool DrawGroup( const IGdbIterator& iIter, int nPass, const MdStMkCol& siParent) ;
@@ -266,8 +279,11 @@ class Scene : public IEGrScene
static Frame3d frGrid ;
return frGrid ; }
bool DrawGrid( void) ;
bool DrawRectangularGrid( void) ;
// Glob Frame
bool DrawGlobFrame( void) ;
// Glob Cube
bool DrawGlobCube( bool bSurf) ;
// Direct
bool DrawDirect( void) ;
bool DrawGeoLine( void) ;
@@ -300,18 +316,24 @@ class Scene : public IEGrScene
HGLRC m_hRC ; // OpenGL Rendering Context
int m_nOglVer ; // OpenGL Version
bool m_bNewWay ; // flag che indica nuova modalità (OpenGL 3.0 in poi)
// Colors
Color m_cColX ; // colore asse x
Color m_cColXm ; // colore asse -x
Color m_cColY ; // colore asse y
Color m_cColYm ; // colore asse -y
Color m_cColZ ; // colore asse z
Color m_cColZm ; // colore asse -z
Color m_cColEdge ; // colore per Edge ( per cubetto)
Color m_cColCorner ; // colore per Corner ( per cubetto)
// Camera
Point3d m_ptCenter ; // centro verso cui è rivolta la camera
Vector3d m_vtDirCamera ; // versore direzione dal centro alla camera
int m_nOrizzOffsCamera ; // offset orizzontale viste camera in multipli di 90deg
double m_dDistCamera ; // distanza dal centro alla camera
bool m_bDistOk ; // flag per stato aggiornamento di dDistCamera
Vector3d m_vtUp ; // versore direzione Su della camera
bool m_bUpOk ; // flag per stato aggiornamento di Up
int m_nViewportW ; // larghezza della finestra
int m_nViewportH ; // altezza della finestra
bool m_bOrthographic ; // flag che indica se camera ortografica o prospettica
int m_nPerspZoomType ; // flag che indica tipologia di zoom in vista prospettica ( standard, dolly)
// Textures
TextureMgr m_TextMgr ; // gestore di textures
// Background
@@ -346,7 +368,7 @@ class Scene : public IEGrScene
SelRec m_nSelBuff[DIM_SEL_BUF] ; // buffer per selezione con OpenGL
// Snap
// lo snap a oggetti usa la select, quindi anche per esso valgono m_nObjFilterForSelect e m_Unsel
int m_nLastSnapId ; // Id dell'entità generatrice dell'ultimo punto snap
int m_nLastSnapId ; // Id dell'entit� generatrice dell'ultimo punto snap
Point3d m_ptLastSnapPnt ; // ultimo punto di snap
bool m_bLastSnapDirOk ; // flag validità direzione associata a ultimo punto snap
Vector3d m_vtLastSnapDir ; // direzione associata a ultimo punto snap
@@ -354,7 +376,6 @@ class Scene : public IEGrScene
IGeomDB* m_pGeomDB ; // puntatore al DB geometrico
Color m_colDef ; // colore di default
Color m_colMark ; // colore per marcatura
Color m_colMark2 ; // colore per marcatura di tipo 2
Color m_colSelSurf ; // colore di superficie selezionata
// Superfici semitrasparenti
ASURFVECTOR m_vAlphaSurf ; // vettore temporaneo di superfici semitrasparenti
@@ -379,9 +400,23 @@ class Scene : public IEGrScene
double m_dGridMaxY ; // massima estensione in Y della griglia
Color m_colMinLine ; // colore delle linee minori
Color m_colMajLine ; // colore delle linee maggiori
// Glob Frame
// Axis Frame
bool m_bShowGlobFrame ; // flag di visualizzazione del riferimento globale
// Direct
int m_nAxisFrame_Flag ; // flag per quadrante di visualizzazione del frame
double m_dFrame_DistX ; // X del Centro del frame sullo schermo
double m_dFrame_DistY ; // Y del Centro del frame sullo schetrmo
double m_dFrameLineL ; // lunghezza delle linee del frame
double m_dFrameLineW ; // spessore delle linee del frame
// Glob Cube
ISURFTMPOVECTOR m_vStm_Cube ; // vettore contenente le superificie del cubo ( 26 in totale)
bool m_bShowGlobCube ; // flag di visualizzazione del cubetto
Point3d m_ptOrigCube ; // centro del cubo in cordinate globali
int m_nCube_Flag ; // flag per posizione negli angoli del cubetto
double m_dCubeEdge ; // lunghezza del lato del cubo
double m_dCubeX ; // X del Centro del cubo sullo schermo
double m_dCubeY ; // Y del Centro del cubo sullo schermo
int m_nStartFaceId ; // nuovo id iniziale utilizzato per assegnare un id univoco e non in uso alle facce del cubo
// Direct
Color m_colorGL ; // colore per GeoLine
bool m_bGeoLine ; // flag esistenza linea diretta in finestra
Point3d m_ptGeoLineP1 ; // primo estremo della linea diretta
@@ -397,10 +432,3 @@ class Scene : public IEGrScene
Point3d m_ptWinRectP1 ; // primo estremo del rettangolo diretto
Point3d m_ptWinRectP2 ; // secondo estremo del rettangolo diretto
} ;
//----------------------------------------------------------------------------
static const double PERSPECTIVE_NEAR_PLANE = 10 ;
static const double PERSPECTIVE_STD_FOV = 45 ;
static const double PERSPECTIVE_MAX_FOV = 100 ;
static const double PERSPECTIVE_TAN_MAX_FOV = tan( 0.5 * PERSPECTIVE_MAX_FOV * DEGTORAD) ;
SceneBasic.cpp
+45 -100
View File
@@ -51,20 +51,27 @@ Scene::Scene( void)
m_hRC = nullptr ;
m_nOglVer = 0 ;
m_bNewWay = false ;
// Colors
m_cColX = Color( 255, 0, 0, 1) ;
m_cColXm = Color( 167, 27, 11, 1) ;
m_cColY = Color( 0, 255, 0, 1) ;
m_cColYm = Color( 36, 163, 25, 1) ;
m_cColZ = Color( 0, 0, 255, 1) ;
m_cColZm = Color( 36, 17, 120, 1) ;
m_cColEdge = Color( 200, 200, 200, 1) ;
m_cColCorner = Color( 200, 200, 200, 1) ;
// Camera e viewport
m_ptCenter = ORIG ;
m_nOrizzOffsCamera = 0 ;
SetCamera( 0, 0, 0) ;
m_nViewportW = 0 ;
m_nViewportH = 0 ;
m_bOrthographic = true ;
m_nPerspZoomType = ZT_STD ;
// Textures
m_TextMgr.SetScene( this) ;
// Sfondo
m_colBackTop.Set( 176, 176, 176) ;
m_colBackBottom.Set( 176, 176, 176) ;
// Modalità di visualizzazione
// Modalit� di visualizzazione
m_nShowMode = SM_WIREFRAME ;
m_bShowCurveDirection = false ;
m_bShowTriaAdvanced = true ;
@@ -91,7 +98,6 @@ Scene::Scene( void)
m_pGeomDB = nullptr ;
m_colDef.Set( 0, 0, 0) ;
m_colMark.Set( 255, 255, 0) ;
m_colMark2.Set( 255, 64, 64) ;
m_colSelSurf.Set( 255, 255, 192) ;
// Superfici semitrasparenti
m_vAlphaSurf.reserve( 100) ;
@@ -140,7 +146,7 @@ Scene::Init( IGeomDB* pGeomDB)
bool
Scene::CreateContext( HDC hDC, int nDriver, bool b2Buff, int nColorBits, int nDepthBits)
{
// verifico validità Device Context
// verifico validit� Device Context
if ( hDC == nullptr)
return false ;
m_hDC = hDC ;
@@ -217,7 +223,7 @@ Scene::CreateContext( HDC hDC, int nDriver, bool b2Buff, int nColorBits, int nDe
LOG_INFO( GetEGrLogger(), "WGL_ARB_create_context missing !")
}
// verifico validità Rendering Context
// verifico validit� Rendering Context
if ( m_hRC == nullptr)
return false ;
@@ -228,7 +234,7 @@ Scene::CreateContext( HDC hDC, int nDriver, bool b2Buff, int nColorBits, int nDe
if ( GlewInitResult != GLEW_OK)
LOG_INFO( GetEGrLogger(), "GLEW is not initialized !")
// verifico se posso lavorare in modalità nuova
// verifico se posso lavorare in modalit� nuova
m_bNewWay = ( nDriver == OD_NEW && glewIsSupported( "GL_VERSION_3_0") == 1) ;
if ( ! m_bNewWay)
LOG_INFO( GetEGrLogger(), "OpenGL old way rendering !")
@@ -290,11 +296,11 @@ Scene::ChooseGenPixelFormat( int nPfd, bool b2Buff, int nColorBits, int nDepthBi
bool
Scene::MakeCurrent( void) const
{
// se RC della scena non è definito, errore
// se RC della scena non � definito, errore
if ( m_hRC == nullptr)
return false ;
// se RC della scena è quello corrente, ok
// se RC della scena � quello corrente, ok
HGLRC hRC = wglGetCurrentContext() ;
if ( m_hRC == hRC)
return true ;
@@ -421,7 +427,7 @@ Scene::SetExtension( const BBox3d& b3Ext)
bool
Scene::CalcExtView( void)
{
// verifico se il calcolo è necessario
// verifico se il calcolo � necessario
if ( m_bExtViewOk && m_bUpOk)
return true ;
// calcolo direzione camera Up
@@ -517,14 +523,9 @@ Scene::CalcClippingPlanesFromExtView( void)
// ricavo la posizione dei piani di clipping sull'asse Z di vista
const double EXP_COEFF = 1.1 ;
double dExtent = max( ( EXP_COEFF * vtExtent.z), MIN_ZCLIP_EXT) ;
if ( m_bOrthographic) {
m_dZNear = - ( ptCenter.z + dExtent) ;
m_dZFar = - ( ptCenter.z - dExtent) ;
}
else {
m_dZNear = PERSPECTIVE_NEAR_PLANE ;
m_dZFar = abs( ptCenter.z - dExtent) ;
}
m_dZNear = - ( ptCenter.z + dExtent) ;
m_dZFar = - ( ptCenter.z - dExtent) ;
return true ;
}
@@ -681,9 +682,6 @@ Scene::Prepare( void)
// eventuale ricalcolo parametri di vista
CalcDirUp() ;
CalcDistCamera() ;
if ( ! m_bOrthographic)
m_bDistOk = false ; // resetto il flag per le prossime operazioni
// imposto matrice di proiezione
glMatrixMode( GL_PROJECTION) ;
@@ -695,27 +693,7 @@ Scene::Prepare( void)
// imposto area di pick
gluPickMatrix( m_ptSelCent.x, ( Viewport[3] - m_ptSelCent.y), m_nSelW, m_nSelH, Viewport) ;
}
if ( m_bOrthographic)
glOrtho( - m_dHalfWidth, m_dHalfWidth, - m_dHalfHeight, m_dHalfHeight, m_dZNear, m_dZFar) ;
else {
// calcolo del fov : se dolly è costante, se zoom standard deve adattarsi alla vista
double dFov = PERSPECTIVE_STD_FOV ;
double dRatio = m_dHalfWidth / m_dHalfHeight ;
if ( m_nPerspZoomType == ZT_STD) {
// verifico che il fov non superi il valore massimo consentito
if ( m_dHalfHeight / m_dDistCamera > PERSPECTIVE_TAN_MAX_FOV) {
dFov = PERSPECTIVE_MAX_FOV ;
// aggiusto i valori di HalfHeight e HalfWidth
m_dHalfHeight = m_dDistCamera * PERSPECTIVE_TAN_MAX_FOV ;
m_dHalfWidth = dRatio * m_dHalfHeight ;
}
else
dFov = 2 * atan2( m_dHalfHeight, m_dDistCamera) * RADTODEG ;
}
gluPerspective( abs( dFov), dRatio, m_dZNear, m_dZFar) ;
}
glOrtho( - m_dHalfWidth, m_dHalfWidth, - m_dHalfHeight, m_dHalfHeight, m_dZNear, m_dZFar) ;
// imposto matrice modello/vista
glMatrixMode( GL_MODELVIEW) ;
@@ -762,12 +740,12 @@ Scene::MyDraw( bool bSwapBF)
if ( m_pGeomDB != nullptr)
m_pGeomDB->GetDefaultMaterial( m_colDef) ;
// impostazioni dipendenti dalla modalità di visualizzazione
// impostazioni dipendenti dalla modalit� di visualizzazione
switch ( m_nShowMode) {
case SM_WIREFRAME :
// disabilito illuminazione
glDisable( GL_LIGHTING) ;
// disegno griglia senza illuminazione (già impostato)
// disegno griglia senza illuminazione (gi� impostato)
DrawGrid() ;
// imposto dati standard per punti e linee
glPointSize( (float) GetPointSize()) ;
@@ -780,7 +758,7 @@ Scene::MyDraw( bool bSwapBF)
case SM_HIDDENLINE :
// disabilito illuminazione
glDisable( GL_LIGHTING) ;
// disegno griglia senza illuminazione (già impostato)
// disegno griglia senza illuminazione (gi� impostato)
DrawGrid() ;
// imposto dati standard per punti e linee
glPointSize( (float) GetPointSize()) ;
@@ -866,6 +844,10 @@ Scene::MyDraw( bool bSwapBF)
glDisable( GL_DEPTH_TEST) ;
glDisable( GL_LIGHTING) ;
// da togliere e richiamare esternamente...
SetGlobCubeParameters( 1, 60, 60, 75) ;
SetGlobFrameParameters( 3, 40, 40, 25, 2) ;
// disegno riferimento globale
DrawGlobFrame() ;
@@ -873,6 +855,24 @@ Scene::MyDraw( bool bSwapBF)
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL) ;
DrawDirect() ;
// disegno il cubetto
glDisable( GL_LIGHTING) ;
glEnable( GL_DEPTH_TEST) ;
glEnable( GL_POLYGON_OFFSET_FILL) ;
glFrontFace( GL_CCW) ;
glCullFace( GL_BACK) ;
glEnable( GL_CULL_FACE) ;
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL) ;
glPolygonOffset( 0.5, 0.5) ;
DrawGlobCube( true) ; // superifici
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE) ;
glLineWidth( 1) ;
DrawGlobCube( false) ; // linee
glLineWidth( GetLineWidth()) ;
glDisable( GL_CULL_FACE) ;
glDisable( GL_DEPTH_TEST) ;
// aggiorno
glFlush() ;
@@ -941,61 +941,6 @@ Scene::UnProject( const Point3d& ptView, Point3d& ptWorld) const
return ( nRes == GL_TRUE) ;
}
//----------------------------------------------------------------------------
bool
Scene::GetPixelZ( const Point3d& ptWin, double& dWinZ)
{
glGetError() ;
// recupero la ViewPort corrente
GLint Viewport[ 4] ;
glGetIntegerv( GL_VIEWPORT, Viewport) ;
// inizializzo i parametri come per la selezione, senza però effettuarla !
m_bSelect = true ;
m_ptSelCent = ptWin ;
m_nSelW = 13 ; // riducibile ...
m_nSelH = 13 ; // riducibile ...
// imposto la pick-matrix e la proiezione ridotta
if ( ! Prepare()) {
m_bSelect = false ;
dWinZ = GetProjectedCenter().z ;
return false ;
}
// forzo rendering opaco per il picking: niente blending, depth write ON
glDisable( GL_LIGHTING) ;
glDisable( GL_BLEND) ;
glEnable( GL_DEPTH_TEST) ;
glDepthMask( GL_TRUE) ;
glClear( GL_DEPTH_BUFFER_BIT) ; // pulizia buffer depth per futura scrittura
// disegno la scena nella viewport ridotta : questo scrive il depth buffer ( se fossi nella vera
// modalità di selezione GL_SELECT non scriverei le depth nel buffer, in qaunto non c'è una
// modalità di rendering)
DrawGroup( GDB_ID_ROOT, 1, MdStMkCol( GDB_MD_STD, GDB_ST_ON, GDB_MK_OFF, m_colDef)) ;
glFlush() ; // per sicurezza attendo
// leggo la Z del pizel corrente, le coordinate x e y non cambiano rispetto alla viewport originale
glReadBuffer( GL_FRONT) ;
float dZ ;
bool bOk = true ;
glReadPixels( int( ptWin.x), int( Viewport[3] - ptWin.y), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &dZ) ;
if ( glGetError() == GL_NO_ERROR && dZ > 0.001f && dZ < 0.999f)
dWinZ = dZ ;
else {
bOk = false ;
dWinZ = GetProjectedCenter().z ;
}
// reset dei parametri
m_bSelect = false ;
Prepare() ;
return bOk ;
}
//----------------------------------------------------------------------------
void
Scene::Destroy( void)
SceneCamera.cpp
+47 -217
View File
@@ -24,74 +24,10 @@ using namespace std ;
static const double MIN_DIST_CAMERA = 10 ;
static const double STD_DIST_CAMERA = 1000 ;
//----------------------------------------------------------------------------
bool
Scene::SetCameraType( bool bOrthoOrPersp)
{
m_bOrthographic = bOrthoOrPersp ;
// ricalcolo i parametri di vista
m_bDistOk = false ;
CalcDistCamera() ;
CalcClippingPlanesFromExtView() ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::SetZoomType( int nZoomMode)
{
if ( nZoomMode != ZT_STD && nZoomMode != ZT_DOLLY)
return false ;
m_nPerspZoomType = nZoomMode ;
return true ;
}
//----------------------------------------------------------------------------
double
Scene::CalcMinCameraDistance()
{
double dMinDist = MIN_DIST_CAMERA ;
// nel caso di vista prospettica la distanza della camera deve garantire di non finire dentro gli oggetti
if ( ! m_bOrthographic) {
// calcolo il box di tutti gli oggetti visibili nel frame della camera
Frame3d frCamera ;
CalcCameraFrame( frCamera) ;
BBox3d b3Tot ;
if ( m_pGeomDB != nullptr)
m_pGeomDB->GetGlobalBBox( GDB_ID_ROOT, b3Tot, BBF_ONLY_VISIBLE) ;
b3Tot.ToLoc( frCamera) ;
// la distanza minima della camera è quella che garantisce di trovarsi ad una distanza pari almeno a PERSPECTIVE_NEAR_PLANE
// dalla faccia del box davanti alla camera
Point3d ptMax = b3Tot.GetMax() ;
ptMax.ToGlob( frCamera) ;
dMinDist = ( ptMax - m_ptCenter) * m_vtDirCamera + PERSPECTIVE_NEAR_PLANE + 10 * EPS_SMALL ;
}
return dMinDist ;
}
//----------------------------------------------------------------------------
bool
Scene::CalcDistCamera()
{
// verifico se il calcolo è necessario
if ( m_bDistOk)
return true ;
if ( m_dDistCamera < EPS_SMALL)
m_dDistCamera = STD_DIST_CAMERA ;
else {
double dMinDist = CalcMinCameraDistance() ;
if ( m_dDistCamera < dMinDist)
m_dDistCamera = dMinDist ;
}
m_bDistOk = true ;
return true ;
}
static const double MIN_HALF_WIDTH_STD = 0.7 ;
static const double MAX_HALF_WIDTH_STD = 180000 ;
static const double MIN_HALF_HEIGHT_STD = 0.5 ;
static const double MAX_HALF_HEIGHT_STD = 140000 ;
//----------------------------------------------------------------------------
bool
@@ -110,10 +46,9 @@ Scene::SetCenter( const Point3d& ptCenter)
bool
Scene::SetCamera( double dAngVertDeg, double dAngOrizzDeg, double dDist)
{
// assegno la direzione ed eventuale distanza
// assegno la direzione e la distanza
m_vtDirCamera = FromSpherical( 1, dAngVertDeg, dAngOrizzDeg) ;
if ( dDist > EPS_SMALL)
m_dDistCamera = dDist ;
m_dDistCamera = dDist ;
if ( ! VerifyCamera())
return false ;
// se vista da sopra, impongo vtUp da angolo orizzontale
@@ -173,11 +108,7 @@ Scene::SetCamera( int nDir, double dDist)
}
if ( nDir != CT_CPLANE)
m_vtDirCamera.Rotate( Z_AX, m_nOrizzOffsCamera * ANG_RIGHT) ;
// assegno eventuale distanza
if ( dDist > EPS_SMALL)
m_dDistCamera = dDist ;
m_dDistCamera = dDist ;
return VerifyCamera( nDir != CT_CPLANE) ;
}
@@ -188,16 +119,15 @@ Scene::VerifyCamera( bool bUseOrizzOffsCamera)
// verifico il versore
if ( ! m_vtDirCamera.Normalize())
m_vtDirCamera.Set( 0, 0, 1) ;
// verifico la distanza
if ( m_dDistCamera < EPS_SMALL)
m_dDistCamera = STD_DIST_CAMERA ;
else
m_dDistCamera = max( m_dDistCamera, MIN_DIST_CAMERA) ;
// ricalcolo direzione Up
m_bUpOk = false ;
if ( ! CalcDirUp( bUseOrizzOffsCamera))
return false ;
// verifico la distanza
m_bDistOk = false ;
CalcDistCamera() ;
// ricalcolo ExtView
m_bExtViewOk = false ;
if ( ! CalcExtView())
@@ -278,11 +208,11 @@ Scene::GetProjectedCenter( void) const
bool
Scene::CalcDirUp( bool bUseOrizzOffsCamera)
{
// verifico se il calcolo è necessario
// verifico se il calcolo è necessario
if ( m_bUpOk)
return true ;
// direzione perpendicolare giacente nel piano XY
// ( m_vtDirCamera è opposta alla direzione in cui si guarda)
// ( m_vtDirCamera è opposta alla direzione in cui si guarda)
Vector3d vtPerpXY = m_vtDirCamera ^ Z_AX ;
if ( ! vtPerpXY.Normalize()) {
vtPerpXY = -X_AX ;
@@ -319,29 +249,19 @@ bool
Scene::PanCamera( const Point3d& ptWinOld, const Point3d& ptWinNew)
{
// porto i due punti in coordinate mondo
double dOldZCenter ;
GetPixelZ( ptWinOld, dOldZCenter) ;
Point3d ptViewOld( ptWinOld.x, ptWinOld.y, dOldZCenter) ;
double dZCenter = GetProjectedCenter().z ;
Point3d ptViewOld( ptWinOld.x, ptWinOld.y, dZCenter) ;
Point3d ptWorldOld ;
if ( ! UnProject( ptViewOld, ptWorldOld))
return false ;
double dNewZCenter ;
GetPixelZ( ptWinNew, dNewZCenter) ;
Point3d ptViewNew( ptWinNew.x, ptWinNew.y, dNewZCenter) ;
Point3d ptViewNew( ptWinNew.x, ptWinNew.y, dZCenter) ;
Point3d ptWorldNew ;
if ( ! UnProject( ptViewNew, ptWorldNew))
return false ;
// calcolo lo spostamento tra i due punti
Vector3d vtMove = ptWorldNew - ptWorldOld ;
// applico questo spostamento al centro di vista
SetCenter( GetCenter() - vtMove) ;
// se dolly aggiusto la distanza per non entrare negli oggetti
if ( ! m_bOrthographic && m_nPerspZoomType == ZT_DOLLY)
CalcDistCamera() ;
else
m_bDistOk = true ;
return true ;
return SetCenter( GetCenter() - vtMove) ;
}
//----------------------------------------------------------------------------
@@ -387,31 +307,6 @@ Scene::ZoomAll( void)
// calcolo nuovi dati di ingombro
CalcDimViewFromExtView() ;
if ( ! m_bOrthographic) {
if ( m_nPerspZoomType == ZT_DOLLY) {
// adatto la distanza della camera in modo che il fov resti al valore standard
m_dDistCamera = m_dHalfHeight / tan( PERSPECTIVE_STD_FOV * 0.5 * DEGTORAD) + ( m_b3ExtView.GetMax().z - m_b3ExtView.GetMin().z) * 0.5 ;
}
else {
// aggiusto la distanza della camera
m_b3ExtView.GetDiameter( m_dDistCamera) ;
// il valore di m_dHalfHeight calcolato dal box non garantisce che l'oggetto sia interamente contenuto nel frustum
// perchè è il valore in corrispondenza della faccia del box davanti alla camera. Per il calcolo del fov m_dHalfHeight
// deve essere calcolato in corrispondenza di m_ptCenter
// distanza della camera dalla faccia davanti del box
double dDist = m_dDistCamera - ( m_b3ExtView.GetMax().z - m_b3ExtView.GetMin().z) * 0.5 ;
// aggiorno le dimensioni
double dAspect = m_dHalfWidth / m_dHalfHeight ;
m_dHalfHeight = m_dHalfHeight / dDist * m_dDistCamera ;
m_dHalfWidth = m_dHalfHeight * dAspect ;
}
}
// la distanza della camera è calcolata correttamente
m_bDistOk = true ;
CalcClippingPlanesFromExtView() ;
return true ;
@@ -454,32 +349,8 @@ Scene::ZoomObject( int nId)
double dHalfHeight = COEFF * ( b3Obj.GetMax().y - b3Obj.GetMin().y) / 2 ;
// imposto il centro e le dimensioni di vista
m_ptCenter = ptCent ;
if ( ! AdjustDimView( dHalfWidth, dHalfHeight))
return false ;
if ( ! m_bOrthographic) {
// cfr conti analoghi in ZoomAll
if ( m_nPerspZoomType == ZT_DOLLY) {
m_dDistCamera = m_dHalfHeight / tan( PERSPECTIVE_STD_FOV * 0.5 * DEGTORAD) + ( b3Obj.GetMax().z - b3Obj.GetMin().z) * 0.5 ;
}
else {
// verifico di non finire dentro l'oggetto
double dDiam ; b3Obj.GetDiameter( dDiam) ;
if ( m_dDistCamera < dDiam * 0.5)
m_dDistCamera = dDiam * 0.5 ;
// distanza della camera dalla faccia davanti del box
double dDist = m_dDistCamera - ( b3Obj.GetMax().z - b3Obj.GetMin().z) * 0.5 ;
// ricalcolo le dimensioni
double dAspect = m_dHalfWidth / m_dHalfHeight ;
m_dHalfHeight = m_dHalfHeight / dDist * m_dDistCamera ;
m_dHalfWidth = m_dHalfHeight * dAspect ;
}
}
// la distanza della camera è calcolata per non finire dentro gli oggetti
m_bDistOk = true ;
return true ;
m_ptCenter = ptCent ;
return AdjustDimView( dHalfWidth, dHalfHeight) ;
}
//----------------------------------------------------------------------------
@@ -487,19 +358,7 @@ bool
Scene::ZoomRadius( double dRadius)
{
// adatto le dimensioni a quelle della vista
if ( ! AdjustDimView( dRadius, dRadius))
return false ;
// per il dolly va modificata la distanza dalla camera
if ( ! m_bOrthographic && m_nPerspZoomType == ZT_DOLLY) {
m_dDistCamera = m_dHalfHeight / tan( PERSPECTIVE_STD_FOV * 0.5 * DEGTORAD) ;
// verifico la distanza della camera
CalcDistCamera() ;
}
else
m_bDistOk = true ;
return true ;
return AdjustDimView( dRadius, dRadius) ;
}
//----------------------------------------------------------------------------
@@ -509,17 +368,13 @@ Scene::ZoomChange( double dCoeff)
const double MIN_COEFF = 0.5 ;
const double MAX_COEFF = 2 ;
// cambio le dimensioni di zoom
if ( ! m_bOrthographic && m_nPerspZoomType == ZT_DOLLY) {
// per il dolly va modificata la distanza della camera
m_dDistCamera *= dCoeff ;
}
else {
// controllo i limiti
dCoeff = clamp( dCoeff, MIN_COEFF, MAX_COEFF) ;
m_dHalfWidth *= dCoeff ;
m_dHalfHeight *= dCoeff ;
}
// controllo i limiti
if ( dCoeff < MIN_COEFF)
dCoeff = MIN_COEFF ;
else if ( dCoeff > MAX_COEFF)
dCoeff = MAX_COEFF ;
m_dHalfWidth *= dCoeff ;
m_dHalfHeight *= dCoeff ;
return true ;
}
@@ -528,45 +383,31 @@ Scene::ZoomChange( double dCoeff)
bool
Scene::ZoomOnPoint( const Point3d& ptWin, double dCoeff)
{
// leggo Z del pixel
double dWinZ ;
GetPixelZ( ptWin, dWinZ) ;
// recupero la matrice viewport
GLint Viewport[4] ;
glGetIntegerv( GL_VIEWPORT, Viewport) ;
// range valori delle Viewport
double dLimInfHW = MIN_HALF_WIDTH_STD * Viewport[2] / 1152.0 ;
double dLimInfHH = MIN_HALF_HEIGHT_STD * Viewport[3] / 928.0 ;
double dLimSupHW = MAX_HALF_WIDTH_STD * Viewport[2] / 1152.0 ;
double dLimSupHH = MAX_HALF_WIDTH_STD * Viewport[3] / 928.0 ;
// controllo se i parametri di Zoom minimo e massimo sono rispettati, altrimenti esco
if ( m_dHalfWidth * dCoeff > dLimSupHW || m_dHalfHeight * dCoeff > dLimSupHH)
return true ;
if ( m_dHalfWidth * dCoeff < dLimInfHW || m_dHalfHeight * dCoeff < dLimInfHH)
return true ;
// porto il punto in coordinate mondo
Point3d ptView( ptWin.x, ptWin.y, dWinZ) ;
Point3d ptView( ptWin.x, ptWin.y, GetProjectedCenter().z) ;
Point3d ptWorld ;
if ( ! UnProject( ptView, ptWorld))
return false ;
// modifico opportunamente il centro di vista
Point3d ptOldCen = m_ptCenter ;
Point3d ptNewCen = ptWorld + ( m_ptCenter - ptWorld) * dCoeff ;
ptNewCen += ( ptWorld - ptNewCen) * m_vtDirCamera * m_vtDirCamera ;
Point3d ptNewCen = ptWorld + ( GetCenter() - ptWorld) * dCoeff ;
SetCenter( ptNewCen) ;
m_bDistOk = true ;
if ( ! m_bOrthographic) {
if ( m_nPerspZoomType == ZT_DOLLY) {
// nel caso di dolly verifico se il nuovo zoom fa entrare negli oggetti
double dMinDist = CalcMinCameraDistance() ;
if ( m_dDistCamera * dCoeff < dMinDist) {
// adatto il coefficiente di zoom e ricalcolo il centro
dCoeff = dMinDist / m_dDistCamera ;
Point3d ptNewCenter = ptWorld + ( ptOldCen - ptWorld) * dCoeff ;
SetCenter( ptNewCenter) ;
}
}
else {
// nel caso standard verifico se il nuovo fov supera il valore massimo
if ( m_dHalfHeight * dCoeff / m_dDistCamera > PERSPECTIVE_TAN_MAX_FOV) {
// adatto il coefficiente di zoom e ricalcolo il centro
dCoeff = PERSPECTIVE_TAN_MAX_FOV * m_dDistCamera / m_dHalfHeight ;
Point3d ptNewCenter = ptWorld + ( ptOldCen - ptWorld) * dCoeff ;
SetCenter( ptNewCenter) ;
}
}
}
// eseguo lo zoom
return ZoomChange( dCoeff) ;
}
@@ -600,18 +441,7 @@ Scene::ZoomWin( const Point3d& ptWin1, const Point3d& ptWin2)
double dHalfHeight = 0.5 * abs( ptView1.y - ptView2.y) ;
// adatto le dimensioni a quelle della vista
if ( ! AdjustDimView( dHalfWidth, dHalfHeight))
return false ;
// per il dolly va modificata la distanza della camera
if ( ! m_bOrthographic && m_nPerspZoomType == ZT_DOLLY) {
m_dDistCamera = m_dHalfHeight / tan( PERSPECTIVE_STD_FOV * 0.5 * DEGTORAD) ;
CalcDistCamera() ;
}
else
m_bDistOk = true ;
return true ;
return AdjustDimView( dHalfWidth, dHalfHeight) ;
}
//----------------------------------------------------------------------------
SceneGeom.cpp
+68 -134
View File
@@ -64,14 +64,6 @@ Scene::SetMark( Color colMark)
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::SetMark2( Color colMark)
{
m_colMark2 = colMark ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::SetSelSurf( Color colSelSurf)
@@ -143,7 +135,7 @@ Scene::DrawGroup( const IGdbIterator& iIter, int nPass, const MdStMkCol& cParent
Frame3d frFrame ;
if ( ! iIter.GetGroupFrame( frFrame))
return false ;
// se non è identità, lo aggiungo sullo stack delle matrici MODELVIEW di OpenGL
// se non è identità, lo aggiungo sullo stack delle matrici MODELVIEW di OpenGL
bool bMatrix = ( frFrame.GetType() != Frame3d::TOP || ! frFrame.Orig().IsSmall()) ;
if ( bMatrix) {
glPushMatrix() ;
@@ -174,7 +166,7 @@ Scene::DrawGroup( const IGdbIterator& iIter, int nPass, const MdStMkCol& cParent
// recupero e aggiorno il colore dell'oggetto
Color colObj = cParent.colObj ;
pIter->GetMaterial( colObj) ;
// se in modalità selezione, verifico sia selezionabile
// se in modalità selezione, verifico sia selezionabile
bool bSel = true ;
if ( m_bSelect && UnselectableFind( pIter->GetId()))
bSel = false ;
@@ -228,10 +220,6 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
// recupero eventuale parte custom
const IUserObj* pUserObj = iIter.GetUserObj() ;
// numero di colori per TriMesh e Zmap
const int STM_COL = 2 ;
const int ZMAP_COL = 2 ;
// se non esiste grafica associata, la creo
if ( pGeoObj->GetObjGraphics() == nullptr) {
// oggetto grafico molteplice solo per Zmap o superfici che lo richiedono
@@ -240,25 +228,17 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
const IVolZmap* pZmap = GetVolZmap( pGeoObj) ;
if ( pZmap != nullptr) {
if ( ( m_nShowZmap & ZSM_SURF) != 0)
nCount += ZMAP_COL * pZmap->GetBlockCount() ;
nCount += 2 * pZmap->GetBlockCount() ;
if ( ( m_nShowZmap & ZSM_LINES) != 0 || ( m_nShowZmap & ZSM_NORMALS) != 0)
nCount += 1 ;
if ( pZmap->GetShowEdges())
nCount += 1 ;
}
}
else if (( nGeoType & GEO_SURF) != 0) {
const ISurfTriMesh* pSTM = GetSurfTriMeshAux( pGeoObj) ;
if ( pSTM != nullptr) {
if ( pSTM->GetMaxTFlag() > 0)
nCount = STM_COL ;
else
nCount = 1 ;
if ( pSTM->GetShowEdges())
nCount += 1 ;
}
if ( pSTM != nullptr && pSTM->GetMaxTFlag() > 0)
nCount = 2 ;
}
// nuova modalità grafica solo per superfici e testi con molti triangoli o solidi Zmap
// 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) {
@@ -283,7 +263,7 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
pGeoObj->SetObjGraphics( pGraphics) ;
}
// se la grafica associata non è valida la ricalcolo
// se la grafica associata non è valida la ricalcolo
ObjEGrGraphics* pGraphics = GetObjEGrGraphics( pGeoObj) ;
if ( ! pGraphics->IsValid()) {
const double ANG_TOL_GRAPH_DEG = 15 ;
@@ -386,14 +366,11 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
if ( pSTM == nullptr)
return false ;
// superficie con visualizzazione standard
bool bTwoColors = ( pSTM->GetMaxTFlag() > 0) ;
if ( ! bTwoColors) {
if ( pSTM->GetMaxTFlag() == 0) {
// recupero il materiale
Material mMat ;
if ( ! iIter.GetCalcMaterial( mMat))
mMat.Set( m_colDef) ;
// Imposto indice blocco corrente
pGraphics->SetCurrent( 0) ;
// pulisco
pGraphics->Clear() ;
// se ci sono triangoli
@@ -419,11 +396,11 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
}
pGraphics->EndTriangles() ;
}
else
pGraphics->Validate() ;
}
// altrimenti superficie con due colori
else {
// numero di colori
const int STM_COL = 2 ;
// definizione materiali
Material mMat[STM_COL] ;
Color cCol[STM_COL] ;
@@ -431,7 +408,7 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
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)
// secondo materiale per parti modificate (tonalità spostata di +22.5 deg)
cCol[1] = cCol[0] ;
mMat[1] = mMat[0] ;
HSV hsv = GetHSVFromColor( siObj.colObj) ;
@@ -448,13 +425,12 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
// Ciclo sui colori
for ( int j = 0 ; j < STM_COL ; ++ j) {
// Imposto indice blocco corrente
if ( pGraphics->SetCurrent( j))
pGraphics->Clear() ;
pGraphics->SetCurrent( j) ;
// lo pulisco
pGraphics->Clear() ;
// se non ci sono triangoli, passo oltre
if ( nTri[j] == 0) {
pGraphics->Validate() ;
if ( nTri[j] == 0)
continue ;
}
// assegno materiali
pGraphics->AddColor( cCol[j]) ; // per wireframe
pGraphics->AddMaterial( mMat[j].GetAmbient(), mMat[j].GetDiffuse(),
@@ -478,28 +454,6 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
pGraphics->EndTriangles() ;
}
}
// eventuali spigoli vivi
if ( pSTM->GetShowEdges()) {
if ( pGraphics->SetCurrent( bTwoColors ? 2 : 1))
pGraphics->Clear() ;
int nEdgCnt = pSTM->GetEdgeCount() ;
if ( nEdgCnt > 0) {
pGraphics->AddColor( DGRAY) ;
pGraphics->AddMaterial( DGRAY, DGRAY, DGRAY, 10) ;
pGraphics->AddBackMaterial( DGRAY) ;
PNTVECTOR vPnt ; vPnt.reserve( 2 * nEdgCnt) ;
for ( int i = 0 ; i < nEdgCnt ; ++i) {
Point3d ptP1, ptP2 ;
double dAng ;
if ( pSTM->GetEdge( i, ptP1, ptP2, dAng) &&
abs( dAng) > pSTM->GetSmoothAngle()) {
vPnt.emplace_back( ptP1) ;
vPnt.emplace_back( ptP2) ;
}
}
pGraphics->AddLines( vPnt, false, true) ;
}
}
}
// se Zmap
else if ( nGeoType == VOL_ZMAP) {
@@ -509,6 +463,8 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
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
@@ -520,9 +476,9 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
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)
// secondo materiale per parti lavorate (tonalità spostata di +22.5 deg)
cCol[1] = cCol[0] ;
mMat[1] = mMat[0] ;
mMat[1] = mMat[0] ;
// se richiesto diverso
if ( ( m_nShowZmap & ZSM_COLORS) != 0) {
HSV hsv = GetHSVFromColor( siObj.colObj) ;
@@ -536,9 +492,9 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
// Ciclo sui blocchi
nCount = pZmap->GetBlockCount() ;
for ( int i = 0 ; i < nCount ; ++ i) {
// Se blocco non esistente o già aggiornato, vado oltre
if ( ! pGraphics->SetCurrent( ZMAP_COL * i) ||
pZmap->GetBlockUpdatingCounter( i) <= pGraphics->GetCounter())
// 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 ;
@@ -553,9 +509,8 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
}
// Ciclo sui colori
for ( int j = 0 ; j < ZMAP_COL ; ++ j) {
// Imposto indice blocco corrente, se non esiste passo oltre
if ( ! pGraphics->SetCurrent( ZMAP_COL * i + j))
continue ;
// Imposto indice blocco corrente
pGraphics->SetCurrent( ZMAP_COL * i + j) ;
// lo pulisco
pGraphics->Clear() ;
// se non ci sono triangoli, passo oltre
@@ -583,68 +538,46 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
}
}
// visualizzazione spilloni e normali (sempre nell'ultimo blocco)
bool bLinNrmShow = ( ( m_nShowZmap & ZSM_LINES) != 0 || ( m_nShowZmap & ZSM_NORMALS) != 0) ;
if ( bLinNrmShow) {
if ( ( m_nShowZmap & ZSM_LINES) != 0 || ( m_nShowZmap & ZSM_NORMALS) != 0) {
// imposto indice blocco corrente
if ( 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) ;
}
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) ;
}
}
}
// eventuali spigoli vivi
if ( pZmap->GetShowEdges()) {
// imposto indice blocco corrente
if ( pGraphics->SetCurrent( ZMAP_COL * nCount + ( bLinNrmShow ? 1 : 0))) {
// lo pulisco
pGraphics->Clear() ;
// inserisco le curve
ICURVEPOVECTOR vpCurve ;
if ( pZmap->GetEdges( vpCurve) && ! vpCurve.empty()) {
pGraphics->AddColor( DGRAY) ;
pGraphics->AddMaterial( DGRAY, DGRAY, DGRAY, 10) ;
pGraphics->AddBackMaterial( DGRAY) ;
for ( const auto& pCrv : vpCurve) {
PolyLine PL ;
if ( pCrv->ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_GRAPH_DEG, ICurve::APL_SPECIAL, PL))
pGraphics->AddPolyLine( PL, false, true) ;
}
}
else {
if ( j == 0)
bOutBreak = true ;
break ;
}
}
if ( bOutBreak)
break ;
}
if ( vPnt.size() > 0)
pGraphics->AddLines( vPnt) ;
}
}
}
@@ -729,7 +662,7 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
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)
// 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
@@ -743,7 +676,7 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
return true ;
}
// se shading e non modalità selezione
// 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
@@ -841,7 +774,6 @@ Scene::DrawAlphaSurfVector( void)
[]( const AlphaSurf& a, const AlphaSurf&b) { return a.dZmax < b.dZmax ; }) ;
// eseguo visualizzazione
bool bOk = true ;
for ( const auto& AlphaSurf : m_vAlphaSurf) {
// imposto matrice MODELVIEW
double Matrix[OGLMAT_DIM] ;
@@ -849,13 +781,15 @@ Scene::DrawAlphaSurfVector( void)
glPushMatrix() ;
glLoadMatrixd( Matrix) ;
// eseguo visualizzazione
if ( ! AlphaSurf.pGraph->Draw( AlphaSurf.nStat, AlphaSurf.nMark, true,
AlphaSurf.bSurf, AlphaSurf.nAlpha, AlphaSurf.bShowAux))
bOk = false ;
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 bOk ;
return true ;
}
//----------------------------------------------------------------------------
SceneGlobCube.cpp
+770
View File
@@ -0,0 +1,770 @@
//----------------------------------------------------------------------------
// EgalTech 2022
//----------------------------------------------------------------------------
// File : SceneGlobCube.cpp Data : 10.10.22 Versione : 1
// Contenuto : Implementazione gestione e disegno Cubetto per viste.
//
//
//
// Modifiche : 11.10.22 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "Scene.h"
#include "EGrUtils.h"
#include "ObjOldGraphics.h"
#include "ObjNewGraphics.h"
#include "ObjMultiGraphics.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EGkGeomDB.h"
#include "/EgtDev/Include/EGkObjGraphics.h"
using namespace std ;
// posizione X e Y dello schermo
const double MIN_EDGE_SIZE = 20 ;
const double MAX_EDGE_SIZE = 200.0 ;
// colore render dei bordi delle superifici del cubo
const Color CUBE_LINES( 0, 0, 0, 1) ;
// angolo di tolleranza per rotazioni con vettori quasi paralleli
const double ANG_ROT_TOLL = 5 ;
//----------------------------------------------------------------------------
bool
Scene::CreateFlatPart( ISurfTriMesh* pSrf)
{
// vertici
pSrf->AddVertex( Point3d( 0.33 * m_dCubeEdge, 0.33 * m_dCubeEdge, 0)),
pSrf->AddVertex( Point3d( - 0.33 * m_dCubeEdge, 0.33 * m_dCubeEdge, 0)) ;
pSrf->AddVertex( Point3d( - 0.33 * m_dCubeEdge, - 0.33 * m_dCubeEdge, 0)) ;
pSrf->AddVertex( Point3d( 0.33 * m_dCubeEdge, - 0.33 * m_dCubeEdge, 0)) ;
// triangoli
int nNewInd_0[3] = { 0, 1, 2} ;
pSrf->AddTriangle( nNewInd_0) ;
int nNewInd_1[3] = { 0, 2, 3} ;
pSrf->AddTriangle( nNewInd_1) ;
// verifico
pSrf->DoCompacting() ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::CreateEdgePart( ISurfTriMesh* pSrf)
{
// vertici
pSrf->AddVertex( Point3d( 0.33 * m_dCubeEdge, - 0.085 * m_dCubeEdge, 0)) ;
pSrf->AddVertex( Point3d( - 0.33 * m_dCubeEdge, - 0.085 * m_dCubeEdge, 0)) ;
pSrf->AddVertex( Point3d( - 0.33 * m_dCubeEdge, 0, - 0.085 * m_dCubeEdge)) ;
pSrf->AddVertex( Point3d( 0.33 * m_dCubeEdge, 0, - 0.085 * m_dCubeEdge)) ;
pSrf->AddVertex( Point3d( - 0.33 * m_dCubeEdge, 0.085 * m_dCubeEdge, - 0.17 * m_dCubeEdge)) ;
pSrf->AddVertex( Point3d( 0.33 * m_dCubeEdge, 0.085 * m_dCubeEdge, - 0.17 * m_dCubeEdge)) ;
// triangoli
int nNewInd_0[3] = { 2, 1 ,0} ;
pSrf->AddTriangle( nNewInd_0) ;
int nNewInd_1[3] = { 3, 2, 0} ;
pSrf->AddTriangle( nNewInd_1) ;
int nNewInd_2[3] = { 2, 5, 4} ;
pSrf->AddTriangle( nNewInd_2) ;
int nNewInd_3[3] = { 2, 3, 5} ;
pSrf->AddTriangle( nNewInd_3) ;
// verifico
pSrf->DoCompacting() ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::CreateCornerPart( ISurfTriMesh* pSrf)
{
// vertici
pSrf->AddVertex( Point3d( - 0.085 * m_dCubeEdge, 0.085 * m_dCubeEdge, -0.17 * m_dCubeEdge)) ;
pSrf->AddVertex( Point3d( - 0.085 * m_dCubeEdge, - 0.085 * m_dCubeEdge, 0)) ;
pSrf->AddVertex( Point3d( 0.085 * m_dCubeEdge, - 0.085 * m_dCubeEdge, - 0.17 * m_dCubeEdge)) ;
// triangoli
int nNewInd_0[3] = { 0, 1, 2} ;
pSrf->AddTriangle( nNewInd_0) ;
// verifico
pSrf->DoCompacting() ;
return true ;
}
//----------------------------------------------------------------------------
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) ;
}
//----------------------------------------------------------------------------
bool
Scene::DrawCube( bool bSurf)
{
// recupero la matrice viewport
GLint Viewport[4] ;
glGetIntegerv( GL_VIEWPORT, Viewport) ;
// se il vettore delle superifici č vuoto, allora lo creo
if ( m_vStm_Cube.empty()) {
// Z+ -> 1 -> TOP
PtrOwner<ISurfTriMesh> pStm_Zp( CreateSurfTriMesh()) ;
CreateFlatPart( pStm_Zp) ;
pStm_Zp->Translate( Vector3d( 0, 0, 0.5 * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_Zp)) ;
// Z- -> 2 -> BOTTOM
PtrOwner<ISurfTriMesh> pStm_Zm( CreateSurfTriMesh()) ;
CreateFlatPart( pStm_Zm) ;
pStm_Zm->Rotate( ORIG, Y_AX, 180) ;
pStm_Zm->Translate( Vector3d( 0, 0, - 0.5 * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_Zm)) ;
// X+ -> 3 -> RIGHT
PtrOwner<ISurfTriMesh> pStm_Xp( CreateSurfTriMesh()) ;
CreateFlatPart( pStm_Xp) ;
pStm_Xp->Rotate( ORIG, Y_AX, 180) ;
pStm_Xp->Rotate( ORIG, -Y_AX, 90) ;
pStm_Xp->Translate( Vector3d( 0.5 * m_dCubeEdge, 0, 0)) ;
m_vStm_Cube.emplace_back( Release( pStm_Xp)) ;
// X- -> 4 -> LEFT
PtrOwner<ISurfTriMesh> pStm_Xm( CreateSurfTriMesh()) ;
CreateFlatPart( pStm_Xm) ;
pStm_Xm->Rotate( ORIG, -Y_AX, 90) ;
pStm_Xm->Translate( Vector3d( -0.5 * m_dCubeEdge, 0, 0)) ;
m_vStm_Cube.emplace_back( Release( pStm_Xm)) ;
// Y+ -> 5 -> FRONT
PtrOwner<ISurfTriMesh> pStm_Yp( CreateSurfTriMesh()) ;
CreateFlatPart( pStm_Yp) ;
pStm_Yp->Rotate( ORIG, -X_AX, 90) ;
pStm_Yp->Translate( Vector3d( 0, 0.5 * m_dCubeEdge, 0)) ;
m_vStm_Cube.emplace_back( Release( pStm_Yp)) ;
// Y- -> 6 -> BACK
PtrOwner<ISurfTriMesh> pStm_Ym( CreateSurfTriMesh()) ;
CreateFlatPart( pStm_Ym) ;
pStm_Ym->Rotate( ORIG, Y_AX, 180) ;
pStm_Ym->Rotate( ORIG, -X_AX, 90) ;
pStm_Ym->Translate( Vector3d( 0, -0.5 * m_dCubeEdge, 0)) ;
m_vStm_Cube.emplace_back( Release( pStm_Ym)) ;
// Z+X+ -> 7 -> TOP-RIGHT
PtrOwner<ISurfTriMesh> pStm_ZpXp( CreateSurfTriMesh()) ;
CreateEdgePart( pStm_ZpXp) ;
pStm_ZpXp->Rotate( ORIG, -Z_AX, 90) ;
pStm_ZpXp->Translate( Vector3d(( 0.5 - 0.085) * m_dCubeEdge , 0, 0.5 * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_ZpXp)) ;
// Z+X- -> 8 -> TOP-LEFT
PtrOwner<ISurfTriMesh> pStm_ZpXm( CreateSurfTriMesh()) ;
CreateEdgePart( pStm_ZpXm) ;
pStm_ZpXm->Rotate( ORIG, Z_AX, 90) ;
pStm_ZpXm->Translate( Vector3d(( - 0.5 + 0.085) * m_dCubeEdge, 0, 0.5 * m_dCubeEdge));
m_vStm_Cube.emplace_back( Release( pStm_ZpXm)) ;
// Z-X+ -> 9 -> BOTTOM-RIGHT
PtrOwner<ISurfTriMesh> pStm_ZmXp( CreateSurfTriMesh()) ;
CreateEdgePart( pStm_ZmXp) ;
pStm_ZmXp->Rotate( ORIG, -Z_AX, 90) ;
pStm_ZmXp->Rotate( ORIG, Y_AX, 90) ;
pStm_ZmXp->Translate( Vector3d( 0.5 * m_dCubeEdge, 0,( - 0.5 + 0.085) * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_ZmXp)) ;
// Z-X- -> 10 -> BOTTOM-LEFT
PtrOwner<ISurfTriMesh> pStm_ZmXm( CreateSurfTriMesh()) ;
CreateEdgePart( pStm_ZmXm) ;
pStm_ZmXm->Rotate( ORIG, Z_AX, 90) ;
pStm_ZmXm->Rotate( ORIG, -Y_AX, 90) ;
pStm_ZmXm->Translate( Vector3d( - 0.5 * m_dCubeEdge, 0, ( - 0.5 + 0.085) * m_dCubeEdge)) ;;
m_vStm_Cube.emplace_back( Release( pStm_ZmXm)) ;
// Z+Y+ -> 11 -> TOP-FRONT
PtrOwner<ISurfTriMesh> pStm_ZpYp( CreateSurfTriMesh()) ;
CreateEdgePart( pStm_ZpYp) ;
pStm_ZpYp->Translate( Vector3d( 0, ( 0.5 - 0.085) * m_dCubeEdge, 0.5 * m_dCubeEdge)) ;
pStm_ZpYp->SetTempProp( 5, 0) ;
m_vStm_Cube.emplace_back( Release( pStm_ZpYp)) ;
// Z+Y- -> 12 -> TOP-BACK
PtrOwner<ISurfTriMesh> pStm_ZpYm( CreateSurfTriMesh()) ;
CreateEdgePart( pStm_ZpYm) ;
pStm_ZpYm->Rotate( ORIG, -Z_AX, 180) ;
pStm_ZpYm->Translate( Vector3d( 0, ( - 0.5 + 0.085) * m_dCubeEdge, 0.5 * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_ZpYm)) ;
// Z-Y+ -> 13 -> BOTTOM-FRONT
PtrOwner<ISurfTriMesh> pStm_ZmYp( CreateSurfTriMesh()) ;
CreateEdgePart( pStm_ZmYp) ;
pStm_ZmYp->Rotate( ORIG, -X_AX, 90) ;
pStm_ZmYp->Translate( Vector3d( 0, ( 0.5) * m_dCubeEdge ,
( - 0.5 + 0.085) * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_ZmYp)) ;
// Z-Y- -> 14 -> BOTTOM-BACK
PtrOwner<ISurfTriMesh> pStm_ZmYm( CreateSurfTriMesh()) ;
CreateEdgePart( pStm_ZmYm) ;
pStm_ZmYm->Rotate( ORIG, -Z_AX, 180) ;
pStm_ZmYm->Rotate( ORIG, X_AX, 90) ;
pStm_ZmYm->Translate( Vector3d( 0, - 0.5 * m_dCubeEdge, ( - 0.5 + 0.085) * m_dCubeEdge )) ;
m_vStm_Cube.emplace_back( Release( pStm_ZmYm)) ;
// X+Y+ -> 15 -> RIGHT-FRONT
PtrOwner<ISurfTriMesh> pStm_XpYp( CreateSurfTriMesh()) ;
CreateEdgePart( pStm_XpYp) ;
pStm_XpYp->Rotate( ORIG, Y_AX, 90) ;
pStm_XpYp->Translate( Vector3d( 0.5 * m_dCubeEdge,( 0.5 - 0.085) * m_dCubeEdge, 0)) ;
m_vStm_Cube.emplace_back( Release( pStm_XpYp)) ;
// X-Y+ -> 16 -> LEFT-FRONT
PtrOwner<ISurfTriMesh> pStm_XmYp( CreateSurfTriMesh()) ;
CreateEdgePart( pStm_XmYp) ;
pStm_XmYp->Rotate( ORIG, -Y_AX, 90) ;
pStm_XmYp->Translate( Vector3d( - 0.5 * m_dCubeEdge, ( 0.5 - 0.085) * m_dCubeEdge, 0)) ;
m_vStm_Cube.emplace_back( Release( pStm_XmYp)) ;
// X+Y- -> 17 -> RIGHT-BACK
PtrOwner<ISurfTriMesh> pStm_XpYm( CreateSurfTriMesh()) ;
CreateEdgePart( pStm_XpYm) ;
pStm_XpYm->Rotate( ORIG, -Y_AX, 90) ;
pStm_XpYm->Rotate( ORIG, Z_AX, 180) ;
pStm_XpYm->Translate( Vector3d( 0.5 * m_dCubeEdge, ( - 0.5 + 0.085) * m_dCubeEdge , 0)) ;
m_vStm_Cube.emplace_back( Release( pStm_XpYm)) ;
// X-Y- -> 18 -> LEFT-BACK
PtrOwner<ISurfTriMesh> pStm_XmYm( CreateSurfTriMesh()) ;
CreateEdgePart( pStm_XmYm) ;
pStm_XmYm->Rotate( ORIG, Y_AX, 90) ;
pStm_XmYm->Rotate( ORIG, Z_AX, 180) ;
pStm_XmYm->Translate( Vector3d( - 0.5 * m_dCubeEdge,- ( 0.5 - 0.085) * m_dCubeEdge, 0)) ;
m_vStm_Cube.emplace_back( Release( pStm_XmYm)) ;
// Z+X+Y+ -> 19 -> TOP-RIGHT-FRONT
PtrOwner<ISurfTriMesh> pStm_XpYpZp( CreateSurfTriMesh()) ;
CreateCornerPart( pStm_XpYpZp ) ;
pStm_XpYpZp->Translate( Vector3d(( 0.5 - 0.085) * m_dCubeEdge, ( 0.5 - 0.085) * m_dCubeEdge, 0.5 * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_XpYpZp)) ;
// Z+X-Y+ -> 20 -> TOP-LEFT-FRONT
PtrOwner<ISurfTriMesh> pStm_XmYpZp( CreateSurfTriMesh()) ;
CreateCornerPart( pStm_XmYpZp) ;
pStm_XmYpZp->Rotate( ORIG, Z_AX, 90) ;
pStm_XmYpZp->Translate( Vector3d(( - 0.5 + 0.085) * m_dCubeEdge,( 0.5 - 0.085) * m_dCubeEdge,0.5 * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_XmYpZp)) ;
// Z+X+Y- -> 21 -> TOP-RIGHT-BACK
PtrOwner<ISurfTriMesh> pStm_XpYmZp( CreateSurfTriMesh()) ;
CreateCornerPart( pStm_XpYmZp) ;
pStm_XpYmZp->Rotate( ORIG, -Z_AX, 90) ;
pStm_XpYmZp->Translate( Vector3d(( + 0.5 - 0.085) * m_dCubeEdge, ( - 0.5 + 0.085) * m_dCubeEdge,0.5 * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_XpYmZp)) ;
// Z+X-Y- -> 22 -> TOP-LEFT-BACK
PtrOwner<ISurfTriMesh> pStm_XmYmZp( CreateSurfTriMesh()) ;
CreateCornerPart( pStm_XmYmZp) ;
pStm_XmYmZp->Rotate( ORIG, Z_AX, 180) ;
pStm_XmYmZp->Translate( Vector3d(( - 0.5 + 0.085) * m_dCubeEdge, ( - 0.5 + 0.085) * m_dCubeEdge, 0.5 * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_XmYmZp)) ;
// Z-X+Y+ -> 23 -> BOTTOM-RIGHT-FRONT
PtrOwner<ISurfTriMesh> pStm_XpYpZm( CreateSurfTriMesh()) ;
CreateCornerPart( pStm_XpYpZm) ;
pStm_XpYpZm->Rotate( ORIG, X_AX, 180) ;
pStm_XpYpZm->Rotate( ORIG, Z_AX, 90) ;
pStm_XpYpZm->Translate( Vector3d(( 0.5 - 0.085) * m_dCubeEdge, ( 0.5 - 0.085) * m_dCubeEdge, - 0.5 * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_XpYpZm)) ;
// Z-X-Y+ -> 24 -> BOTTOM-LEFT-FRONT
PtrOwner<ISurfTriMesh> pStm_XmYpZm( CreateSurfTriMesh()) ;
CreateCornerPart( pStm_XmYpZm) ;
pStm_XmYpZm->Rotate(ORIG, -X_AX, 90) ;
pStm_XmYpZm->Rotate( ORIG, Z_AX, 90) ;
pStm_XmYpZm->Translate( Vector3d( - 0.5 * m_dCubeEdge, ( 0.5 - 0.085) * m_dCubeEdge,( - 0.5 + 0.085) * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_XmYpZm)) ;
// Z-X+Y- -> 25 -> BOTTOM-RIGHT-BACK
PtrOwner<ISurfTriMesh> pStm_XpYmZm( CreateSurfTriMesh()) ;
CreateCornerPart( pStm_XpYmZm) ;
pStm_XpYmZm->Rotate( ORIG, X_AX, 180) ;
pStm_XpYmZm->Translate( Vector3d(( + 0.5 - 0.085) * m_dCubeEdge, ( - 0.5 + 0.085) * m_dCubeEdge, - 0.5 * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_XpYmZm)) ;
// Z-X-Y- -> 26 -> BOTTOM-LEFT-BACK
PtrOwner<ISurfTriMesh> pStm_XmYmZm( CreateSurfTriMesh()) ;
CreateCornerPart( pStm_XmYmZm) ;
pStm_XmYmZm->Rotate( ORIG, X_AX, 180) ;
pStm_XmYmZm->Rotate( ORIG, -Z_AX, 90) ;
pStm_XmYmZm->Translate( Vector3d(( - 0.5 + 0.085) * m_dCubeEdge, ( - 0.5 + 0.085) * m_dCubeEdge, - 0.5 * m_dCubeEdge)) ;
m_vStm_Cube.emplace_back( Release( pStm_XmYmZm)) ;
}
// creo un vettore di Graphics, uno per ogni superificie del cubetto
vector<PtrOwner<ObjEGrGraphics>> vGraphics ;
for ( int i = 0 ; i < 26 ; ++ i) {
PtrOwner<ObjEGrGraphics> pNewGraphics( CreateObjEGrGraphics( 0, false)) ;
vGraphics.emplace_back( Release( pNewGraphics)) ;
vGraphics[i]->SetScene( this) ;
}
// render delle superifici del cubo ( superfici o Linee a seconda del Flag)
for ( int s = 0 ; s < 26 ; ++ s) {
// recupero la superificie corrente del cubo da visualizzare
PtrOwner<ISurfTriMesh> pStmCurr( CloneSurfTriMesh( m_vStm_Cube[s])) ;
if ( IsNull( pStmCurr))
return false ;
// scalo la superificie a seconda della viewport corrente ( per Zoom)
pStmCurr->Scale( GLOB_FRM, ( 2 * m_dHalfWidth) / Viewport[2], ( 2 * m_dHalfWidth) / Viewport[2],
( 2 * m_dHalfWidth) / Viewport[2]) ;
// sposto la superificie nel sistema di riferimento relativo alla telecamera ( per Pan)
pStmCurr->Translate(( m_ptOrigCube - ORIG)) ;
// definisco colori per i vertici e colore per le linee
Color cCol_Vertex ;
Color cCol_Line = CUBE_LINES ;
switch ( s) {
case 0 :
cCol_Vertex = m_cColZ ; break ;
case 1 :
cCol_Vertex = m_cColZm ; break ;
case 2 :
cCol_Vertex = m_cColX ; break ;
case 3 :
cCol_Vertex = m_cColXm ; break ;
case 4 :
cCol_Vertex = m_cColY ; break ;
case 5 :
cCol_Vertex = m_cColYm ; break ;
break ;
case 6 : case 7 : case 8 : case 9 : case 10 : case 11 :
case 12 : case 13 : case 14 : case 15 : case 16 : case 17 :
cCol_Vertex = m_cColEdge ; break ;
case 18 : case 19 : case 20 : case 21: case 22: case 23 : case 24 : case 25 :
cCol_Vertex = m_cColCorner ; break ;
default :
break ;
}
vGraphics[s]->AddColor( bSurf ? cCol_Vertex : CUBE_LINES) ;
int nTria = pStmCurr->GetTriangleCount() ;
vGraphics[s]->StartTriangles( nTria) ;
Triangle3dEx Tria ;
int nId = pStmCurr->GetFirstTriangle( Tria) ;
while ( nId != SVT_NULL) {
// edge solo se boundary e normali ai vertici smussate
vGraphics[s]->AddTriangle( Tria, Tria.GetTriFlags(), Tria.GetTriNormals()) ;
nId = pStmCurr->GetNextTriangle( nId, Tria) ;
}
vGraphics[s]->EndTriangles() ;
// assegno un id temporaneo alla superificie caricata ( modalita wireFrame, come nella Select)
if ( ! bSurf)
glLoadName( m_nStartFaceId + s + 1) ;
vGraphics[s]->Draw( GDB_ST_ON, GDB_MK_OFF, true, true, 80, false) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::DrawGlobCube( bool bSurf)
{
// se non devo disegnare il cubetto, esco
if ( ! m_bShowGlobCube)
return true ;
// recupero il primo Id libero ( e aggiungo 1000)
m_nStartFaceId = m_pGeomDB->GetNewId() + 1000 ;
// recupero la matrice viewport
GLint Viewport[4] ;
glGetIntegerv( GL_VIEWPORT, Viewport) ;
// imposto il riferimento
glPushMatrix() ;
// se sono in selezione il cubo lo lascio nella posizione precedente ( cambio di viewport => cambio centro del cubo)
Point3d ptOrig ;
if ( m_bSelect)
ptOrig = m_ptOrigCube ;
else {
UnProject( Point3d( m_dCubeX, m_dCubeY, 0.25), ptOrig) ; // posizione Z del cubo sempre 0.25 dallo schermo
m_ptOrigCube = ptOrig ;
}
// creo il cubo
if ( ! DrawCube( bSurf))
return true ;
// tolgo lo stack dei nomi in modalitŕ selezione
if ( m_bSelect)
glLoadName( 0) ;
// ripristino lo stack delle matrici
glPopMatrix() ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::RotateCameraWithCube()
{
// controllo se il cubetto č abilitato e ho almeno un Id dalla selezione nel buffer
if ( ! m_bShowGlobCube || m_nSelNbr == 0)
return false ;
// controllo che la selezione non sia avvenuta mediante Drag
if ( m_nSelW != 13 || m_nSelH != 13)
return false ;
// se ho piů di un elemento trovato, do prioritŕ alla superificie con piů facce
int nId = 0 ;
int nFace = 1 ;
bool bSelStm_Cube = false ;
for ( int i = 0 ; i < m_nSelNbr ; ++ i) {
// recupero l'Id corrente
int nCurrId = m_nSelBuff[i].nId ;
// controllo che l'Id appartenga ad una superificie del cubetto
if ( nCurrId <= m_nStartFaceId || nCurrId > m_nStartFaceId + 26)
continue ;
bSelStm_Cube = true ;
int nCurrFace = 1 ;
if ( nCurrId - m_nStartFaceId > 6 && nCurrId - m_nStartFaceId <= 18) // se superificie Edge
nCurrFace = 2 ;
else if ( nCurrId - m_nStartFaceId > 18) // se superificie Corner
nCurrFace = 3 ;
nFace = max( nFace, nCurrFace) ;
if ( nFace == 1 || nFace == nCurrFace)
nId = nCurrId ;
}
if ( ! bSelStm_Cube)
return false ;
// ottengo la faccia del cubo selezionato ( valore tra 1 e 26)
int nCubeface = nId - m_nStartFaceId ;
// prendo i parametri della telecamera
double dTheta, dPhi, dDist ;
GetCamera( &dPhi, &dTheta, &dDist) ;
double dPhi_orig = dPhi ;
double dTheta_orig = dTheta ;
// flag per numero di Step fatti e valore forzato di Theta per Z+ e Z-
bool bHasTwoStep = false ;
double dTheta_Forced = 0.0 ;
// imposto i nuovi angoli theta e phi mantenendo la distanza
if ( GetAngleByCubeFace( nCubeface, dTheta, dPhi)) {
// ricavo il vettore iniziale della telecamera
Vector3d v_q1 = m_vtDirCamera ;
// ricavo il vettore finale della telecamera
Vector3d v_q2 = FromSpherical( 1 , dPhi, dTheta) ;
// flag per rotazione necessaria o superflua
bool bDoRotation = true ;
// nuovi angoli nel caso di doppie rotazioni
double dTheta_new ; double dPhi_new ;
// controllo se voglio mettere la vista in Z+ o Z-
if ( AreSameOrOppositeVectorApprox( v_q2, Z_AX)) {
// controllo se sono giŕ in posizione questa posizione ( Z+ o Z-)
if ( AreSameVectorApprox( v_q1, v_q2)) {
// se sono giŕ orientato in maniera corretta non faccio nulla, altrimenti...
if ( abs( dTheta_orig - ( ANG_RIGHT - ANG_STRAIGHT)) > EPS_ANG_SMALL) {
Vector3d v_q1S = FromSpherical( 1, 90, dTheta_orig) ;
// ... ruoto la telecamera solo lungo theta
RotateCameraWithBlockedAngle( v_q1S, -Y_AX, dDist, true, 1, dTheta_orig, dPhi_orig, dTheta_new, dPhi_new) ;
}
bDoRotation = false ;
}
// se non sono in posizione Z+ o Z- e devo andare in una di queste due, allora...
else if ( ! (( v_q2.IsZplus() || v_q2.IsZminus()) &&
( abs( dTheta_orig - ( ANG_STRAIGHT + ANG_RIGHT)) < EPS_SMALL && v_q1.y < 0))) {
// controllo se sono nel caso limite della faccia quasi opposta
bool bForceCoeff = false ;
if ( abs( dTheta_orig - ( ANG_RIGHT)) < EPS_ANG_SMALL)
v_q1.Rotate( Z_AX, 5) ;
bHasTwoStep = true ;
// ... ruoto la telecamera solo lungo theta
RotateCameraWithBlockedAngle( v_q1, - Y_AX, 1, true, 1, dTheta_orig, dPhi_orig, dTheta_new, dPhi_new) ;
dTheta_Forced = ANG_RIGHT + ANG_STRAIGHT ;
v_q1 = FromSpherical( 1, dPhi_orig, dTheta_Forced) ;
}
}
// controllo se sono in posizione Z+ o Z- e devo sistemare la vista in un'altra posizione
else if ( AreSameOrOppositeVectorApprox( v_q1, Z_AX)) {
// ho giŕ controllato di non aver v_q1 e v_q2 paralleli...
double dTheta_S, dPhi_S , dLenS_ ;
v_q2.ToSpherical( &dLenS_, &dPhi_S, &dTheta_S) ;
if ( abs( dTheta_orig - dTheta_S) > EPS_SMALL) {
Vector3d v_q1S = FromSpherical( 1, 90, dTheta_orig) ;
// controllo nel caso di angoli opposti ( o quasi)
bool bForceCoeff = false ;
if ( abs( dTheta_S - ANG_RIGHT ) < EPS_ANG_SMALL) {
v_q1S.Rotate( Z_AX, dTheta_S - ANG_RIGHT >= 0 ? ANG_ROT_TOLL : -ANG_ROT_TOLL) ;
bForceCoeff = true ;
}
// ... ruoto la telecamera solo lungo theta
RotateCameraWithBlockedAngle( v_q1S, v_q2, dDist, bForceCoeff ? 2 : 1, 1, dTheta_orig, dPhi_orig,
dTheta_new, dPhi_new) ;
dTheta_Forced = dTheta_new ;
v_q1 = FromSpherical( 1, dPhi_orig, dTheta_Forced) ;
bHasTwoStep = true ;
}
else {
bHasTwoStep = true ;
dTheta_Forced = ANG_RIGHT + ANG_STRAIGHT ;
}
}
// se devo ruotare ... animazione mediante Slerp con parametro u tra 0 e 1
if ( bDoRotation)
RotateCameraWithBlockedAngle( v_q1, v_q2, dDist, true, bHasTwoStep ? 2 : 0, dTheta_Forced, dPhi_orig,
dTheta_new, dPhi_new) ;
}
// refresh finale per sicurezza
RedrawWindow() ;
// annullo il numero di elementi selezionati
m_nSelNbr = 0 ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::RotateCameraWithBlockedAngle( Vector3d vDirS, Vector3d vDirE, double dDist, int nAdaptSpeed,
int nBlockedAngle, double dTheta_orig, double dPhi_orig,
double& dTheta_new, double& dPhi_new)
{
// controllo dei parametri
if ( vDirS.IsSmall() || vDirE.IsSmall() || dDist < EPS_SMALL)
return false ;
if ( nBlockedAngle < 0 || nBlockedAngle > 2)
nBlockedAngle = 0 ;
vDirS.Normalize() ;
vDirE.Normalize() ;
// angolo per interpolazione sferica
double dAng = acos( vDirS * vDirE) ;
// imposto la velocitŕ di rotazione a seconda dell'angolo da percorrere... ( se richisto, altrimenti 1)
int nCoeff = 1 ;
if (( nAdaptSpeed == 1 && dAng * RADTODEG > ANG_RIGHT * ( 2.0 / 3.0) - 50 * EPS_ANG_SMALL) || nAdaptSpeed == 2)
nCoeff = 2 ;
double dThetaSs, dPhiSs, dLenSs, dThetaEs, dPhiEs, dLenEs ;
vDirS.ToSpherical( &dLenSs, &dPhiSs, &dThetaSs) ;
vDirE.ToSpherical( &dLenEs, &dPhiEs, &dThetaEs) ;
if (( abs ( abs( dThetaEs - dThetaSs) - ANG_STRAIGHT)) < 3 * ANG_ROT_TOLL + 5 * EPS_ANG_SMALL)
nCoeff = 4 ;
// ricavo i parametri per l'interpolazione sferica
for ( int u = 0 ; u <= 10 * nCoeff && abs( dAng) > EPS_SMALL ; ++ u) {
double du = u ;
if ( nCoeff == 2) du = 0.5 * u ;
if ( nCoeff == 4) du = 0.25 * u ;
Vector3d vSlerp = (( sin( 1 - 0.1 * du) * dAng) / sin( dAng)) * vDirS +
( sin( 0.1 * du * dAng) / sin( dAng)) * vDirE ;
double dTheta_u ,dPhi_u ,dLen ;
vSlerp.ToSpherical( &dLen, &dPhi_u, &dTheta_u) ;
if ( abs( u - 10 * nCoeff) < EPS_SMALL &&
( abs( dPhi_u) < EPS_ANG_SMALL || abs( dPhi_u - ANG_STRAIGHT) < EPS_ANG_SMALL))
dTheta_u = ANG_STRAIGHT + ANG_RIGHT ;
SetCamera( nBlockedAngle == 1 ? dPhi_orig : dPhi_u,
nBlockedAngle == 2 ? dTheta_orig : dTheta_u, dDist) ;
RedrawWindow() ;
dTheta_new = dTheta_u ;
dPhi_new = dPhi_u ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::GetAngleByCubeFace( int nFaceId, double &dTheta, double &dPhi)
{
switch ( nFaceId)
{
case 1 : // TOP
dPhi = 0 ; dTheta = 270 ;
break ;
case 2 : // BOTTOM
dPhi = 180 ; dTheta = 270 ;
break ;
case 3 : // RIGHT
dPhi = 90 ; dTheta = 0 ;
break ;
case 4 : // LEFT
dPhi = 90 ; dTheta = 180 ;
break ;
case 5 : // FRONT
dPhi = 90 ; dTheta = 90 ;
break ;
case 6 : // BACK
dPhi = 90 ; dTheta = 270 ;
break ;
case 7 : // TOP-RIGHT
dPhi = 45 ; dTheta = 0 ;
break ;
case 8 : // TOP-LEFT
dPhi = 45 ; dTheta = 180 ;
break ;
case 9 : // BOTTOM-RIGHT
dPhi = 225 ; dTheta = 180 ;
break ;
case 10 : // BOTTOM-LEFT
dPhi = 225 ; dTheta = 0 ;
break ;
case 11 : // TOP-FRONT
dPhi = 45 ; dTheta = 90 ;
break ;
case 12 : // TOP-BACK
dPhi = 45 ; dTheta = 270 ;
break ;
case 13 : // BOTTOM-FRONT
dPhi = 225 ; dTheta = 270 ;
break ;
case 14 : // BOTTOM-BACK
dPhi = 225 ; dTheta = 90 ;
break ;
case 15 : // RIGHT-FRONT
dPhi = 90 ; dTheta = 45 ;
break ;
case 16 : // LEFT-FRONT
dPhi = 90 ; dTheta = 135 ;
break ;
case 17 : // RIGHT-BACK
dPhi = 90 ; dTheta = 315 ;
break ;
case 18 : // LEFT-BACK
dPhi = 90 ; dTheta = 225 ;
break ;
case 19 : // TOP-RIGHT-FRONT
dPhi = 45 ; dTheta = 45 ;
break ;
case 20 : // TOP-LEFT-FRONT
dPhi = 45 ; dTheta = 135 ;
break ;
case 21 : // TOP-RIGHT-BACK
dPhi = 45 ; dTheta = 315 ;
break ;
case 22 : // TOP-LEFT-BACK
dPhi = 45 ; dTheta = 225 ;
break ;
case 23 : // BOTTOM-RIGHT-FRONT
dPhi = 135 ; dTheta = 45 ;
break ;
case 24 : // BOTTOM-LEFT-FRONT
dPhi = 135 ; dTheta = 135 ;
break ;
case 25 : // BOTTOM-RIGHT-BACK
dPhi = 135 ; dTheta = 315 ;
break ;
case 26: // BOTTOM-LEFT-BACK
dPhi = 135 ; dTheta = 215 ;
break ;
default :
break ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::SetGlobCubeParameters( int nPosFlag, double dDistX, double dDistY, double dLenEdge)
{
// controllo ammissibilitŕ dei parametri
if ( nPosFlag < 0 || nPosFlag > 4 ||
dDistX < 0 || dDistY < 0 ||
dLenEdge < MIN_EDGE_SIZE || dLenEdge > MAX_EDGE_SIZE )
return false ;
// se visualizzazione del cubo non ammessa, esco
if ( nPosFlag == 0) {
m_bShowGlobCube = false ;
return true ;
}
// imposto il flag di scelta dell'angolo del cubetto
m_nCube_Flag = nPosFlag ;
// recupero la matrice viewport
GLint Viewport[4] ;
glGetIntegerv( GL_VIEWPORT, Viewport) ;
// imposto le coordinate del centro del cubo ( X e Y coordinate in ViewPort)
double dCoordX = 0 ;
double dCoordY = 0 ;
switch ( m_nCube_Flag)
{
case 1 : // cubo in alto a destra
dCoordX = Viewport[2] - dDistX ;
dCoordY = dDistY ;
break ;
case 2 : // cubo in alto a sinistra
dCoordX = dDistX ;
dCoordY = dDistY ;
break ;
case 3 : // cubo in basso a sinistra
dCoordX = dDistX ;
dCoordY = Viewport[3] - dDistY ;
break ;
case 4 : // cubo in basso a destra
dCoordX = Viewport[2] - dDistX ;
dCoordY = Viewport[3] - dDistY ;
break ;
default :
return false ;
break ;
}
// controllo che il cubo stia nella Viewport verticale con l'ingombro del suo lato
if ( dCoordX <= sqrt( 3) * dLenEdge * 0.5 * sqrt( 2) * 0.5 + 3 ||
dCoordX >= Viewport[2] - sqrt( 3) * dLenEdge * 0.5 * sqrt( 2) / 2 - 3)
return false ;
// controllo che il cubo stia nella Viewport orizzontale con l'ingombro del suo lato
if ( dCoordY <= Viewport[1] + sqrt( 3) * dLenEdge * 0.5 * sqrt( 2) * 0.5 + 3 ||
dCoordY >= Viewport[3] - sqrt( 3) * dLenEdge * 0.5 * sqrt( 2) * 0.5 - 3)
return false ;
// imposto le variabili membro
m_dCubeX = dCoordX ;
m_dCubeY = dCoordY ;
m_dCubeEdge = dLenEdge ;
return true ;
}
SceneGlobFrame.cpp
+249 -26
View File
@@ -15,10 +15,69 @@
#include "stdafx.h"
#include "Scene.h"
#include "EGrUtils.h"
#include "/EgtDev/Include/EGkStmStandard.h"
#include "ObjOldGraphics.h"
#include "ObjNewGraphics.h"
#include "ObjMultiGraphics.h"
using namespace std ;
// posizione X e Y dello schermo
const int POSITION_FLAG = 3 ;
const double DIST_X = 40 ;
const double DIST_Y = 40 ;
// dimensione lunghezza delle linee
const double LINE_LEN = 25 ;
const double MIN_LINE_LEN = 20.0 ;
const double MAX_LINE_LEN = 100.0 ;
// dimensione spessore delle linee
const double LINE_WIDTH = 2 ;
// colore origine del Frame
const Color FRAME_ORIG( 0, 0, 0, 1) ;
// flag creazione coni per assi e vettore delle tre rispettive superifici
static bool bConeCreated = false ;
ISURFTMPOVECTOR vStmCones ;
//----------------------------------------------------------------------------
bool CreateCone( double dConeRad, double dConeLen, double dLen) {
vStmCones.clear() ;
PtrOwner<ISurfTriMesh> pStmConeX( GetSurfTriMeshCone( dConeRad, dConeLen, 10)) ;
pStmConeX->Rotate( ORIG, Y_AX, ANG_RIGHT) ;
pStmConeX->Translate( Vector3d( 1, 0, 0) * dLen) ;
vStmCones.emplace_back( Release( pStmConeX)) ;
PtrOwner<ISurfTriMesh> pStmConeY( GetSurfTriMeshCone( dConeRad, dConeLen, 10)) ;
pStmConeY->Rotate( ORIG, -X_AX, ANG_RIGHT) ;
pStmConeY->Translate( Vector3d( 0, 1, 0) * dLen) ;
vStmCones.emplace_back( Release( pStmConeY)) ;
PtrOwner<ISurfTriMesh> pStmConeZ( GetSurfTriMeshCone( dConeRad, dConeLen, 10)) ;
pStmConeZ->Translate( Vector3d( 0, 0, 1) * dLen) ;
vStmCones.emplace_back( Release( pStmConeZ)) ;
bConeCreated = true ;
return true ;
}
//----------------------------------------------------------------------------
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) ;
}
//----------------------------------------------------------------------------
bool
Scene::SetGlobFrameShow( bool bShow)
@@ -27,6 +86,76 @@ Scene::SetGlobFrameShow( bool bShow)
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::SetGlobFrameParameters( int nPosFlag, double dDistX, double dDistY,
double dLenLine, double dWidthLine)
{
// controllo ammissibilità dei parametri
if ( nPosFlag < 0 || nPosFlag > 4 ||
dDistX < 0 || dDistY < 0 ||
dLenLine < MIN_LINE_LEN || dLenLine > MAX_LINE_LEN ||
dWidthLine < 1.0)
return false ;
// se visualizzazione del frame non ammessa, esco
if ( nPosFlag == 0) {
m_bShowGlobFrame = false ;
bConeCreated = false ;
return true ;
}
// setto il flag di scelta per l'angolo di visualizzazione del Frame
m_nAxisFrame_Flag = nPosFlag ;
// recupero la matrice viewport
GLint Viewport[4] ;
glGetIntegerv( GL_VIEWPORT, Viewport) ;
// imposto le coordinate del centro del Frame ( X e Y coordinate in ViewPort)
double dCoordX = 0 ;
double dCoordY = 0 ;
switch ( m_nAxisFrame_Flag)
{
case 1 : // frame in alto a destra
dCoordX = Viewport[2] - dDistX ;
dCoordY = dDistY ;
break ;
case 2 : // frame in alto a sinistra
dCoordX = dDistX ;
dCoordY = dDistY ;
break ;
case 3 : // frame in basso a sinistra
dCoordX = dDistX ;
dCoordY = Viewport[3] - dDistY ;
break ;
case 4 : // frame in basso a destra
dCoordX = Viewport[2] - dDistX ;
dCoordY = Viewport[3] - dDistY ;
break ;
default :
break ;
}
// controllo che il frame stia nella Viewport verticale con l'ingombro dei suoi versori
if ( dCoordX <= dLenLine * 0.5 * sqrt( 2) + 3 ||
dCoordX >= Viewport[2] - sqrt( 2) * dLenLine * 0.5 - 3)
return false ;
// controllo che il frame stia nella Viewport orizzontale con l'ingombro dei suoi versori
if ( dCoordY <= Viewport[1] + sqrt( 2) * dLenLine * 0.5 + 3 ||
dCoordY >= Viewport[3] - sqrt( 2) * dLenLine * 0.5 - 3)
return false ;
// imposto le variabili membro
m_dFrame_DistX = dCoordX ;
m_dFrame_DistY = dCoordY ;
m_dFrameLineL = dLenLine ;
m_dFrameLineW = dWidthLine ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::DrawGlobFrame( void)
@@ -39,46 +168,140 @@ Scene::DrawGlobFrame( void)
GLint Viewport[ 4] ;
glGetIntegerv( GL_VIEWPORT, Viewport) ;
// imposto il riferimento sempre in vista ortografica
glMatrixMode( GL_PROJECTION) ;
// imposto il riferimento
glPushMatrix() ;
if ( ! m_bOrthographic) {
glLoadIdentity() ;
glOrtho( - m_dHalfWidth, m_dHalfWidth, - m_dHalfHeight, m_dHalfHeight, m_dZNear, m_dZFar) ;
}
// origine del riferimento globale
const double DIST_BORDER = 30 ;
const double POS_Z = 0.5 ;
// imposto l'origine del sistema di riferimento nelle coordinate della ViewPort
Point3d ptOrig ;
UnProject( Point3d( DIST_BORDER, Viewport[3] - DIST_BORDER, POS_Z), ptOrig) ;
const double POS_Z = 0.25 ;
UnProject( Point3d( m_dFrame_DistX, m_dFrame_DistY, POS_Z), ptOrig) ;
// lunghezza degli assi
const double LEN_AX = DIST_BORDER - 2 ;
double dLen = LEN_AX * ( 2 * m_dHalfWidth) / Viewport[2] ;
// abilito Ztest per rendering delle linee e dei punti
glEnable( GL_DEPTH_TEST) ;
// disegno degli assi
glLineWidth( (float) GetFrameLineWidth()) ;
// controllo gli angoli correnti della telecamera per decidere il rendering delle linee ( continue o stripped)
double dTheta, dPhi, dDist ;
GetCamera( &dPhi, &dTheta, &dDist) ;
bool bStripped_X = false ;
bool bStripped_Y = false ;
bool bStripped_Z = false ;
if ( abs( dPhi) > ANG_RIGHT)
bStripped_Z = true ;
if ( abs( dTheta) > ANG_RIGHT && abs( dTheta) < ANG_RIGHT + ANG_STRAIGHT)
bStripped_X = true ;
if ( abs( dTheta) > ANG_STRAIGHT)
bStripped_Y = true ;
// scalo la lunghezza degli assi
double dLen = m_dFrameLineL * ( 2 * m_dHalfWidth) / Viewport[2] ;
double dOrigOff = 0.875 * m_dFrameLineW * ( 2 * m_dHalfWidth) / Viewport[2] ;
double dConeRad = m_dFrameLineW * 1.0 ;
double dConeLen = 0.4 * m_dFrameLineL ;
// imposto la dimensione degli assi
glLineWidth(( float) m_dFrameLineW) ;
// asse X
if ( bStripped_X)
glEnable( GL_LINE_STIPPLE) ;
else
glEnable( GL_LINES) ;
glBegin( GL_LINES) ;
// asse X+
glColor3f( 1, 0, 0) ;
glVertex3f( float( ptOrig.x), float( ptOrig.y), float( ptOrig.z)) ;
glColor3f( m_cColX.GetRed(), m_cColX.GetGreen(), m_cColX.GetBlue()) ;
glVertex3f( float( ptOrig.x + dOrigOff), float( ptOrig.y), float( ptOrig.z)) ;
glVertex3f( float( ptOrig.x + dLen), float( ptOrig.y), float( ptOrig.z)) ;
// asse Y+
glColor3f( 0, 1, 0) ;
glVertex3f( float( ptOrig.x), float( ptOrig.y), float( ptOrig.z)) ;
glEnd() ;
if ( bStripped_X)
glDisable( GL_LINE_STIPPLE) ;
// asse Y
if ( bStripped_Y)
glEnable( GL_LINE_STIPPLE) ;
else
glEnable( GL_LINES) ;
glBegin( GL_LINES) ;
glColor3f( m_cColY.GetRed(), m_cColY.GetGreen(), m_cColY.GetBlue()) ;
glVertex3f( float( ptOrig.x), float( ptOrig.y + dOrigOff), float( ptOrig.z)) ;
glVertex3f( float( ptOrig.x), float( ptOrig.y + dLen), float( ptOrig.z)) ;
// asse Z+
glColor3f( 0, 0, 1) ;
glVertex3f( float( ptOrig.x), float( ptOrig.y), float( ptOrig.z)) ;
glEnd() ;
if ( bStripped_Y)
glDisable( GL_LINE_STIPPLE) ;
// asse Z
if ( bStripped_Z)
glEnable( GL_LINE_STIPPLE) ;
else
glEnable( GL_LINES) ;
glBegin( GL_LINES) ;
glColor3f( m_cColZ.GetRed(), m_cColZ.GetGreen(), m_cColZ.GetBlue()) ;
glVertex3f( float( ptOrig.x), float( ptOrig.y), float( ptOrig.z + dOrigOff)) ;
glVertex3f( float( ptOrig.x), float( ptOrig.y), float( ptOrig.z + dLen)) ;
glEnd() ;
if ( bStripped_Z)
glDisable( GL_LINE_STIPPLE) ;
// ripristino spessore linee
glLineWidth( (float) GetLineWidth()) ;
// TEST PUNTI !
glEnable( GL_POINT_SMOOTH ) ;
glPointSize(( float) 2.5 * m_dFrameLineW) ;
glBegin( GL_POINTS) ;
glColor3f( FRAME_ORIG.GetRed(), FRAME_ORIG.GetGreen(), FRAME_ORIG.GetBlue()) ;
glVertex3f( float( ptOrig.x), float( ptOrig.y), float( ptOrig.z)) ;
glEnd() ;
glPointSize(( float) GetPointSize()) ;
glDisable( GL_POINT_SMOOTH) ;
// disegno i tre coni ( se precedentemente non già creati)
if ( ! bConeCreated)
CreateCone( dConeRad, dConeLen, m_dFrameLineL) ;
// creo un vettore di Graphics, uno per ogni cono del frame
vector<PtrOwner<ObjEGrGraphics>> vGraphics ;
for ( int i = 0 ; i < 3 ; ++ i) {
PtrOwner<ObjEGrGraphics> pNewGraphics( CreateObjEGrGraphics( 0, false)) ;
vGraphics.emplace_back( Release( pNewGraphics)) ;
vGraphics[i]->SetScene( this) ;
}
for ( int s = 0 ; s < 3 ; ++ s) {
// recupero la superificie corrente del cubo da visualizzare
PtrOwner<ISurfTriMesh> pStmCurr_Cone( CloneSurfTriMesh( vStmCones[s])) ;
if ( IsNull( pStmCurr_Cone))
return false ;
// scalo la superificie a seconda della viewport corrente ( per Zoom)
pStmCurr_Cone->Scale( GLOB_FRM, ( 2 * m_dHalfWidth) / Viewport[2], ( 2 * m_dHalfWidth) / Viewport[2],
( 2 * m_dHalfWidth) / Viewport[2]) ;
// sposto la superificie nel sistema di riferimento relativo alla telecamera ( per Pan)
pStmCurr_Cone->Translate(( ptOrig - ORIG)) ;
Color cCurrColor ;
if ( s == 0) cCurrColor = m_cColX ;
if ( s == 1) cCurrColor = m_cColY ;
if ( s == 2) cCurrColor = m_cColZ ;
vGraphics[s]->AddColor( cCurrColor) ;
int nTria = pStmCurr_Cone->GetTriangleCount() ;
vGraphics[s]->StartTriangles( nTria) ;
Triangle3dEx Tria ;
int nId = pStmCurr_Cone->GetFirstTriangle( Tria) ;
while ( nId != SVT_NULL) {
// edge solo se boundary e normali ai vertici smussate
vGraphics[s]->AddTriangle( Tria, Tria.GetTriFlags(), Tria.GetTriNormals()) ;
nId = pStmCurr_Cone->GetNextTriangle( nId, Tria) ;
}
vGraphics[s]->EndTriangles() ;
// assegno un id temporaneo alla superificie caricata ( modalita wireFrame, come nella Select)
vGraphics[s]->Draw( GDB_ST_ON, GDB_MK_OFF, true, true, 80, false) ;
}
// torno a spessore della linee impostato in precedenza
glLineWidth((float) GetLineWidth()) ;
glDisable( GL_DEPTH_TEST) ;
// ripristino lo stack delle matrici
glPopMatrix() ;
return true ;
}
SceneImage.cpp
+19 -21
View File
@@ -128,28 +128,26 @@ Scene::GetImage( int nShowMode, Color colBackTop, Color colBackBottom,
pDib = FreeImage_ConvertTo24Bits( pTmpDib) ;
FreeImage_Unload( pTmpDib) ;
// Se necessario, eseguo scalatura della bitmap
if ( nDestWidth != nN * nWidth || nDestHeight != nM * nHeight) {
int nLeft ; int nTop ;
int nRight ; int nBottom ;
if ( dCoeffW / nN >= dCoeffH / nM) {
nLeft = 0 ;
nRight = nN * nWidth - 1 ;
int nDeltaH = nM * nHeight - nN * int( nDestHeight / dCoeffW) ;
nTop = nDeltaH / 2 ;
nBottom = nM * nHeight - nTop - 1 ;
}
else {
nTop = 0 ;
nBottom = nM * nHeight - 1 ;
int nDeltaW = nN * nWidth - nM * int( nDestWidth / dCoeffH) ;
nLeft = nDeltaW / 2 ;
nRight = nN * nWidth - nLeft - 1 ;
}
FIBITMAP* pTmp2Dib = pDib ;
pDib = FreeImage_RescaleRect( pTmp2Dib, nDestWidth, nDestHeight, nLeft, nTop, nRight, nBottom, FILTER_CATMULLROM) ;
FreeImage_Unload( pTmp2Dib) ;
// Eseguo scalatura della bitmap
int nLeft ; int nTop ;
int nRight ; int nBottom ;
if ( dCoeffW / nN >= dCoeffH / nM) {
nLeft = 0 ;
nRight = nN * nWidth - 1 ;
int nDeltaH = nM * nHeight - nN * int( nDestHeight / dCoeffW) ;
nTop = nDeltaH / 2 ;
nBottom = nM * nHeight - nTop - 1 ;
}
else {
nTop = 0 ;
nBottom = nM * nHeight - 1 ;
int nDeltaW = nN * nWidth - nM * int( nDestWidth / dCoeffH) ;
nLeft = nDeltaW / 2 ;
nRight = nN * nWidth - nLeft - 1 ;
}
FIBITMAP* pTmp2Dib = pDib ;
pDib = FreeImage_RescaleRect( pTmp2Dib, nDestWidth, nDestHeight, nLeft, nTop, nRight, nBottom, FILTER_BSPLINE) ;
FreeImage_Unload( pTmp2Dib) ;
// Salvataggio
int nFlag = 0 ;
SceneSelect.cpp
+11 -21
View File
@@ -95,6 +95,12 @@ Scene::Select( const Point3d& ptSelCenter, int nW, int nH, int& nSel)
// non imposto glPolygonMode secondo il tipo di rendering perchè ignorato in selezione
// disegno le geometrie del DB in una sola passata
DrawGroup( GDB_ID_ROOT, 1, MdStMkCol( GDB_MD_STD, GDB_ST_ON, GDB_MK_OFF, m_colDef)) ;
// disegno il cubetto
glEnable( GL_CULL_FACE) ;
glCullFace( GL_BACK) ;
glFrontFace( GL_CCW) ;
DrawGlobCube( false) ;
glDisable( GL_CULL_FACE) ;
// pulisco stack nomi
glPopName() ;
@@ -109,6 +115,10 @@ Scene::Select( const Point3d& ptSelCenter, int nW, int nH, int& nSel)
// riordino il buffer di selezione secondo la Zdepth minima crescente
qsort( m_nSelBuff, m_nSelNbr, sizeof( SelRec), CompareSelRec) ;
// controllo se ho selezionato una superficie sul cubetto
if ( RotateCameraWithCube())
m_nSelNbr = 0 ;
nSel = m_nSelNbr ;
return true ;
}
@@ -361,27 +371,7 @@ Scene::GetPointFromSelect( int nSelId, const Point3d& ptView, Point3d& ptSel, in
double dLenMir = 4 * dBlRad ;
// cerco i triangoli intersecati dalla linea di mira
ILSIVECTOR vInfo ;
if ( ! IntersLineSurfTm( ptMir, vtDir, dLenMir, *pStm, vInfo))
return false ;
// se non trovato alcunchè, cerco le linee che partono dagli angoli e dai punti medi dei lati del rettangolo di mira
VCT3DVECTOR vVtWind = { {0.51, 0.51, 0}, {0, 0.51, 0}, {-0.51, 0.51, 0}, {-0.51, 0, 0},
{-0.51, -0.51, 0}, {0, -0.51, 0}, {0.51, -0.51, 0}, {0.51, 0, 0},
{0.25, 0.51, 0}, {-0.25, 0.51, 0}, {-0.51, 0.25, 0}, {-0.51, -0.25, 0},
{-0.25, -0.51, 0}, {0.25, -0.51, 0}, {0.51, -0.25, 0}, {0.51, 0.25, 0}} ;
for ( int i = 0 ; i < int( vVtWind.size()) && vInfo.empty() ; ++ i) {
// determino punto su vertice del rettangolo di selezione
Point3d ptWinZ2 = ptWinZ + vVtWind[i].x * m_nSelH * X_AX + vVtWind[i].y * m_nSelW * Y_AX ;
// ne ricavo punto di mira
Point3d ptMir2 ;
if ( ! UnProject( ptWinZ2, ptMir2))
return false ;
ptMir2.ToLoc( frEnt) ;
ptMir2 -= vtDir * 2 * dBlRad ;
// interseco con la superficie
if ( ! IntersLineSurfTm( ptMir2, vtDir, dLenMir, *pStm, vInfo))
return false ;
}
if ( vInfo.empty())
if ( ! IntersLineSurfTm( ptMir, vtDir, dLenMir, *pStm, vInfo) || vInfo.size() == 0)
return false ;
// recupero il primo punto
ptSel = GetToGlob( vInfo[0].ptI, frEnt) ;
SceneSnap.cpp
+64 -98
View File
@@ -48,7 +48,7 @@ Scene::GetGraphicSnapPoint( int nSnap, const Point3d& ptWin, int nW, int nH, Poi
// reset dati associati a ultimo punto snap
m_nLastSnapId = GDB_ID_NULL ;
m_bLastSnapDirOk = false ;
// verifico validità GDB
// verifico validità GDB
if ( m_pGeomDB == nullptr)
return false ;
// se Snap Sketch o Grid, devo trovare il punto sulla griglia
@@ -58,14 +58,14 @@ Scene::GetGraphicSnapPoint( int nSnap, const Point3d& ptWin, int nW, int nH, Poi
return true ;
}
}
// se Snap Intersection, devo trovare l'intersezione tra due entità inquadrate
// se Snap Intersection, devo trovare l'intersezione tra due entità inquadrate
else if ( nSnap == SP_INTERS) {
if ( FindSelectedIntersectionPoint( ptWin, nW, nH)) {
ptSel = m_ptLastSnapPnt ;
return true ;
}
}
// altrimenti devo trovare il punto dall'entità inquadrata
// altrimenti devo trovare il punto dall'entità inquadrata
else {
if ( FindSelectedSnapPoint( nSnap, ptWin, nW, nH)) {
ptSel = m_ptLastSnapPnt ;
@@ -88,17 +88,9 @@ Scene::GetGridSnapPointZ( bool bSketch, const Point3d& ptWin, const Point3d& ptG
if ( ! UnProject( ptWin, ptLine))
return false ;
Vector3d vtLine = - m_vtDirCamera ;
if ( ! m_bOrthographic) {
// nella vista prospettica la direzione di mira è data dalla linea che coingiunge le proiezioni di ptWin sui piani near e far
Point3d ptLine2 ;
if ( ! UnProject( Point3d( ptWin.x, ptWin.y, 1), ptLine2))
return false ;
vtLine = ptLine - ptLine2 ;
vtLine.Normalize() ;
}
// piano di elevazione :
// per il punto di griglia, contenente la perp. alla griglia e più perp. possibile alla direzione di mira
// per il punto di griglia, contenente la perp. alla griglia e più perp. possibile alla direzione di mira
Vector3d vtNorm = vtLine - ( vtLine * frGrid.VersZ()) * frGrid.VersZ() ;
if ( ! vtNorm.Normalize())
return false ;
@@ -131,14 +123,6 @@ Scene::FindGridSnapPoint( bool bSketch, const Point3d& ptWin)
if ( ! UnProject( ptWin, ptLine))
return false ;
Vector3d vtLine = - m_vtDirCamera ;
if ( ! m_bOrthographic) {
// nella vista prospettica la direzione di mira è data dalla linea che coingiunge le proiezioni di ptWin sui piani near e far
Point3d ptLine2 ;
if ( ! UnProject( Point3d( ptWin.x, ptWin.y, 1), ptLine2))
return false ;
vtLine = ptLine - ptLine2 ;
vtLine.Normalize() ;
}
// determino l'intersezione di questa linea con il piano della griglia
double dDenom = vtLine * frGrid.VersZ() ;
@@ -149,7 +133,7 @@ Scene::FindGridSnapPoint( bool bSketch, const Point3d& ptWin)
// porto il punto sul piano di griglia
m_ptLastSnapPnt.ToLoc( frGrid) ;
// se punto grid, devo arrotondare al nodo di griglia più vicino
// se punto grid, devo arrotondare al nodo di griglia più vicino
if ( ! bSketch) {
m_ptLastSnapPnt.x = floor( m_ptLastSnapPnt.x / m_dSnapStep + 0.5) * m_dSnapStep ;
m_ptLastSnapPnt.y = floor( m_ptLastSnapPnt.y / m_dSnapStep + 0.5) * m_dSnapStep ;
@@ -166,9 +150,7 @@ bool
Scene::FindSelectedIntersectionPoint( const Point3d& ptWin, int nW, int nH)
{
// --- l'intersezione viene calcolata nel piano della griglia ---
// salvo eventuale ultima entità precedentemente selezionata
int nPrevSel = GetFirstSelectedObj() ;
// verifico siano state selezionate delle entità
// verifico siano state selezionate delle entità
int nSel ;
Select( ptWin, nW, nH, nSel) ;
if ( nSel <= 0)
@@ -176,19 +158,17 @@ Scene::FindSelectedIntersectionPoint( const Point3d& ptWin, int nW, int nH)
// cerco le prime due curve inquadrate con i loro riferimenti
const ICurve* pCrv[2] ;
Frame3d frEnt[2] ;
int nIds[2] ;
double dWinZ = 0 ;
int nCrvNum = 0 ;
for ( int nObjId = GetFirstSelectedObj() ; nObjId != GDB_ID_NULL && nCrvNum < 2 ; nObjId = GetNextSelectedObj()) {
// se non è entità geometrica
for ( int i = GetFirstSelectedObj() ; i != GDB_ID_NULL && nCrvNum < 2 ; i = GetNextSelectedObj()) {
// se non è entità geometrica
const IGeoObj* pGObj ;
if ( ( pGObj = m_pGeomDB->GetGeoObj( nObjId)) == nullptr)
if ( ( pGObj = m_pGeomDB->GetGeoObj( i)) == nullptr)
continue ;
if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
pCrv[nCrvNum] = GetCurve( pGObj) ;
if ( ! m_pGeomDB->GetGlobFrame( nObjId, frEnt[nCrvNum]))
if ( ! m_pGeomDB->GetGlobFrame( i, frEnt[nCrvNum]))
return false ;
nIds[nCrvNum] = nObjId ;
dWinZ += 0.5 * GetSelectedObjWinZ() ;
++ nCrvNum ;
}
@@ -196,11 +176,11 @@ Scene::FindSelectedIntersectionPoint( const Point3d& ptWin, int nW, int nH)
// se nessuna curva, esco
if ( nCrvNum == 0)
return false ;
// se una sola curva, può essere auto intersezione
// se una sola curva, può essere auto intersezione
if ( nCrvNum == 1) {
// recupero il riferimento di griglia
Frame3d frGrid = GetGridFrame() ;
// se il riferimento della curva è diverso da quello della griglia, devo trasformarla
// se il riferimento della curva è diverso da quello della griglia, devo trasformarla
PtrOwner<ICurve> pcrvTrans0 ;
if ( ! AreSameFrame( frEnt[0], frGrid)) {
pcrvTrans0.Set( pCrv[0]->Clone()) ;
@@ -215,19 +195,17 @@ Scene::FindSelectedIntersectionPoint( const Point3d& ptWin, int nW, int nH)
if ( ! UnProject( ptWinZ, ptNear))
ptNear = ORIG ;
ptNear.ToLoc( frGrid) ;
// calcolo il punto di intersezione sulla prima curva più vicino al punto di riferimento
// calcolo il punto di intersezione sulla prima curva più vicino al punto di riferimento
SelfIntersCurve sintC( *pCrv[0]) ;
if ( ! sintC.GetIntersPointNearTo( ptNear, m_ptLastSnapPnt))
return false ;
m_nLastSnapId = nIds[0] ;
m_ptLastSnapPnt.ToGlob( frGrid) ;
m_bLastSnapDirOk = false ;
return true ;
}
// altrimenti due curve, procedo normalmente
// recupero il riferimento di griglia
Frame3d frGrid = GetGridFrame() ;
// se il riferimento della prima curva è diverso da quello della griglia, devo trasformarla
// se il riferimento della prima curva è diverso da quello della griglia, devo trasformarla
PtrOwner<ICurve> pcrvTrans0 ;
if ( ! AreSameFrame( frEnt[0], frGrid)) {
pcrvTrans0.Set( pCrv[0]->Clone()) ;
@@ -236,7 +214,7 @@ Scene::FindSelectedIntersectionPoint( const Point3d& ptWin, int nW, int nH)
pcrvTrans0->LocToLoc( frEnt[0], frGrid) ;
pCrv[0] = pcrvTrans0 ;
}
// se il riferimento della seconda curva è diverso da quello della griglia, devo trasformarla
// se il riferimento della seconda curva è diverso da quello della griglia, devo trasformarla
PtrOwner<ICurve> pcrvTrans1 ;
if ( ! AreSameFrame( frEnt[1], frGrid)) {
pcrvTrans1.Set( pCrv[1]->Clone()) ;
@@ -251,13 +229,11 @@ Scene::FindSelectedIntersectionPoint( const Point3d& ptWin, int nW, int nH)
if ( ! UnProject( ptWinZ, ptNear))
ptNear = ORIG ;
ptNear.ToLoc( frGrid) ;
// calcolo il punto di intersezione sulla prima curva più vicino al punto di riferimento
// calcolo il punto di intersezione sulla prima curva più vicino al punto di riferimento
IntersCurveCurve intCC( *pCrv[0], *pCrv[1], true) ;
if ( ! intCC.GetIntersPointNearTo( ( nPrevSel == nIds[1] ? 1 : 0), ptNear, m_ptLastSnapPnt))
if ( ! intCC.GetIntersPointNearTo( 0, ptNear, m_ptLastSnapPnt))
return false ;
m_nLastSnapId = nIds[0] ;
m_ptLastSnapPnt.ToGlob( frGrid) ;
m_bLastSnapDirOk = false ;
return true ;
}
@@ -265,20 +241,20 @@ Scene::FindSelectedIntersectionPoint( const Point3d& ptWin, int nW, int nH)
bool
Scene::FindSelectedSnapPoint( int nSnap, const Point3d& ptWin, int nW, int nH)
{
// seleziono e verifico siano state selezionate delle entità
// seleziono e verifico siano state selezionate delle entità
int nSel ;
Select( ptWin, nW, nH, nSel) ;
if ( nSel <= 0)
return false ;
// cerco il punto notevole più vicino alla selezione tra le entità selezionate
// cerco il punto notevole più vicino alla selezione tra le entità selezionate
bool bFound = false ;
double dMinSqDist = INFINITO * INFINITO ;
for ( int nId = GetFirstSelectedObj() ; nId != GDB_ID_NULL ; nId = GetNextSelectedObj()) {
// se non è entità geometrica
// se non è entità geometrica
const IGeoObj* pGObj ;
if ( ( pGObj = m_pGeomDB->GetGeoObj( nId)) == nullptr)
continue ;
// recupero riferimento dell'entità
// recupero riferimento dell'entità
Frame3d frEnt ;
if ( ! m_pGeomDB->GetGlobFrame( nId, frEnt))
continue ;
@@ -494,7 +470,7 @@ Scene::FindCurveSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Frame
UnProject( ptWinZ, ptRef) ;
// lo porto nel frame della curva
ptRef.ToLoc( frEnt) ;
// determino il punto più vicino della curva a questo
// determino il punto più vicino della curva a questo
MinDistPCInfo mdInfo ;
DistPointCurve dstPtCurve( ptRef, *pCrv) ;
if ( dstPtCurve.GetMinDistInfo( 0, mdInfo)) {
@@ -521,7 +497,7 @@ Scene::FindCurveSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Frame
bool
Scene::VerifySnapPoint( const Point3d& ptP, const Point3d& ptWin, double& dMinSqDist) const
{
// il punto di riferimento deriva da XY su viewport e Z minima (più vicina a osservatore) da selezione
// il punto di riferimento deriva da XY su viewport e Z minima (più vicina a osservatore) da selezione
Point3d ptWinZ( ptWin.x, ptWin.y, GetSelectedObjMinWinZ()) ;
// punto di riferimento nello spazio geometrico 3d
Point3d ptRef ;
@@ -529,7 +505,7 @@ Scene::VerifySnapPoint( const Point3d& ptP, const Point3d& ptWin, double& dMinSq
return false ;
// recupero la direzione di mira
Vector3d vtDir = - m_vtDirCamera ;
// il punto di confronto è quello sulla linea di mira a minima distanza dal punto dato
// il punto di confronto è quello sulla linea di mira a minima distanza dal punto dato
Point3d ptCfr = ptRef + (( ptP - ptRef) * vtDir) * vtDir ;
// determino la distanza e la confronto con il minimo
double dSqDist = SqDist( ptP, ptCfr) ;
@@ -569,10 +545,10 @@ Scene::AdjustForCurveExtr( const Point3d& ptWin, const Frame3d& frEnt, const ICu
double dExtrSqDist = INFINITO ;
DistPointCurve dstPtECurve( ptRef - vtExtr, *pCrv) ;
dstPtECurve.GetSqDist( dExtrSqDist) ;
// se più vicino a base non devo modificare il punto
// se più vicino a base non devo modificare il punto
if ( dBaseSqDist <= dExtrSqDist)
return false ;
// più vicino ad estrusione, quindi la aggiungo
// più vicino ad estrusione, quindi la aggiungo
ptP += vtExtr ;
return true ;
}
@@ -590,7 +566,7 @@ Scene::FindCurveCompoSnapPoint( int nSnap, const Point3d& ptWin, int nId, const
return false ;
// porto il punto nel riferimento della curva
ptRef.ToLoc( frEnt) ;
// se richiesto il centro di gravità (baricentro, centroide)
// se richiesto il centro di gravità (baricentro, centroide)
if ( nSnap == SP_CENTROID) {
Point3d ptP ;
bool bFound = false ;
@@ -607,11 +583,11 @@ Scene::FindCurveCompoSnapPoint( int nSnap, const Point3d& ptWin, int nId, const
return bFound ;
}
// altrimenti opero sulle curve componenti elementari
// determino la curva elementare più vicina al punto di riferimento
// determino la curva elementare più vicina al punto di riferimento
int nCrv = - 1 ;
double dPar ;
int nFlag ;
// cerco il punto della curva più vicino, dal suo parametro deduco la curva elementare
// cerco il punto della curva più vicino, dal suo parametro deduco la curva elementare
if ( DistPointCurve( ptRef, *pCrvCompo).GetParamAtMinDistPoint( 0, dPar, nFlag))
nCrv = static_cast<int>( dPar) ;
// lavoro sulla curva elementare
@@ -641,7 +617,7 @@ bool
Scene::FindSurfTMSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Frame3d& frEnt,
const ISurfTriMesh* pStm, double& dMinSqDist)
{
// il punto di riferimento deriva da XY su viewport e Z minima (più vicina a osservatore) da selezione
// il punto di riferimento deriva da XY su viewport e Z minima (più vicina a osservatore) da selezione
Point3d ptWinZ( ptWin.x, ptWin.y, GetSelectedObjMinWinZ()) ;
// punto di riferimento nello spazio geometrico 3d
Point3d ptRef ;
@@ -667,12 +643,12 @@ Scene::FindSurfTMSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fram
Color cCol ;
bool bAlpha = ( m_pGeomDB->GetCalcMaterial( nId, cCol) && cCol.GetIntAlpha() <= ALPHA_LIM) ;
// se richiesto il centro di gravità (baricentro, centroide)
// se richiesto il centro di gravità (baricentro, centroide)
if ( nSnap == SP_CENTROID) {
Point3d ptP ;
bool bFound = false ;
if ( pStm->GetCentroid( ptP)) {
// il punto di confronto è quello sulla linea di mira a minima distanza dal vertice
// il punto di confronto è quello sulla linea di mira a minima distanza dal vertice
Point3d ptCfr = ptRef + (( ptP - ptRef) * vtDir) * vtDir ;
// determino la distanza e la confronto con il minimo
double dSqDist = SqDist( ptP, ptCfr) ;
@@ -684,7 +660,7 @@ Scene::FindSurfTMSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fram
m_bLastSnapDirOk = false ;
}
}
// se trovato e modalità shading o hiddenline, la favorisco perchè davanti alle possibili successive
// se trovato e modalità shading o hiddenline, la favorisco perchè davanti alle possibili successive
if ( bFound && ! ( bAlpha || m_nShowMode == SM_WIREFRAME))
dMinSqDist = 0 ;
return bFound ;
@@ -694,14 +670,12 @@ Scene::FindSurfTMSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fram
ILSIVECTOR vInfo ;
if ( ! IntersLineSurfTm( ptMir, vtDir, dLenMir, *pStm, vInfo))
return false ;
// se non trovato alcunchè, cerco le linee che partono dagli angoli e dai punti medi dei lati del rettangolo di mira
VCT3DVECTOR vVtWind = { {0.51, 0.51, 0}, {0, 0.51, 0}, {-0.51, 0.51, 0}, {-0.51, 0, 0},
{-0.51, -0.51, 0}, {0, -0.51, 0}, {0.51, -0.51, 0}, {0.51, 0, 0},
{0.25, 0.51, 0}, {-0.25, 0.51, 0}, {-0.51, 0.25, 0}, {-0.51, -0.25, 0},
{-0.25, -0.51, 0}, {0.25, -0.51, 0}, {0.51, -0.25, 0}, {0.51, 0.25, 0}} ;
for ( int i = 0 ; i < int( vVtWind.size()) && vInfo.empty() ; ++ i) {
// se non trovato alcunchè, cerco le linee che partono dagli angoli del rettangolo di mira
Vector3d vtWinD( -1, -1, 0) ;
for ( int i = 0 ; i < 4 && vInfo.size() == 0 ; ++ i) {
// determino punto su vertice del rettangolo di selezione
Point3d ptWinZ2 = ptWinZ + vVtWind[i].x * m_nSelH * X_AX + vVtWind[i].y * m_nSelW * Y_AX ;
Point3d ptWinZ2 = ptWinZ + vtWinD.x * m_nSelH * X_AX + vtWinD.y * m_nSelW * Y_AX ;
vtWinD.Rotate( Z_AX, 0, 1) ;
// ne ricavo punto di mira
Point3d ptMir2 ;
if ( ! UnProject( ptWinZ2, ptMir2))
@@ -712,7 +686,7 @@ Scene::FindSurfTMSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fram
if ( ! IntersLineSurfTm( ptMir2, vtDir, dLenMir, *pStm, vInfo))
return false ;
}
if ( vInfo.empty())
if ( vInfo.size() == 0)
return false ;
// elaborazione a seconda del tipo di snap
@@ -725,12 +699,12 @@ Scene::FindSurfTMSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fram
for ( int i = 0 ; i < nTtot ; ++ i) {
// punto di intersezione
Point3d ptInt = vInfo[i].ptI ;
// punto finale più vicino
// punto finale più vicino
int nF = pStm->GetFacetFromTria( vInfo[i].nT) ;
Point3d ptEnd ;
Vector3d vtN ;
if ( pStm->GetFacetNearestEndPoint( nF, ptInt, ptEnd, vtN)) {
// il punto di confronto è quello sulla linea di mira a minima distanza dal vertice
// il punto di confronto è quello sulla linea di mira a minima distanza dal vertice
Point3d ptCfr = ptRef + (( ptEnd - ptRef) * vtDir) * vtDir ;
// determino la distanza e la confronto con il minimo
double dSqDist = SqDist( ptEnd, ptCfr) ;
@@ -753,12 +727,12 @@ Scene::FindSurfTMSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fram
for ( int i = 0 ; i < nTtot ; ++ i) {
// punto di intersezione
Point3d ptInt = vInfo[i].ptI ;
// punto medio più vicino
// punto medio più vicino
int nF = pStm->GetFacetFromTria( vInfo[i].nT) ;
Point3d ptMid ;
Vector3d vtN ;
if ( pStm->GetFacetNearestMidPoint( nF, ptInt, ptMid, vtN)) {
// il punto di confronto è quello sulla linea di mira a minima distanza dal punto medio
// il punto di confronto è quello sulla linea di mira a minima distanza dal punto medio
Point3d ptCfr = ptRef + (( ptMid - ptRef) * vtDir) * vtDir ;
// determino la distanza e la confronto con il minimo
double dSqDist = SqDist( ptMid, ptCfr) ;
@@ -779,12 +753,12 @@ Scene::FindSurfTMSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fram
// con wireframe devo provare tutti i triangoli intersecati, con shading e hiddenline solo il primo
int nTtot = (( bAlpha || m_nShowMode == SM_WIREFRAME) ? int( vInfo.size()) : 1) ;
for ( int i = 0 ; i < nTtot ; ++ i) {
// centro più vicino
// centro più vicino
int nF = pStm->GetFacetFromTria( vInfo[i].nT) ;
Point3d ptCen ;
Vector3d vtN ;
if ( pStm->GetFacetCenter( nF, ptCen, vtN)) {
// il punto di confronto è quello sulla linea di mira a minima distanza dal centro
// il punto di confronto è quello sulla linea di mira a minima distanza dal centro
Point3d ptCfr = ptRef + (( ptCen - ptRef) * vtDir) * vtDir ;
// determino la distanza e la confronto con il minimo
double dSqDist = SqDist( ptCen, ptCfr) ;
@@ -805,7 +779,7 @@ Scene::FindSurfTMSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fram
case SP_PERP :
case SP_MINDIST :
// considero solo il primo triangolo intersecato
// la distanza è nulla e la confronto con il minimo
// la distanza è nulla e la confronto con il minimo
if ( 0 < dMinSqDist) {
bFound = true ;
dMinSqDist = 0 ;
@@ -831,7 +805,7 @@ Scene::FindSurfTMSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fram
break ;
}
// se trovato e modalità shading o hiddenline, la favorisco perchè davanti alle possibili successive
// se trovato e modalità shading o hiddenline, la favorisco perchè davanti alle possibili successive
if ( bFound && ! ( bAlpha || m_nShowMode == SM_WIREFRAME) && dMinSqDist < SRF_SMALL_SQDIST)
dMinSqDist = 0 ;
@@ -843,7 +817,7 @@ bool
Scene::FindSurfFRSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Frame3d& frEnt,
const ISurfFlatRegion* pSfr, double& dMinSqDist)
{
// il punto di riferimento deriva da XY su viewport e Z minima (più vicina a osservatore) da selezione
// il punto di riferimento deriva da XY su viewport e Z minima (più vicina a osservatore) da selezione
Point3d ptWinZ( ptWin.x, ptWin.y, GetSelectedObjMinWinZ()) ;
// punto di riferimento nello spazio geometrico 3d
Point3d ptRef ;
@@ -860,11 +834,11 @@ Scene::FindSurfFRSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fram
// elaborazione a seconda del tipo di snap
bool bFound = false ;
// se richiesto il centro di gravità (baricentro, centroide)
// se richiesto il centro di gravità (baricentro, centroide)
if ( nSnap == SP_CENTROID) {
Point3d ptP ;
if ( pSfr->GetCentroid( ptP)) {
// il punto di confronto è quello sulla linea di mira a minima distanza dal centro
// il punto di confronto è quello sulla linea di mira a minima distanza dal centro
Point3d ptCfr = ptRef + (( ptP - ptRef) * vtDir) * vtDir ;
// determino la distanza e la confronto con il minimo
double dSqDist = SqDist( ptP, ptCfr) ;
@@ -877,12 +851,12 @@ Scene::FindSurfFRSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fram
}
}
}
// se richiesto il centro (è il centroide del chunk più vicino)
// se richiesto il centro (è il centroide del chunk più vicino)
else if ( nSnap == SP_CENTER) {
Point3d ptP ;
for ( int i = 0 ; i < pSfr->GetChunkCount() ; ++ i) {
if ( pSfr->GetChunkCentroid( i, ptP)) {
// il punto di confronto è quello sulla linea di mira a minima distanza dal centro
// il punto di confronto è quello sulla linea di mira a minima distanza dal centro
Point3d ptCfr = ptRef + (( ptP - ptRef) * vtDir) * vtDir ;
// determino la distanza e la confronto con il minimo
double dSqDist = SqDist( ptP, ptCfr) ;
@@ -933,7 +907,7 @@ Scene::FindSurfFRSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fram
}
}
// se trovato e modalità shading o hiddenline, la favorisco perchè davanti alle possibili successive
// se trovato e modalità shading o hiddenline, la favorisco perchè davanti alle possibili successive
if ( bFound && ! ( bAlpha || m_nShowMode == SM_WIREFRAME) && dMinSqDist < SRF_SMALL_SQDIST)
dMinSqDist = 0 ;
@@ -945,7 +919,7 @@ bool
Scene::FindVolZmapSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Frame3d& frEnt,
const IVolZmap* pVzm, double& dMinSqDist)
{
// il punto di riferimento deriva da XY su viewport e Z minima (più vicina a osservatore) da selezione
// il punto di riferimento deriva da XY su viewport e Z minima (più vicina a osservatore) da selezione
Point3d ptWinZ( ptWin.x, ptWin.y, GetSelectedObjMinWinZ()) ;
// punto di riferimento nello spazio geometrico 3d
Point3d ptRef ;
@@ -970,13 +944,13 @@ Scene::FindVolZmapSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fra
Color cCol ;
bool bAlpha = ( m_pGeomDB->GetCalcMaterial( nId, cCol) && cCol.GetIntAlpha() <= ALPHA_LIM) ;
// se richiesto il centro di gravità (baricentro, centroide)
// se richiesto il centro di gravità (baricentro, centroide)
if ( nSnap == SP_CENTROID) {
Point3d ptP ;
bool bFound = false ;
BBox3d b3Loc ;
if ( pVzm->GetLocalBBox( b3Loc) && b3Loc.GetCenter( ptP)) {
// il punto di confronto è quello sulla linea di mira a minima distanza dal vertice
// il punto di confronto è quello sulla linea di mira a minima distanza dal vertice
Point3d ptCfr = ptRef + (( ptP - ptRef) * vtDir) * vtDir ;
// determino la distanza e la confronto con il minimo
double dSqDist = SqDist( ptP, ptCfr) ;
@@ -988,7 +962,7 @@ Scene::FindVolZmapSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fra
m_bLastSnapDirOk = false ;
}
}
// se trovato e modalità shading o hiddenline, la favorisco perchè davanti alle possibili successive
// se trovato e modalità shading o hiddenline, la favorisco perchè davanti alle possibili successive
if ( bFound && ! ( bAlpha || m_nShowMode == SM_WIREFRAME))
dMinSqDist = 0 ;
return bFound ;
@@ -998,7 +972,7 @@ Scene::FindVolZmapSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fra
ILZIVECTOR vInfo ;
if ( ! IntersLineVolZmap( ptMir, vtDir, *pVzm, vInfo))
return false ;
// se non trovato alcunchè, cerco le linee che partono dagli angoli del rettangolo di mira
// se non trovato alcunchè, cerco le linee che partono dagli angoli del rettangolo di mira
Vector3d vtWinD( -1, -1, 0) ;
for ( int i = 0 ; i < 4 && vInfo.size() == 0 ; ++ i) {
// determino punto su vertice del rettangolo di selezione
@@ -1027,7 +1001,7 @@ Scene::FindVolZmapSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fra
for ( int i = 0 ; i < nTtot ; ++ i) {
// triangolo
Triangle3d& trTria = vInfo[i].trTria ;
// recupero il vertice del triangolo più vicino alla linea di mira
// recupero il vertice del triangolo più vicino alla linea di mira
int nVert ; double dSqDist ;
if ( GetTriaVertexNearestToLine( trTria, ptRef, vtDir, nVert, dSqDist) && dSqDist < dMinSqDist) {
bFound = true ;
@@ -1047,7 +1021,7 @@ Scene::FindVolZmapSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fra
for ( int i = 0 ; i < nTtot ; ++ i) {
// triangolo
Triangle3d& trTria = vInfo[i].trTria ;
// recupero il punto medio del lato del triangolo più vicino alla linea di mira
// recupero il punto medio del lato del triangolo più vicino alla linea di mira
Point3d ptMid ; double dSqDist ;
if ( GetTriaMidEdgeNearestToLine( trTria, ptRef, vtDir, ptMid, dSqDist) && dSqDist < dMinSqDist) {
bFound = true ;
@@ -1067,9 +1041,9 @@ Scene::FindVolZmapSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fra
for ( int i = 0 ; i < nTtot ; ++ i) {
// triangolo
Triangle3d& trTria = vInfo[i].trTria ;
// centro più vicino
// centro più vicino
Point3d ptCen = trTria.GetCentroid() ;
// il punto di confronto è quello sulla linea di mira a minima distanza dal centro
// il punto di confronto è quello sulla linea di mira a minima distanza dal centro
Point3d ptCfr = ptRef + (( ptCen - ptRef) * vtDir) * vtDir ;
// determino la distanza e la confronto con il minimo
double dSqDist = SqDist( ptCen, ptCfr) ;
@@ -1089,7 +1063,7 @@ Scene::FindVolZmapSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fra
case SP_PERP :
case SP_MINDIST :
// considero solo il primo triangolo intersecato
// la distanza è nulla e la confronto con il minimo
// la distanza è nulla e la confronto con il minimo
if ( 0 < dMinSqDist) {
bFound = true ;
dMinSqDist = 0 ;
@@ -1103,7 +1077,7 @@ Scene::FindVolZmapSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fra
break ;
}
// se trovato e modalità shading o hiddenline, la favorisco perchè davanti alle possibili successive
// se trovato e modalità shading o hiddenline, la favorisco perchè davanti alle possibili successive
if ( bFound && ! ( bAlpha || m_nShowMode == SM_WIREFRAME) && dMinSqDist < SRF_SMALL_SQDIST)
dMinSqDist = 0 ;
@@ -1291,14 +1265,6 @@ Scene::GetPlaneSnapPoint( const Point3d& ptWin, const Plane3d& plPlane, Point3d&
if ( ! UnProject( ptWin, ptLine))
return false ;
Vector3d vtLine = - m_vtDirCamera ;
if ( ! m_bOrthographic) {
// nella vista prospettica la direzione di mira è data dalla linea che coingiunge le proiezioni di ptWin sui piani near e far
Point3d ptLine2 ;
if ( ! UnProject( Point3d( ptWin.x, ptWin.y, 1), ptLine2))
return false ;
vtLine = ptLine - ptLine2 ;
vtLine.Normalize() ;
}
// determino l'intersezione di questa linea con il piano
double dDenom = vtLine * plPlane.GetVersN() ;