EgtGraphics :

- piccoli aggiustamenti su ZoomOnPoint e ZoomWin per impostazione centro vista.

EgtGraphics.vcxproj

@@ -22,14 +22,14 @@
     <ProjectGuid>{4EC970B1-B4D9-4088-8A31-B462CF72116E}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>EgtGraphics</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.20348.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.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>v141_xp</PlatformToolset>
+    <PlatformToolset>v143</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>v141_xp</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
@@ -108,7 +108,7 @@
       <CompileAs>CompileAsCpp</CompileAs>
       <DisableSpecificWarnings>
       </DisableSpecificWarnings>
-      <LanguageStandard>stdcpp17</LanguageStandard>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -135,7 +135,7 @@ copy $(TargetPath) \EgtProg\DllD32</Command>
       <OpenMPSupport>true</OpenMPSupport>
       <DisableSpecificWarnings>
       </DisableSpecificWarnings>
-      <LanguageStandard>stdcpp17</LanguageStandard>
+      <LanguageStandard>stdcpp20</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>stdcpp17</LanguageStandard>
+      <LanguageStandard>stdcpp20</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>stdcpp17</LanguageStandard>
+      <LanguageStandard>stdcpp20</LanguageStandard>
       <AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
     </ClCompile>
     <Link>

ObjEGrGraphics.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2023
+//  EgalTech 2014-2024
 //----------------------------------------------------------------------------
-// File : ObjEGrGraphics.h          Data : 08.07.23         Versione : 2.5g1
+// File : ObjEGrGraphics.h          Data : 09.03.24         Versione : 2.6c2
 // Contenuto : Dichiarazione della classe grafica di un oggetto geometrico.
 //
 //
@@ -31,8 +31,9 @@ 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) { return false ; }
+      virtual bool SetCurrent( int nCurr) = 0 ;
       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 ;
@@ -40,8 +41,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) = 0 ;
+      virtual bool AddLines( const PNTVECTOR& vPnt, bool bAux = false, bool bSurfSha = false) = 0 ;
-      virtual bool AddPolyLine( const PolyLine& PL, bool bAux = false) = 0 ;
+      virtual bool AddPolyLine( const PolyLine& PL, bool bAux = false, bool bSurfSha = 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

@@ -33,7 +33,7 @@ void
 ObjMultiGraphics::Reset( void)
 {
    m_bValid = false ;
-   m_nCurr = - 1 ;
+   m_nCurr = -1 ;
 }
 
 //----------------------------------------------------------------------------
@@ -51,8 +51,8 @@ void
 ObjMultiGraphics::SetScene( Scene* pScene)
 {
    m_pScene = pScene ;
-   for ( size_t i = 0 ; i < m_vOEGR.size() ; ++ i)
+   for ( auto& pOEGR : m_vOEGR)
-      m_vOEGR[i]->SetScene( pScene) ;
+      pOEGR->SetScene( pScene) ;
 }
 
 //----------------------------------------------------------------------------
@@ -77,6 +77,18 @@ 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)
@@ -136,22 +148,22 @@ ObjMultiGraphics::AddPoints( const PNTVECTOR& vPnt, bool bAux)
 
 //----------------------------------------------------------------------------
 bool
-ObjMultiGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux)
+ObjMultiGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux, bool bSurfSha)
 {
    if ( m_nCurr < 0  ||  m_nCurr >= int( m_vOEGR.size()))
       return false ;
    m_bValid = true ;
-   return m_vOEGR[m_nCurr]->AddLines( vPnt, bAux) ;
+   return m_vOEGR[m_nCurr]->AddLines( vPnt, bAux, bSurfSha) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-ObjMultiGraphics::AddPolyLine( const PolyLine& PL, bool bAux)
+ObjMultiGraphics::AddPolyLine( const PolyLine& PL, bool bAux, bool bSurfSha)
 {
    if ( m_nCurr < 0  ||  m_nCurr >= int( m_vOEGR.size()))
       return false ;
    m_bValid = true ;
-   return m_vOEGR[m_nCurr]->AddPolyLine( PL, bAux) ;
+   return m_vOEGR[m_nCurr]->AddPolyLine( PL, bAux, bSurfSha) ;
 }
 
 //----------------------------------------------------------------------------

ObjMultiGraphics.h

@@ -32,6 +32,7 @@ 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 ;
@@ -39,8 +40,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) override ;
+      bool AddLines( const PNTVECTOR& vPnt, bool bAux = false, bool bSurfSha = false) override ;
-      bool AddPolyLine( const PolyLine& PL, bool bAux = false) override ;
+      bool AddPolyLine( const PolyLine& PL, bool bAux = false, bool bSurfSha = 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

@@ -52,6 +52,15 @@ 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)
@@ -165,7 +174,7 @@ ObjNewGraphics::AddPoints( const PNTVECTOR& vPnt, bool bAux)
 
 //----------------------------------------------------------------------------
 bool
-ObjNewGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux)
+ObjNewGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux, bool bSurfSha)
 {
    if ( m_pScene == nullptr  ||  ! m_pScene->MakeCurrent())
       return false ;
@@ -195,7 +204,7 @@ ObjNewGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux)
    glEnableClientState( GL_VERTEX_ARRAY) ;
    glBindVertexArray( 0) ;
   // aggiungo i dati in lista
-   AddNgaVerts( GL_LINES, nCount, nVaoId, nVboId, bAux) ;
+   AddNgaVerts( GL_LINES, nCount, nVaoId, nVboId, bAux, bSurfSha) ;
   // dichiaro valida la grafica
    m_bValid = true ;
 
@@ -204,7 +213,7 @@ ObjNewGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux)
 
 //----------------------------------------------------------------------------
 bool
-ObjNewGraphics::AddPolyLine( const PolyLine& PL, bool bAux)
+ObjNewGraphics::AddPolyLine( const PolyLine& PL, bool bAux, bool bSurfSha)
 {
    if ( m_pScene == nullptr  ||  ! m_pScene->MakeCurrent())
       return false ;
@@ -236,7 +245,7 @@ ObjNewGraphics::AddPolyLine( const PolyLine& PL, bool bAux)
    glEnableClientState( GL_VERTEX_ARRAY) ;
    glBindVertexArray( 0) ;
   // aggiungo i dati in lista
-   AddNgaVerts( GL_LINE_STRIP, nCount, nVaoId, nVboId, bAux) ;
+   AddNgaVerts( GL_LINE_STRIP, nCount, nVaoId, nVboId, bAux, bSurfSha) ;
   // dichiaro valida la grafica
    m_bValid = true ;
 
@@ -377,9 +386,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) {
+      if ( nMark == GDB_MK_ON  ||  nMark == GDB_MK_ON_2) {
          bStdCol = false ;
-         Color colMark = m_pScene->GetMark() ;
+         Color colMark = m_pScene->GetMark( nMark) ;
          colMark.SetAlpha( nAlpha) ;
          colMark.GetFloat( fSelMarkCol) ;
          Color colMarkBack = GetSurfBackColor( colMark) ;
@@ -424,6 +433,13 @@ 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 ;
@@ -461,7 +477,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  &&  ! bSurfSha) {
+   if ( ( nMark == GDB_MK_ON  ||  nMark == GDB_MK_ON_2)  &&  ! bSurfSha) {
      // cambio test di depth per non sovrascrivere il disegno appena fatto
       glDepthFunc( GL_LESS) ;
 
@@ -470,7 +486,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() ;
+      Color colMark = m_pScene->GetMark( nMark) ;
       glColor4f( colMark.GetRed(), colMark.GetGreen(), colMark.GetBlue(), colMark.GetAlpha()) ;
 
      // ciclo di disegno
@@ -514,7 +530,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) {
+   if ( nStat == GDB_ST_SEL  ||  nMark == GDB_MK_ON  ||  nMark == GDB_MK_ON_2) {
       glPointSize( (float) m_pScene->GetPointSize()) ;
       glLineWidth( (float) m_pScene->GetLineWidth()) ;
    }

ObjNewGraphics.h

@@ -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, COLOR = 3,
+      enum GrType { NONE = 0, VERTS = 1, VERTS_A = 2, VERTS_S = 3, COLOR = 4,
-                    MAT_A = 4, MAT_D = 5, MAT_S = 6, MAT_SH = 7, MAT_B = 8, LINE_STIPPLE = 9} ;
+                    MAT_A = 5, MAT_D = 6, MAT_S = 7, MAT_SH = 8, MAT_B = 9, LINE_STIPPLE = 10} ;
 
    public :
       GrType m_nType ;
@@ -69,7 +69,10 @@ 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 ;
@@ -77,8 +80,8 @@ 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) override ;
+      bool AddLines( const PNTVECTOR& vPnt, bool bAux = false, bool bSurfSha = false) override ;
-      bool AddPolyLine( const PolyLine& PL, bool bAux = false) override ;
+      bool AddPolyLine( const PolyLine& PL, bool bAux = false, bool bSurfSha = 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 ;
@@ -87,7 +90,7 @@ class ObjNewGraphics : public ObjEGrGraphics
               { b3Loc = m_b3Loc ; return ! m_b3Loc.IsEmpty() ; }
 
    public :
-      ObjNewGraphics( void) : m_pScene( nullptr), m_bValid( false)  {}
+      ObjNewGraphics( void) : m_pScene( nullptr), m_bValid( false), m_nCurrMode( GL_NONE)  {}
 
    private :
       bool DeleteVaoVbo( void) ;
@@ -95,9 +98,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 AddNgaVerts( int nMode, int nCount, unsigned int nVaoId, unsigned int nVboId, bool bAux = false, bool bSurfSha = false)
               { NgAtom nga ;
-                nga.m_nType = ( bAux ? NgAtom::VERTS_A : NgAtom::VERTS) ;
+                nga.m_nType = ( bSurfSha ? NgAtom::VERTS_S : ( 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

@@ -48,6 +48,15 @@ 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)
@@ -129,7 +138,7 @@ ObjOldGraphics::AddPoints( const PNTVECTOR& vPnt, bool bAux)
 
 //----------------------------------------------------------------------------
 bool
-ObjOldGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux)
+ObjOldGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux, bool bSurfSha)
 {
   // modo corrente deve essere nullo
    if ( m_nCurrMode != GL_NONE)
@@ -137,7 +146,7 @@ ObjOldGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux)
   // riservo memoria per vettore
    m_ogaVect.reserve( VECT_HEAP + vPnt.size()) ;
   // start
-   AddOgaStart( GL_LINES, bAux) ;
+   AddOgaStart( GL_LINES, bAux, bSurfSha) ;
   // inserisco i vertici + aggiorno bbox
    for ( int i = 0 ; i < int( vPnt.size()) ; ++ i) {
       AddOgaVert3f( vPnt[i]) ;
@@ -153,7 +162,7 @@ ObjOldGraphics::AddLines( const PNTVECTOR& vPnt, bool bAux)
 
 //----------------------------------------------------------------------------
 bool
-ObjOldGraphics::AddPolyLine( const PolyLine& PL, bool bAux)
+ObjOldGraphics::AddPolyLine( const PolyLine& PL, bool bAux, bool bSurfSha)
 {
   // modo corrente deve essere nullo
    if ( m_nCurrMode != GL_NONE)
@@ -161,7 +170,7 @@ ObjOldGraphics::AddPolyLine( const PolyLine& PL, bool bAux)
   // riservo memoria per vettore
    m_ogaVect.reserve( VECT_HEAP + PL.GetPointNbr()) ;
   // start
-   AddOgaStart( GL_LINE_STRIP, bAux) ;
+   AddOgaStart( GL_LINE_STRIP, bAux, bSurfSha) ;
   // inserisco i nuovi vertici + aggiorno bbox
    Point3d  ptP ;
    for ( bool bFound = PL.GetFirstPoint( ptP) ; bFound ; bFound = PL.GetNextPoint( ptP)) {
@@ -245,6 +254,9 @@ 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 ;
@@ -262,9 +274,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) {
+      if ( nMark == GDB_MK_ON  ||  nMark == GDB_MK_ON_2) {
          bStdCol = false ;
-         Color colMark = ( ( GetScene() != nullptr) ? GetScene()->GetMark() : Color( 255, 255, 0)) ;
+         Color colMark = m_pScene->GetMark( nMark) ;
          colMark.SetAlpha( nAlpha) ;
          colMark.GetFloat( fSelMarkCol) ;
          Color colMarkBack = GetSurfBackColor( colMark) ;
@@ -273,7 +285,7 @@ ObjOldGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
       }
       else if ( nStat == GDB_ST_SEL) {
          bStdCol = false ;
-         Color colSelSurf = ( ( GetScene() != nullptr) ? GetScene()->GetSelSurf() : Color( 255, 255, 192)) ;
+         Color colSelSurf = m_pScene->GetSelSurf() ;
          colSelSurf.SetAlpha( nAlpha) ;
          colSelSurf.GetFloat( fSelMarkCol) ;
          Color colSelSurfBack = GetSurfBackColor( colSelSurf) ;
@@ -292,34 +304,45 @@ ObjOldGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
    }
 
   // ciclo di disegno
-   bool bStartA = false ;
+   bool bSkip = false ;
    bool bLineStipple = false ;
    for ( const auto& Oga : m_ogaVect) {
       switch ( Oga.m_nType) {
       case OgAtom::START :
          glBegin( Oga.m_nMode) ;
-         bStartA = false ;
+         bSkip = false ;
          break ;
       case OgAtom::START_A :
-         if ( bShowAux)
+         if ( bShowAux) {
             glBegin( Oga.m_nMode) ;
-         bStartA = true ;
+            bSkip = false ;
+         }
+         else
+            bSkip = true ;
+         break ;
+      case OgAtom::START_S :
+         if ( bSurfSha) {
+            glBegin( Oga.m_nMode) ;
+            bSkip = false ;
+         }
+         else
+            bSkip = true ;
          break ;
       case OgAtom::END :
-         if ( ! bStartA  ||  bShowAux) 
+         if ( ! bSkip) 
             glEnd() ;
-         bStartA = false ;
+         bSkip = false ;
          break ;
       case OgAtom::VERT :
-         if ( ! bStartA  ||  bShowAux) 
+         if ( ! bSkip) 
             glVertex3fv( Oga.m_fVal) ;
          break ;
       case OgAtom::BND_FLAG :
-         if ( ! bStartA  ||  bShowAux) 
+         if ( ! bSkip ) 
             glEdgeFlag( Oga.m_nFlag) ;
          break ;
       case OgAtom::NORMAL :
-         if ( ! bStartA  ||  bShowAux) 
+         if ( ! bSkip) 
             glNormal3fv( Oga.m_fVal) ;
          break ;
       case OgAtom::COLOR :
@@ -359,7 +382,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  &&  ! bSurfSha) {
+   if ( ( nMark == GDB_MK_ON  ||  nMark == GDB_MK_ON_2)  &&  ! bSurfSha) {
      // cambio test di depth per non sovrascrivere il disegno appena fatto
       glDepthFunc( GL_LESS) ;
 
@@ -368,7 +391,7 @@ ObjOldGraphics::Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlph
       glLineWidth( (float) m_pScene->GetMarkLineWidth()) ;
 
      // colore di marcatura
-      Color colMark = ( ( GetScene() != nullptr) ? GetScene()->GetMark() : Color( 192, 192, 0)) ;
+      Color colMark = m_pScene->GetMark( nMark) ;
       glColor4f( colMark.GetRed(), colMark.GetGreen(), colMark.GetBlue(), colMark.GetAlpha()) ;
 
      // ciclo di disegno
@@ -422,7 +445,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) {
+   if ( nStat == GDB_ST_SEL  ||  nMark == GDB_MK_ON  ||  nMark == GDB_MK_ON_2) {
       glPointSize( (float) m_pScene->GetPointSize()) ;
       glLineWidth( (float) m_pScene->GetLineWidth()) ;
    }

ObjOldGraphics.h

@@ -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, END = 3, VERT = 4, BND_FLAG = 5, NORMAL = 6,
+      enum GrType { NONE = 0, START = 1, START_A = 2, START_S = 3, END = 4, VERT = 5, BND_FLAG = 6, NORMAL = 7,
-                    COLOR = 7, MAT_A = 8, MAT_D = 9, MAT_S = 10, MAT_SH = 11, MAT_B = 12, LINE_STIPPLE = 13} ;
+                    COLOR = 8, MAT_A = 9, MAT_D = 10, MAT_S = 11, MAT_SH = 12, MAT_B = 13, LINE_STIPPLE = 14} ;
 
    public :
       GrType m_nType ;
@@ -74,7 +74,10 @@ 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 ;
@@ -82,8 +85,8 @@ 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) override ;
+      bool AddLines( const PNTVECTOR& vPnt, bool bAux = false, bool bSurfSha = false) override ;
-      bool AddPolyLine( const PolyLine& PL, bool bAux = false) override ;
+      bool AddPolyLine( const PolyLine& PL, bool bAux = false, bool bSurfSha = 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 ;
@@ -99,9 +102,9 @@ class ObjOldGraphics : public ObjEGrGraphics
               { try { m_ogaVect.push_back( oga) ; }
                 catch(...) { return false ; }
                 return true ; }
-      bool AddOgaStart( int nMode, bool bAux = false)
+      bool AddOgaStart( int nMode, bool bAux = false, bool bSurfSha = false)
               { OgAtom oga ;
-                oga.m_nType = ( bAux ? OgAtom::START_A : OgAtom::START) ;
+                oga.m_nType = ( bSurfSha ? OgAtom::START_S : ( bAux ? OgAtom::START_A : OgAtom::START)) ;
                 oga.m_nMode = nMode ;
                 return AddOgAtom( oga) ; }
       bool AddOgaEnd( void)

Scene.h

@@ -1,12 +1,13 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2014-2024
 //----------------------------------------------------------------------------
-// File : Scene.h           Data : 09.01.24           Versione : 2.5l7
+// File : Scene.h           Data : 16.02.24           Versione : 2.6b4
 // Contenuto : Dichiarazione della classe gestione scena.
 //
 //
 //
 // Modifiche : 29.01.14 DS Creazione modulo.
+//             16.02.24 DS Aggiunte Set/Get CameraDirOrizzOffset.
 //
 //
 //----------------------------------------------------------------------------
@@ -89,11 +90,15 @@ class Scene : public IEGrScene
       void Destroy( void) override ;
      // Camera
       bool SetCenter( const Point3d& ptCenter) override ;
+      bool SetCameraDirOrizzOffset( int nRightStepOffset = 0) override
+                { m_nOrizzOffsCamera = nRightStepOffset ; return true ; }
       bool SetCamera( double dAngVertDeg, double dAngOrizzDeg, double dDist) override ;
       bool SetCamera( int nDir, double dDist = 0) override ;
       const Point3d& GetCenter( void) const override
                 { return m_ptCenter ; }
       Point3d GetProjectedCenter( void) const override ;
+      int  GetCameraDirOrizzOffset( void) const override
+                { return m_nOrizzOffsCamera ; }
       void GetCamera( double* pdAngVertDeg, double* pdAngOrizzDeg, double* pdDist = nullptr) const override ;
       int  GetCameraDir( void) const override ;
       const Vector3d& GetCameraUp( void) const override
@@ -107,6 +112,8 @@ class Scene : public IEGrScene
       bool ZoomOnPoint( const Point3d& ptWin, double dCoeff) override ;
       bool ZoomWin( const Point3d& ptWin1, const Point3d& ptWin2) override ;
       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  &&
@@ -137,6 +144,7 @@ class Scene : public IEGrScene
       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
@@ -223,8 +231,8 @@ class Scene : public IEGrScene
       double GetFrameLineWidth( void) const
                { return m_dFrameLineWidth ; }
      // Geometry
-      Color GetMark( void) const
+      Color GetMark( int nMark) const
-               { return m_colMark ; }
+               { return ( nMark == GDB_MK_ON_2 ? m_colMark2 : m_colMark) ; }
       Color GetSelSurf( void) const
                { return m_colSelSurf ; }
 
@@ -238,10 +246,13 @@ class Scene : public IEGrScene
       bool MyDraw( bool bSwapBF) ;
       bool Background( void) ;
       bool Prepare( void) ;
+      bool GetPixelZ( const Point3d& ptWin, double& dWinZ) ;
      // Camera
-      bool VerifyCamera( void) ;
+      bool VerifyCamera( bool bUseOrizzOffsCamera = false) ;
-      bool CalcDirUp( void) ;
+      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) ;
@@ -288,15 +299,19 @@ class Scene : public IEGrScene
       HDC      m_hDC ;                    // Device Context
       HGLRC    m_hRC ;                    // OpenGL Rendering Context 
       int      m_nOglVer ;                // OpenGL Version
-      bool     m_bNewWay ;                // flag che indica nuova modalità (OpenGL 3.0 in poi)
+      bool     m_bNewWay ;                // flag che indica nuova modalità (OpenGL 3.0 in poi)
      // Camera
-      Point3d  m_ptCenter ;               // centro verso cui è rivolta la 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
@@ -306,7 +321,7 @@ class Scene : public IEGrScene
       int      m_nShowMode ;              // modo di visualizzazione (wireframe, hiddenline, shading)
       bool     m_bShowCurveDirection ;    // flag di visualizzazione direzione curve
       bool     m_bShowTriaAdvanced ;      // flag per abilitare la visualizzazione avanzata dei triangoli
-      int      m_nShowZmap ;              // modo visualizzazione Zmap (+1=surf, +2=spilloni, +4=normali, +8=più colori)
+      int      m_nShowZmap ;              // modo visualizzazione Zmap (+1=surf, +2=spilloni, +4=normali, +8=più colori)
       int      m_nShowText ;              // modo visualizzazione scritte (1=solo contorni, 2=con riempimento)
      // PointSize - LineWidth
       double   m_dPointSize ;             // dimensione punti
@@ -331,14 +346,15 @@ 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
+      bool     m_bLastSnapDirOk ;         // flag validità direzione associata a ultimo punto snap
       Vector3d m_vtLastSnapDir ;          // direzione associata a ultimo punto snap 
      // Geometry
       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
@@ -381,3 +397,10 @@ 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

@@ -53,15 +53,18 @@ Scene::Scene( void)
    m_bNewWay = false ;
   // 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 ;
@@ -88,6 +91,7 @@ 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) ;
@@ -136,7 +140,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 ;
@@ -213,7 +217,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 ;
 
@@ -224,7 +228,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 !")
@@ -286,11 +290,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 ;
@@ -417,7 +421,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
@@ -513,8 +517,14 @@ 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) ;
-   m_dZNear = - ( ptCenter.z + dExtent) ;
+   if ( m_bOrthographic) {
-   m_dZFar = - ( ptCenter.z - dExtent) ;
+      m_dZNear = - ( ptCenter.z + dExtent) ;
+      m_dZFar = - ( ptCenter.z - dExtent) ;   
+   }
+   else {
+      m_dZNear = PERSPECTIVE_NEAR_PLANE ;
+      m_dZFar = abs( ptCenter.z - dExtent) ;
+   }
    return true ;
 }
 
@@ -671,6 +681,9 @@ 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) ;
@@ -682,7 +695,27 @@ Scene::Prepare( void)
      // imposto area di pick
       gluPickMatrix( m_ptSelCent.x, ( Viewport[3] - m_ptSelCent.y), m_nSelW, m_nSelH, Viewport) ;
    }
-   glOrtho( - m_dHalfWidth, m_dHalfWidth, - m_dHalfHeight, m_dHalfHeight, m_dZNear, m_dZFar) ;
+
+   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) ;
+   }
 
   // imposto matrice modello/vista
    glMatrixMode( GL_MODELVIEW) ;
@@ -729,12 +762,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()) ;
@@ -747,7 +780,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()) ;
@@ -908,6 +941,61 @@ 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 quanto 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 pixel 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.1f  &&  dZ < 0.9f)
+      dWinZ = dZ ;
+   else {
+      bOk = false ;
+      dWinZ = GetProjectedCenter().z ;
+   }
+
+  // reset dei parametri
+   m_bSelect = false ;
+   Prepare() ;
+
+   return bOk ;
+}
+
 //----------------------------------------------------------------------------
 void
 Scene::Destroy( void)

SceneCamera.cpp

@@ -14,9 +14,11 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "Scene.h"
-#include "/EgtDev/Include/EgtILogger.h"
-#include "/EgtDev/Include/EGnStringUtils.h"
 #include "/EgtDev/Include/EGkFrame3d.h"
+#include "/EgtDev/Include/EGnStringUtils.h"
+#include "/EgtDev/Include/EgtNumUtils.h"
+#include "/EgtDev/Include/EgtILogger.h"
+
 
 using namespace std ;
 
@@ -24,6 +26,75 @@ 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 ;
+}
+
 //----------------------------------------------------------------------------
 bool
 Scene::SetCenter( const Point3d& ptCenter)
@@ -41,9 +112,10 @@ Scene::SetCenter( const Point3d& ptCenter)
 bool
 Scene::SetCamera( double dAngVertDeg, double dAngOrizzDeg, double dDist)
 {
-  // assegno la direzione e la distanza
+  // assegno la direzione ed eventuale distanza
    m_vtDirCamera = FromSpherical( 1, dAngVertDeg, dAngOrizzDeg) ;
-   m_dDistCamera = dDist ;
+   if ( dDist > EPS_SMALL)
+      m_dDistCamera = dDist ;
    if ( ! VerifyCamera())
       return false ;
   // se vista da sopra, impongo vtUp da angolo orizzontale
@@ -83,16 +155,16 @@ Scene::SetCamera( int nDir, double dDist)
       m_vtDirCamera.Set( 0, 0, -1) ;
       break ;
    case CT_ISO_SW :
-      m_vtDirCamera.Set( - SQRT1_3, - SQRT1_3, SQRT1_3) ;
+      m_vtDirCamera.Set( -SQRT1_3, -SQRT1_3, SQRT1_3) ;
       break ;
    case CT_ISO_SE :
-      m_vtDirCamera.Set( SQRT1_3, - SQRT1_3, SQRT1_3) ;
+      m_vtDirCamera.Set( SQRT1_3, -SQRT1_3, SQRT1_3) ;
       break ;
    case CT_ISO_NE :
       m_vtDirCamera.Set( SQRT1_3, SQRT1_3, SQRT1_3) ;
       break ;
    case CT_ISO_NW :
-      m_vtDirCamera.Set( - SQRT1_3, SQRT1_3, SQRT1_3) ;
+      m_vtDirCamera.Set( -SQRT1_3, SQRT1_3, SQRT1_3) ;
       break ;
    case CT_CPLANE :
       m_vtDirCamera = GetGridFrame().VersZ() ;
@@ -101,29 +173,39 @@ Scene::SetCamera( int nDir, double dDist)
       return false ;
       break ;
    }
-   m_dDistCamera = dDist ;
+   if ( nDir != CT_CPLANE)
+      m_vtDirCamera.Rotate( Z_AX, m_nOrizzOffsCamera * ANG_RIGHT) ;
 
-   return VerifyCamera() ;
+  // assegno eventuale distanza
+   if ( dDist > EPS_SMALL)
+      m_dDistCamera = dDist ;
+
+   return VerifyCamera( nDir != CT_CPLANE) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Scene::VerifyCamera( void)
+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)
+  // ricalcolo direzione Up
-      m_dDistCamera = STD_DIST_CAMERA ;
-   else
-      m_dDistCamera = max( m_dDistCamera, MIN_DIST_CAMERA) ;
-  // invalido Up e ExtView
    m_bUpOk = false ;
+   if ( ! CalcDirUp( bUseOrizzOffsCamera))
+      return false ;
+
+  // verifico la distanza
+   m_bDistOk = false ;
+   CalcDistCamera() ;
+
+  // ricalcolo ExtView
    m_bExtViewOk = false ;
+   if ( ! CalcExtView())
+      return false ;
   // calcolo nuovi dati di Z clipping
-   CalcClippingPlanesFromExtView() ;
+   return CalcClippingPlanesFromExtView() ;
-   return true ;
 }
 
 //----------------------------------------------------------------------------
@@ -157,25 +239,27 @@ Scene::GetCamera( double* pdAngVertDeg, double* pdAngOrizzDeg, double* pdDist) c
 int
 Scene::GetCameraDir( void) const
 {
-   if ( m_vtDirCamera.IsZplus())
+   Vector3d vtDir = m_vtDirCamera ;
+   vtDir.Rotate( Z_AX, - m_nOrizzOffsCamera * ANG_RIGHT) ;
+   if ( vtDir.IsZplus())
       return CT_TOP ;
-   else if (  m_vtDirCamera.IsYminus())
+   else if (  vtDir.IsYminus())
       return CT_FRONT ;
-   else if (  m_vtDirCamera.IsXplus())
+   else if (  vtDir.IsXplus())
       return CT_RIGHT ;
-   else if (  m_vtDirCamera.IsYplus())
+   else if (  vtDir.IsYplus())
       return CT_BACK ;
-   else if (  m_vtDirCamera.IsXminus())
+   else if (  vtDir.IsXminus())
       return CT_LEFT ;
-   else if (  m_vtDirCamera.IsZminus())
+   else if (  vtDir.IsZminus())
       return CT_BOTTOM ;
-   else if (  AreSameVectorApprox( m_vtDirCamera, Vector3d( - SQRT1_3, - SQRT1_3, SQRT1_3)))
+   else if (  AreSameVectorApprox( vtDir, Vector3d( - SQRT1_3, - SQRT1_3, SQRT1_3)))
       return CT_ISO_SW ;
-   else if (  AreSameVectorApprox( m_vtDirCamera, Vector3d( SQRT1_3, - SQRT1_3, SQRT1_3)))
+   else if (  AreSameVectorApprox( vtDir, Vector3d( SQRT1_3, - SQRT1_3, SQRT1_3)))
       return CT_ISO_SE ;
-   else if (  AreSameVectorApprox( m_vtDirCamera, Vector3d( SQRT1_3, SQRT1_3, SQRT1_3)))
+   else if (  AreSameVectorApprox( vtDir, Vector3d( SQRT1_3, SQRT1_3, SQRT1_3)))
       return CT_ISO_NE ;
-   else if (  AreSameVectorApprox( m_vtDirCamera, Vector3d( - SQRT1_3, SQRT1_3, SQRT1_3)))
+   else if (  AreSameVectorApprox( vtDir, Vector3d( - SQRT1_3, SQRT1_3, SQRT1_3)))
       return CT_ISO_NW ;
    else
       return CT_NONE ;
@@ -194,16 +278,19 @@ Scene::GetProjectedCenter( void) const
 
 //----------------------------------------------------------------------------
 bool
-Scene::CalcDirUp( void)
+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())
+   if ( ! vtPerpXY.Normalize()) {
       vtPerpXY = -X_AX ;
+      if ( bUseOrizzOffsCamera)
+         vtPerpXY.Rotate( Z_AX, m_nOrizzOffsCamera * ANG_RIGHT) ;
+   }
   // direzione Up
    m_vtUp = vtPerpXY ^ m_vtDirCamera ;
    m_bUpOk = m_vtUp.Normalize() ;
@@ -234,19 +321,29 @@ bool
 Scene::PanCamera( const Point3d& ptWinOld, const Point3d& ptWinNew)
 {
   // porto i due punti in coordinate mondo
-   double dZCenter = GetProjectedCenter().z ;
+   double dOldZCenter ;
-   Point3d ptViewOld( ptWinOld.x, ptWinOld.y, dZCenter) ;
+   GetPixelZ( ptWinOld, dOldZCenter) ;
+   Point3d ptViewOld( ptWinOld.x, ptWinOld.y, dOldZCenter) ;
    Point3d ptWorldOld ;
    if ( ! UnProject( ptViewOld, ptWorldOld))
       return false ;
-   Point3d ptViewNew( ptWinNew.x, ptWinNew.y, dZCenter) ;
+   double dNewZCenter ;
+   GetPixelZ( ptWinNew, dNewZCenter) ;
+   Point3d ptViewNew( ptWinNew.x, ptWinNew.y, dNewZCenter) ;
    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
-   return SetCenter( GetCenter() - vtMove) ;
+   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 ;
 } 
 
 //----------------------------------------------------------------------------
@@ -292,6 +389,31 @@ 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 ;
@@ -334,8 +456,32 @@ 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 ;
+   m_ptCenter = ptCent ;  
-   return AdjustDimView( dHalfWidth, dHalfHeight) ;
+   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 ;
 }
 
 //----------------------------------------------------------------------------
@@ -343,7 +489,19 @@ bool
 Scene::ZoomRadius( double dRadius)
 {
   // adatto le dimensioni a quelle della vista
-   return AdjustDimView( dRadius, dRadius) ;
+   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 ;
 }
 
 //----------------------------------------------------------------------------
@@ -353,14 +511,17 @@ Scene::ZoomChange( double dCoeff)
    const double MIN_COEFF = 0.5 ;
    const double MAX_COEFF = 2 ;
 
-  // controllo i limiti
-   if ( dCoeff < MIN_COEFF)
-      dCoeff = MIN_COEFF ;
-   else if ( dCoeff > MAX_COEFF)
-      dCoeff = MAX_COEFF ;
   // cambio le dimensioni di zoom
-   m_dHalfWidth *= dCoeff ;
+   if ( ! m_bOrthographic  &&  m_nPerspZoomType == ZT_DOLLY) {
-   m_dHalfHeight *= dCoeff ;
+     // 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 ;  
+   }
 
    return true ;
 }
@@ -369,15 +530,45 @@ Scene::ZoomChange( double dCoeff)
 bool
 Scene::ZoomOnPoint( const Point3d& ptWin, double dCoeff)
 {
+  // leggo Z del pixel
+   double dWinZ ;
+   GetPixelZ( ptWin, dWinZ) ;
+
   // porto il punto in coordinate mondo
-   Point3d ptView( ptWin.x, ptWin.y, GetProjectedCenter().z) ;
+   Point3d ptView( ptWin.x, ptWin.y, dWinZ) ;
    Point3d ptWorld ;
    if ( ! UnProject( ptView, ptWorld))
       return false ;
+
   // modifico opportunamente il centro di vista
-   Point3d ptNewCen = ptWorld + ( GetCenter() - ptWorld) * dCoeff ; 
+   Point3d ptOldCen = m_ptCenter ;
+   Point3d ptNewCen = ptWorld + ( m_ptCenter - ptWorld) * dCoeff ;
+   ptNewCen += ( ptWorld - ptNewCen) * m_vtDirCamera * m_vtDirCamera ;
    SetCenter( ptNewCen) ;
-  // eseguo lo zoom
+   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) ;
+         }
+      }
+   }
+
    return ZoomChange( dCoeff) ;
 }
 
@@ -385,12 +576,16 @@ Scene::ZoomOnPoint( const Point3d& ptWin, double dCoeff)
 bool
 Scene::ZoomWin( const Point3d& ptWin1, const Point3d& ptWin2)
 {
+  // leggo Z del pixel
+   double dWinZ ;
+   GetPixelZ( Media( ptWin1, ptWin2), dWinZ) ;
+
   // porto i punti in coordinate mondo
    Point3d ptWorld1 ;
-   if ( ! UnProject( Point3d( ptWin1.x, ptWin1.y, GetProjectedCenter().z), ptWorld1))
+   if ( ! UnProject( Point3d( ptWin1.x, ptWin1.y, dWinZ), ptWorld1))
       return false ;
    Point3d ptWorld2 ;
-   if ( ! UnProject( Point3d( ptWin2.x, ptWin2.y, GetProjectedCenter().z), ptWorld2))
+   if ( ! UnProject( Point3d( ptWin2.x, ptWin2.y, dWinZ), ptWorld2))
       return false ;
 
   // recupero il riferimento della camera (vista)
@@ -411,7 +606,18 @@ Scene::ZoomWin( const Point3d& ptWin1, const Point3d& ptWin2)
    double dHalfHeight = 0.5 * abs( ptView1.y - ptView2.y) ;
 
   // adatto le dimensioni a quelle della vista
-   return AdjustDimView( dHalfWidth, dHalfHeight) ;
+   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 ;
 }
 
 //----------------------------------------------------------------------------

SceneGeom.cpp

@@ -64,6 +64,14 @@ Scene::SetMark( Color colMark)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+Scene::SetMark2( Color colMark)
+{
+   m_colMark2 = colMark ;
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 Scene::SetSelSurf( Color colSelSurf)
@@ -135,7 +143,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() ;
@@ -166,7 +174,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 ;
@@ -220,6 +228,10 @@ 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
@@ -228,17 +240,25 @@ 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 += 2 * pZmap->GetBlockCount() ;
+               nCount += ZMAP_COL * 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  &&  pSTM->GetMaxTFlag() > 0)
+         if ( pSTM != nullptr) {
-            nCount = 2 ;
+            if ( pSTM->GetMaxTFlag() > 0)
+               nCount = STM_COL ;
+            else
+               nCount = 1 ;
+            if ( pSTM->GetShowEdges())
+               nCount += 1 ;
+         }
       }
-     // 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) {
@@ -263,7 +283,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 ;
@@ -366,11 +386,14 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
          if ( pSTM == nullptr)
             return false ;
         // superficie con visualizzazione standard
-         if ( pSTM->GetMaxTFlag() == 0) {
+         bool bTwoColors = ( pSTM->GetMaxTFlag() > 0) ;
+         if ( ! bTwoColors) {
            // 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
@@ -396,11 +419,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] ;
@@ -408,7 +431,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) ;
@@ -425,12 +448,13 @@ 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
-               pGraphics->SetCurrent( j) ;
+               if ( pGraphics->SetCurrent( j))
-              // lo pulisco
+                  pGraphics->Clear() ;
-               pGraphics->Clear() ;
               // se non ci sono triangoli, passo oltre
-               if ( nTri[j] == 0)
+               if ( nTri[j] == 0) {
+                  pGraphics->Validate() ;
                   continue ;
+               }
               // assegno materiali
                pGraphics->AddColor( cCol[j]) ;  // per wireframe
                pGraphics->AddMaterial( mMat[j].GetAmbient(), mMat[j].GetDiffuse(),
@@ -454,6 +478,28 @@ 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) {
@@ -463,8 +509,6 @@ 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
@@ -476,9 +520,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) ;
@@ -492,9 +536,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 già aggiornato, vado oltre
+              // Se blocco non esistente o già aggiornato, vado oltre
-               pGraphics->SetCurrent( ZMAP_COL * i) ;
+               if ( ! pGraphics->SetCurrent( ZMAP_COL * i)  ||
-               if ( pZmap->GetBlockUpdatingCounter( i) <= pGraphics->GetCounter())
+                    pZmap->GetBlockUpdatingCounter( i) <= pGraphics->GetCounter())
                   continue ;
               // Recupero i triangoli del blocco
                TRIA3DEXVECTOR vTria ;
@@ -509,8 +553,9 @@ 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
+                 // Imposto indice blocco corrente, se non esiste passo oltre
-                  pGraphics->SetCurrent( ZMAP_COL * i + j) ;
+                  if ( ! pGraphics->SetCurrent( ZMAP_COL * i + j))
+                     continue ;
                  // lo pulisco
                   pGraphics->Clear() ;
                  // se non ci sono triangoli, passo oltre
@@ -538,46 +583,68 @@ Scene::DrawGeoObj( const IGdbIterator& iIter, int nPass, const MdStMkCol& siObj)
             }
          }
         // visualizzazione spilloni e normali (sempre nell'ultimo blocco)
-         if ( ( m_nShowZmap & ZSM_LINES) != 0  ||  ( m_nShowZmap & ZSM_NORMALS) != 0) {
+         bool bLinNrmShow = ( ( m_nShowZmap & ZSM_LINES) != 0  ||  ( m_nShowZmap & ZSM_NORMALS) != 0) ;
+         if ( bLinNrmShow) {
            // imposto indice blocco corrente
-            pGraphics->SetCurrent( ZMAP_COL * nCount) ;
+            if ( pGraphics->SetCurrent( ZMAP_COL * nCount)) {
-           // lo pulisco
+              // lo pulisco
-            pGraphics->Clear() ;
+               pGraphics->Clear() ;
-           // ciclo sui tre gruppi di spilloni
+              // ciclo sui tre gruppi di spilloni
-            int nKmin = ( m_nShowZmap & ZSM_LINES) != 0 ? 0 : 3 ;
+               int nKmin = ( m_nShowZmap & ZSM_LINES) != 0 ? 0 : 3 ;
-            int nKmax = ( m_nShowZmap & ZSM_NORMALS) != 0 ? 6 : 3 ;
+               int nKmax = ( m_nShowZmap & ZSM_NORMALS) != 0 ? 6 : 3 ;
-            Color vCol[6] = {BLUE, RED, GREEN, BLUE, RED, GREEN} ;
+               Color vCol[6] = {BLUE, RED, GREEN, BLUE, RED, GREEN} ;
-            for ( int k = nKmin ; k < nKmax ; ++ k) {
+               for ( int k = nKmin ; k < nKmax ; ++ k) {
-               pGraphics->AddColor( vCol[k]) ;
+                  pGraphics->AddColor( vCol[k]) ;
-               pGraphics->AddMaterial( vCol[k], vCol[k], vCol[k], 10) ;
+                  pGraphics->AddMaterial( vCol[k], vCol[k], vCol[k], 10) ;
-               pGraphics->AddBackMaterial( vCol[k]) ;
+                  pGraphics->AddBackMaterial( vCol[k]) ;
-               PNTVECTOR vPnt ;
+                  PNTVECTOR vPnt ;
-               for ( int i = 0 ; ; ++ i) {
+                  for ( int i = 0 ; ; ++ i) {
-                  bool bOutBreak = false ;
+                     bool bOutBreak = false ;
-                  for ( int j = 0 ; ; ++ j) {
+                     for ( int j = 0 ; ; ++ j) {
-                     POLYLINELIST lstPL ;
+                        POLYLINELIST lstPL ;
-                     if ( pZmap->GetDexelLines( k, j, i, lstPL)) {
+                        if ( pZmap->GetDexelLines( k, j, i, lstPL)) {
-                        for ( const auto& PL : lstPL) {
+                           for ( const auto& PL : lstPL) {
-                           Point3d ptS, ptE ;
+                              Point3d ptS, ptE ;
-                           bool Found = PL.GetFirstLine( ptS, ptE) ;
+                              bool Found = PL.GetFirstLine( ptS, ptE) ;
-                           while ( Found) {
+                              while ( Found) {
-                              vPnt.emplace_back( ptS) ;
+                                 vPnt.emplace_back( ptS) ;
-                              vPnt.emplace_back( ptE) ;
+                                 vPnt.emplace_back( ptE) ;
-                              Found = PL.GetNextLine( ptS, ptE) ;
+                                 Found = PL.GetNextLine( ptS, ptE) ;
+                              }
                            }
                         }
-                     }
+                        else {
-                     else {
+                           if ( j == 0)
-                        if ( j == 0)
+                              bOutBreak = true ;
-                           bOutBreak = true ;
+                           break ;
-                        break ;
+                        }
-                     }
+                     } 
-                  } 
+                     if ( bOutBreak)
-                  if ( bOutBreak)
+                        break ;    
-                     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) ;
+                  }
                }
-               if ( vPnt.size() > 0)
-                  pGraphics->AddLines( vPnt) ;
             }
          }
       }
@@ -662,7 +729,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
@@ -676,7 +743,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
@@ -774,6 +841,7 @@ 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] ;
@@ -781,15 +849,13 @@ Scene::DrawAlphaSurfVector( void)
       glPushMatrix() ;
       glLoadMatrixd( Matrix) ;
      // eseguo visualizzazione
-      bool bOk = AlphaSurf.pGraph->Draw( AlphaSurf.nStat, AlphaSurf.nMark, true,
+      if ( ! AlphaSurf.pGraph->Draw( AlphaSurf.nStat, AlphaSurf.nMark, true,
-                                         AlphaSurf.bSurf, AlphaSurf.nAlpha, AlphaSurf.bShowAux) ;
+                                     AlphaSurf.bSurf, AlphaSurf.nAlpha, AlphaSurf.bShowAux))
+         bOk = false ;
      // ripristino matrice
       glPopMatrix() ;
-     // in caso di errore, esco
-      if ( ! bOk)
-         return false ;
    }
-   return true ;
+   return bOk ;
 }
 
 //----------------------------------------------------------------------------

SceneGlobFrame.cpp

@@ -39,8 +39,13 @@ Scene::DrawGlobFrame( void)
    GLint Viewport[ 4] ;
    glGetIntegerv( GL_VIEWPORT, Viewport) ;
 
-  // imposto il riferimento
+  // imposto il riferimento sempre in vista ortografica 
+   glMatrixMode( GL_PROJECTION) ;
    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 ;

SceneImage.cpp

@@ -128,26 +128,28 @@ Scene::GetImage( int nShowMode, Color colBackTop, Color colBackBottom,
    pDib = FreeImage_ConvertTo24Bits( pTmpDib) ;
    FreeImage_Unload( pTmpDib) ;
 
-  // Eseguo scalatura della bitmap
+  // Se necessario, eseguo scalatura della bitmap
-   int nLeft ; int nTop ;
+   if ( nDestWidth != nN * nWidth  ||  nDestHeight != nM * nHeight) {
-   int nRight ; int nBottom ;
+      int nLeft ; int nTop ;
-   if ( dCoeffW / nN >= dCoeffH / nM) {
+      int nRight ; int nBottom ;
-      nLeft = 0 ;
+      if ( dCoeffW / nN >= dCoeffH / nM) {
-      nRight = nN * nWidth - 1 ;
+         nLeft = 0 ;
-      int nDeltaH = nM * nHeight - nN * int( nDestHeight / dCoeffW) ;
+         nRight = nN * nWidth - 1 ;
-      nTop = nDeltaH / 2 ;
+         int nDeltaH = nM * nHeight - nN * int( nDestHeight / dCoeffW) ;
-      nBottom = nM * nHeight - nTop - 1 ; 
+         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) ;
    }
-   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

@@ -361,7 +361,27 @@ 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)  ||  vInfo.size() == 0)
+      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())
          return false ;
      // recupero il primo punto
       ptSel = GetToGlob( vInfo[0].ptI, frEnt) ;

SceneSnap.cpp

@@ -32,6 +32,7 @@
 #include "/EgtDev/Include/EGkIntersCurves.h"
 #include "/EgtDev/Include/EGkIntersLinePlane.h"
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
+#include "/EgtDev/Include/EGkIntersLineVolZmap.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include <array>
 
@@ -47,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
@@ -57,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 ;
@@ -87,9 +88,17 @@ 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 ;
@@ -122,6 +131,14 @@ 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() ;
@@ -132,7 +149,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 ;
@@ -149,7 +166,9 @@ bool
 Scene::FindSelectedIntersectionPoint( const Point3d& ptWin, int nW, int nH)
 {
   // --- l'intersezione viene calcolata nel piano della griglia ---
-  // verifico siano state selezionate delle entità
+  // salvo eventuale ultima entità precedentemente selezionata
+   int nPrevSel = GetFirstSelectedObj() ;
+  // verifico siano state selezionate delle entità
    int nSel ;
    Select( ptWin, nW, nH, nSel) ;
    if ( nSel <= 0)
@@ -157,17 +176,19 @@ 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 i = GetFirstSelectedObj() ; i != GDB_ID_NULL && nCrvNum < 2 ; i = GetNextSelectedObj()) {
+   for ( int nObjId = GetFirstSelectedObj() ; nObjId != GDB_ID_NULL && nCrvNum < 2 ; nObjId = GetNextSelectedObj()) {
-     // se non è entità geometrica
+     // se non è entità geometrica
       const IGeoObj* pGObj ;
-      if ( ( pGObj = m_pGeomDB->GetGeoObj( i)) == nullptr)
+      if ( ( pGObj = m_pGeomDB->GetGeoObj( nObjId)) == nullptr)
          continue ;
       if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
          pCrv[nCrvNum] = GetCurve( pGObj) ;
-         if ( ! m_pGeomDB->GetGlobFrame( i, frEnt[nCrvNum]))
+         if ( ! m_pGeomDB->GetGlobFrame( nObjId, frEnt[nCrvNum]))
             return false ;
+         nIds[nCrvNum] = nObjId ;
          dWinZ += 0.5 * GetSelectedObjWinZ() ;
          ++ nCrvNum ;
       }
@@ -175,11 +196,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()) ;
@@ -194,17 +215,19 @@ 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()) ;
@@ -213,7 +236,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()) ;
@@ -228,11 +251,13 @@ 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( 0, ptNear, m_ptLastSnapPnt))
+   if ( ! intCC.GetIntersPointNearTo( ( nPrevSel == nIds[1] ? 1 : 0), ptNear, m_ptLastSnapPnt))
       return false ;
+   m_nLastSnapId = nIds[0] ;
    m_ptLastSnapPnt.ToGlob( frGrid) ;
+   m_bLastSnapDirOk = false ;
    return true ;
 }
 
@@ -240,20 +265,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 ;
@@ -469,7 +494,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)) {
@@ -496,7 +521,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 ;
@@ -504,7 +529,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) ;
@@ -544,10 +569,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 ;
 }
@@ -565,7 +590,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 ;
@@ -582,11 +607,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
@@ -616,7 +641,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 ;
@@ -642,12 +667,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) ;
@@ -659,7 +684,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 ;
@@ -669,12 +694,14 @@ 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 del rettangolo di mira
+  // se non trovato alcunchè, cerco le linee che partono dagli angoli e dai punti medi dei lati del rettangolo di mira
-   Vector3d vtWinD( -1, -1, 0) ;
+   VCT3DVECTOR vVtWind = { {0.51, 0.51, 0}, {0, 0.51, 0}, {-0.51, 0.51, 0}, {-0.51, 0, 0},
-   for ( int i = 0 ; i < 4 && vInfo.size() == 0 ; ++ i) {
+                           {-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 + vtWinD.x * m_nSelH * X_AX + vtWinD.y * m_nSelW * Y_AX ;
+      Point3d ptWinZ2 = ptWinZ + vVtWind[i].x * m_nSelH * X_AX + vVtWind[i].y * m_nSelW * Y_AX ;
-      vtWinD.Rotate( Z_AX, 0, 1) ;
      // ne ricavo punto di mira
       Point3d ptMir2 ;
       if ( ! UnProject( ptWinZ2, ptMir2))
@@ -685,7 +712,7 @@ Scene::FindSurfTMSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fram
       if ( ! IntersLineSurfTm( ptMir2, vtDir, dLenMir, *pStm, vInfo))
          return false ;
    }
-   if ( vInfo.size() == 0)
+   if ( vInfo.empty())
       return false ;
 
   // elaborazione a seconda del tipo di snap
@@ -698,12 +725,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) ;
@@ -726,12 +753,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) ;
@@ -752,12 +779,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) ;
@@ -778,7 +805,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 ;
@@ -804,7 +831,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 ;
 
@@ -816,7 +843,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 ;
@@ -833,11 +860,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) ;
@@ -850,12 +877,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) ;
@@ -906,7 +933,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 ;
 
@@ -918,7 +945,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 ;
@@ -943,13 +970,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) ;
@@ -961,7 +988,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 ;
@@ -969,9 +996,9 @@ Scene::FindVolZmapSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fra
 
   // cerco i triangoli intersecati dalla linea di mira
    ILZIVECTOR vInfo ;
-   if ( ! pVzm->GetLineIntersection( ptMir, vtDir, 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
@@ -984,7 +1011,7 @@ Scene::FindVolZmapSnapPoint( int nSnap, const Point3d& ptWin, int nId, const Fra
       ptMir2.ToLoc( frEnt) ;
       ptMir2 -= vtDir * 2 * dBlRad ; 
      // interseco con la superficie
-      if ( ! pVzm->GetLineIntersection( ptMir2, vtDir, vInfo))
+      if ( ! IntersLineVolZmap( ptMir2, vtDir, *pVzm, vInfo))
          return false ;
    }
    if ( vInfo.size() == 0)
@@ -1000,7 +1027,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 ;
@@ -1020,7 +1047,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 ;
@@ -1040,9 +1067,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) ;
@@ -1062,7 +1089,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 ;
@@ -1076,7 +1103,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 ;
 
@@ -1264,6 +1291,14 @@ 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() ;