EgtGraphics :

- piccoli aggiustamenti su ZoomOnPoint e ZoomWin per impostazione centro vista.
EgtGraphics 3.1e2 :
2026-05-14 16:07:02 +02:00 · 2026-05-12 18:08:07 +02:00 · 2026-05-05 19:18:07 +02:00 · 2026-04-22 18:31:56 +02:00 · 2026-03-05 11:18:26 +01:00 · 2026-02-09 12:26:56 +01:00
17 changed files with 797 additions and 293 deletions
@@ -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>
@@ -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 AddPolyLine( const PolyLine& PL, bool bAux = false) = 0 ;
+      virtual bool AddLines( const PNTVECTOR& vPnt, bool bAux = false, bool bSurfSha = false) = 0 ;
+      virtual bool AddPolyLine( const PolyLine& PL, bool bAux = false, bool bSurfSha = false) = 0 ;
      virtual bool 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 ;
@@ -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)
-      m_vOEGR[i]->SetScene( pScene) ;
+   for ( auto& pOEGR : m_vOEGR)
+      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) ;
 }

 //----------------------------------------------------------------------------
@@ -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 AddPolyLine( const PolyLine& PL, bool bAux = false) override ;
+      bool AddLines( const PNTVECTOR& vPnt, bool bAux = false, bool bSurfSha = false) override ;
+      bool AddPolyLine( const PolyLine& PL, bool bAux = false, bool bSurfSha = false) override ;
      bool StartTriangles( int nNum, bool bAux = false) override ;
      bool AddTriangle( const Triangle3d& Tria, const TriFlags3d& TFlags, const TriNormals3d& TNrms) override ;
      bool EndTriangles( void) override ;
@@ -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()) ;
   }
@@ -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,
-                    MAT_A = 4, MAT_D = 5, MAT_S = 6, MAT_SH = 7, MAT_B = 8, LINE_STIPPLE = 9} ;
+      enum GrType { NONE = 0, VERTS = 1, VERTS_A = 2, VERTS_S = 3, COLOR = 4,
+                    MAT_A = 5, MAT_D = 6, MAT_S = 7, MAT_SH = 8, MAT_B = 9, LINE_STIPPLE = 10} ;

   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 AddPolyLine( const PolyLine& PL, bool bAux = false) override ;
+      bool AddLines( const PNTVECTOR& vPnt, bool bAux = false, bool bSurfSha = false) override ;
+      bool AddPolyLine( const PolyLine& PL, bool bAux = false, bool bSurfSha = false) override ;
      bool 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) ; }
@@ -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()) ;
   }
@@ -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,
-                    COLOR = 7, MAT_A = 8, MAT_D = 9, MAT_S = 10, MAT_SH = 11, MAT_B = 12, LINE_STIPPLE = 13} ;
+      enum GrType { NONE = 0, START = 1, START_A = 2, START_S = 3, END = 4, VERT = 5, BND_FLAG = 6, NORMAL = 7,
+                    COLOR = 8, MAT_A = 9, MAT_D = 10, MAT_S = 11, MAT_SH = 12, MAT_B = 13, LINE_STIPPLE = 14} ;

   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 AddPolyLine( const PolyLine& PL, bool bAux = false) override ;
+      bool AddLines( const PNTVECTOR& vPnt, bool bAux = false, bool bSurfSha = false) override ;
+      bool AddPolyLine( const PolyLine& PL, bool bAux = false, bool bSurfSha = false) override ;
      bool 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)
@@ -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
-               { return m_colMark ; }
+      Color GetMark( int nMark) const
+               { 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 CalcDirUp( void) ;
+      bool VerifyCamera( bool bUseOrizzOffsCamera = false) ;
+      bool CalcDirUp( bool bUseOrizzOffsCamera = false) ;
      bool CalcCameraFrame( Frame3d& frView) ;
+      double CalcMinCameraDistance() ;
+      bool CalcDistCamera() ;
     // Geometry
      bool DrawGroup( int nId, int nPass, const MdStMkCol& siParent) ;
      bool DrawGroup( const IGdbIterator& iIter, int nPass, const MdStMkCol& siParent) ;
@@ -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) ;
@@ -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) ;
-   m_dZFar = - ( ptCenter.z - dExtent) ;
+   if ( m_bOrthographic) {
+      m_dZNear = - ( ptCenter.z + dExtent) ;
+      m_dZFar = - ( ptCenter.z - dExtent) ;   
+   }
+   else {
+      m_dZNear = PERSPECTIVE_NEAR_PLANE ;
+      m_dZFar = abs( ptCenter.z - dExtent) ;
+   }
   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)
@@ -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)
-      m_dDistCamera = STD_DIST_CAMERA ;
-   else
-      m_dDistCamera = max( m_dDistCamera, MIN_DIST_CAMERA) ;
-  // invalido Up e ExtView
+
+  // ricalcolo direzione Up
   m_bUpOk = false ;
+   if ( ! CalcDirUp( bUseOrizzOffsCamera))
+      return false ;
+
+  // verifico la distanza
+   m_bDistOk = false ;
+   CalcDistCamera() ;
+
+  // ricalcolo ExtView
   m_bExtViewOk = false ;
+   if ( ! CalcExtView())
+      return false ;
  // calcolo nuovi dati di Z clipping
-   CalcClippingPlanesFromExtView() ;
-   return true ;
+   return CalcClippingPlanesFromExtView() ;
 }

 //----------------------------------------------------------------------------
@@ -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 ;
-   Point3d ptViewOld( ptWinOld.x, ptWinOld.y, dZCenter) ;
+   double dOldZCenter ;
+   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 ;
-   return AdjustDimView( dHalfWidth, dHalfHeight) ;
+   m_ptCenter = ptCent ;  
+   if ( ! AdjustDimView( dHalfWidth, dHalfHeight))
+      return false ;
+
+   if ( ! m_bOrthographic) {
+     // cfr conti analoghi in ZoomAll
+      if ( m_nPerspZoomType == ZT_DOLLY) {
+         m_dDistCamera = m_dHalfHeight / tan( PERSPECTIVE_STD_FOV * 0.5 * DEGTORAD) + ( b3Obj.GetMax().z - b3Obj.GetMin().z) * 0.5  ;
+      }
+      else {
+        // verifico di non finire dentro l'oggetto
+         double dDiam ; b3Obj.GetDiameter( dDiam) ;
+         if ( m_dDistCamera < dDiam * 0.5)
+            m_dDistCamera = dDiam * 0.5 ;
+        // distanza della camera dalla faccia davanti del box
+         double dDist = m_dDistCamera - ( b3Obj.GetMax().z - b3Obj.GetMin().z) * 0.5 ;
+        // ricalcolo le dimensioni
+         double dAspect = m_dHalfWidth / m_dHalfHeight ;    
+         m_dHalfHeight = m_dHalfHeight / dDist * m_dDistCamera ;
+         m_dHalfWidth = m_dHalfHeight * dAspect ;
+      }      
+   }
+  // la distanza della camera è calcolata per non finire dentro gli oggetti
+   m_bDistOk = true ;
+
+   return true ;
 }

 //----------------------------------------------------------------------------
@@ -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 ;
-   m_dHalfHeight *= dCoeff ;
+   if ( ! m_bOrthographic  &&  m_nPerspZoomType == ZT_DOLLY) {
+     // per il dolly va modificata la distanza della camera 
+      m_dDistCamera *= dCoeff ;
+   }
+   else {
+     // controllo i limiti
+      dCoeff = clamp( dCoeff, MIN_COEFF, MAX_COEFF) ;
+      m_dHalfWidth *= dCoeff ;
+      m_dHalfHeight *= dCoeff ;  
+   }

   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 ;
 }

 //----------------------------------------------------------------------------
@@ -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)
-            nCount = 2 ;
+         if ( pSTM != nullptr) {
+            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) ;
-              // lo pulisco
-               pGraphics->Clear() ;
+               if ( pGraphics->SetCurrent( j))
+                  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
-               pGraphics->SetCurrent( ZMAP_COL * i) ;
-               if ( pZmap->GetBlockUpdatingCounter( i) <= pGraphics->GetCounter())
+              // Se blocco non esistente o già aggiornato, vado oltre
+               if ( ! pGraphics->SetCurrent( ZMAP_COL * i)  ||
+                    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
-                  pGraphics->SetCurrent( ZMAP_COL * i + j) ;
+                 // Imposto indice blocco corrente, se non esiste passo oltre
+                  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) ;
-           // lo pulisco
-            pGraphics->Clear() ;
-           // ciclo sui tre gruppi di spilloni
-            int nKmin = ( m_nShowZmap & ZSM_LINES) != 0 ? 0 : 3 ;
-            int nKmax = ( m_nShowZmap & ZSM_NORMALS) != 0 ? 6 : 3 ;
-            Color vCol[6] = {BLUE, RED, GREEN, BLUE, RED, GREEN} ;
-            for ( int k = nKmin ; k < nKmax ; ++ k) {
-               pGraphics->AddColor( vCol[k]) ;
-               pGraphics->AddMaterial( vCol[k], vCol[k], vCol[k], 10) ;
-               pGraphics->AddBackMaterial( vCol[k]) ;
-               PNTVECTOR vPnt ;
-               for ( int i = 0 ; ; ++ i) {
-                  bool bOutBreak = false ;
-                  for ( int j = 0 ; ; ++ j) {
-                     POLYLINELIST lstPL ;
-                     if ( pZmap->GetDexelLines( k, j, i, lstPL)) {
-                        for ( const auto& PL : lstPL) {
-                           Point3d ptS, ptE ;
-                           bool Found = PL.GetFirstLine( ptS, ptE) ;
-                           while ( Found) {
-                              vPnt.emplace_back( ptS) ;
-                              vPnt.emplace_back( ptE) ;
-                              Found = PL.GetNextLine( ptS, ptE) ;
+            if ( pGraphics->SetCurrent( ZMAP_COL * nCount)) {
+              // lo pulisco
+               pGraphics->Clear() ;
+              // ciclo sui tre gruppi di spilloni
+               int nKmin = ( m_nShowZmap & ZSM_LINES) != 0 ? 0 : 3 ;
+               int nKmax = ( m_nShowZmap & ZSM_NORMALS) != 0 ? 6 : 3 ;
+               Color vCol[6] = {BLUE, RED, GREEN, BLUE, RED, GREEN} ;
+               for ( int k = nKmin ; k < nKmax ; ++ k) {
+                  pGraphics->AddColor( vCol[k]) ;
+                  pGraphics->AddMaterial( vCol[k], vCol[k], vCol[k], 10) ;
+                  pGraphics->AddBackMaterial( vCol[k]) ;
+                  PNTVECTOR vPnt ;
+                  for ( int i = 0 ; ; ++ i) {
+                     bool bOutBreak = false ;
+                     for ( int j = 0 ; ; ++ j) {
+                        POLYLINELIST lstPL ;
+                        if ( pZmap->GetDexelLines( k, j, i, lstPL)) {
+                           for ( const auto& PL : lstPL) {
+                              Point3d ptS, ptE ;
+                              bool Found = PL.GetFirstLine( ptS, ptE) ;
+                              while ( Found) {
+                                 vPnt.emplace_back( ptS) ;
+                                 vPnt.emplace_back( ptE) ;
+                                 Found = PL.GetNextLine( ptS, ptE) ;
+                              }
                           }
                        }
-                     }
-                     else {
-                        if ( j == 0)
-                           bOutBreak = true ;
-                        break ;
-                     }
-                  } 
-                  if ( bOutBreak)
-                     break ;    
+                        else {
+                           if ( j == 0)
+                              bOutBreak = true ;
+                           break ;
+                        }
+                     } 
+                     if ( bOutBreak)
+                        break ;    
+                  }
+                  if ( vPnt.size() > 0)
+                     pGraphics->AddLines( vPnt) ;
+               }
+            }
+         }
+        // eventuali spigoli vivi
+         if ( pZmap->GetShowEdges()) {
+           // imposto indice blocco corrente
+            if ( pGraphics->SetCurrent( ZMAP_COL * nCount + ( bLinNrmShow ? 1 : 0))) {
+              // lo pulisco
+               pGraphics->Clear() ;
+              // inserisco le curve
+               ICURVEPOVECTOR vpCurve ;
+               if ( pZmap->GetEdges( vpCurve)  &&  ! vpCurve.empty()) {
+                  pGraphics->AddColor( DGRAY) ;
+                  pGraphics->AddMaterial( DGRAY, DGRAY, DGRAY, 10) ;
+                  pGraphics->AddBackMaterial( DGRAY) ;
+                  for ( const auto& pCrv : vpCurve) {
+                     PolyLine PL ;
+                     if ( pCrv->ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_GRAPH_DEG, ICurve::APL_SPECIAL, PL))
+                        pGraphics->AddPolyLine( PL, false, true) ;
+                  }
               }
-               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,
-                                         AlphaSurf.bSurf, AlphaSurf.nAlpha, AlphaSurf.bShowAux) ;
+      if ( ! AlphaSurf.pGraph->Draw( AlphaSurf.nStat, AlphaSurf.nMark, true,
+                                     AlphaSurf.bSurf, AlphaSurf.nAlpha, AlphaSurf.bShowAux))
+         bOk = false ;
     // ripristino matrice
      glPopMatrix() ;
-     // in caso di errore, esco
-      if ( ! bOk)
-         return false ;
   }
-   return true ;
+   return bOk ;
 }

 //----------------------------------------------------------------------------
@@ -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 ;
@@ -128,26 +128,28 @@ Scene::GetImage( int nShowMode, Color colBackTop, Color colBackBottom,
   pDib = FreeImage_ConvertTo24Bits( pTmpDib) ;
   FreeImage_Unload( pTmpDib) ;

-  // Eseguo scalatura della bitmap
-   int nLeft ; int nTop ;
-   int nRight ; int nBottom ;
-   if ( dCoeffW / nN >= dCoeffH / nM) {
-      nLeft = 0 ;
-      nRight = nN * nWidth - 1 ;
-      int nDeltaH = nM * nHeight - nN * int( nDestHeight / dCoeffW) ;
-      nTop = nDeltaH / 2 ;
-      nBottom = nM * nHeight - nTop - 1 ; 
+  // Se necessario, eseguo scalatura della bitmap
+   if ( nDestWidth != nN * nWidth  ||  nDestHeight != nM * nHeight) {
+      int nLeft ; int nTop ;
+      int nRight ; int nBottom ;
+      if ( dCoeffW / nN >= dCoeffH / nM) {
+         nLeft = 0 ;
+         nRight = nN * nWidth - 1 ;
+         int nDeltaH = nM * nHeight - nN * int( nDestHeight / dCoeffW) ;
+         nTop = nDeltaH / 2 ;
+         nBottom = nM * nHeight - nTop - 1 ; 
+      }
+      else {
+         nTop = 0 ;
+         nBottom = nM * nHeight - 1 ; 
+         int nDeltaW = nN * nWidth - nM * int( nDestWidth / dCoeffH) ;
+         nLeft = nDeltaW / 2 ;
+         nRight = nN * nWidth - nLeft - 1 ;
+      }
+      FIBITMAP* pTmp2Dib = pDib ;
+      pDib = FreeImage_RescaleRect( pTmp2Dib, nDestWidth, nDestHeight, nLeft, nTop, nRight, nBottom, FILTER_CATMULLROM) ;
+      FreeImage_Unload( pTmp2Dib) ;
   }
-   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 ;
@@ -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) ;
@@ -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()) {
-     // se non è entità geometrica
+   for ( int nObjId = GetFirstSelectedObj() ; nObjId != GDB_ID_NULL && nCrvNum < 2 ; nObjId = GetNextSelectedObj()) {
+     // 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
-   Vector3d vtWinD( -1, -1, 0) ;
-   for ( int i = 0 ; i < 4 && vInfo.size() == 0 ; ++ i) {
+  // 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 + vtWinD.x * m_nSelH * X_AX + vtWinD.y * m_nSelW * Y_AX ;
-      vtWinD.Rotate( Z_AX, 0, 1) ;
+      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))
@@ -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() ;
Author	SHA1	Message	Date
Dario Sassi	ac78227f0b	EgtGraphics : - piccoli aggiustamenti su ZoomOnPoint e ZoomWin per impostazione centro vista.	2026-05-14 16:07:02 +02:00
Dario Sassi	8eff351f17	EgtGraphics 3.1e2 : - piccole migliorie per rendere più stabile rotazione camera.	2026-05-12 18:08:07 +02:00
Dario Sassi	0405079553	EgtGraphics 3.1e1 : - piccola miglioria per controllare centro di rotazione camera dopo zoom.	2026-05-05 19:18:07 +02:00
Dario Sassi	50b446c371	EgtGraphics 3.1d2 : - ricompilazione con cambio versione.	2026-04-22 18:31:56 +02:00
Dario Sassi	a68b502938	EgtGraphics 3.1c1 : - ricompilazione con cambio versione.	2026-03-05 11:18:26 +01:00
Riccardo Elitropi	199ef1e26d	EgtGraphics : - utilizzo di GetPixelZ anche per Pan della camera.	2026-02-09 12:26:56 +01:00
Riccardo Elitropi	d2a457b1bd	EgtGraphics : - esteso ZoomOnPoint per superfici non opache.	2026-02-06 13:03:20 +01:00
Riccardo Elitropi	36e6b1d5c1	EgtGraphics : - migliorato lo ZoomOnPoint.	2026-02-05 11:36:33 +01:00
Dario Sassi	bcb3c189a1	EgtGraphics : - migliorato calcolo centro di vista in Zwin utilizzando GetPixelZ.	2026-01-22 11:00:44 +01:00
Dario Sassi	bbe4e99fe8	EgtGraphics 3.1a1 : - ricompilazione con cambio major version.	2026-01-02 18:28:07 +01:00
Dario Sassi	1a4cabe097	EgtGraphics 2.7l1 : - ricompilazione con cambio versione.	2025-12-20 17:54:47 +01:00
Dario Sassi	dbd0c9a739	EgtGraphics : - migliorie nella funzione GetImage di Scene.	2025-11-03 15:14:57 +01:00
Dario Sassi	1cf8e7e965	EgtGraphics 2.7k1 : - ricompilazione per passaggio a C++ 20	2025-11-01 17:32:43 +01:00
Dario Sassi	337b896761	EgtGraphics 2.7J1 : - ricompilazione con cambio versione.	2025-10-09 14:44:46 +02:00
Dario Sassi	2e688ef9aa	EgtGraphics : - ricompilazione con cambio codifica file a UTF-8.	2025-09-18 19:18:57 +02:00
Dario Sassi	41731eaa38	EgtGraphics 2.7i1 : - ricompilazione con cambio versione.	2025-09-05 08:19:01 +02:00
Dario Sassi	784d7d0ae4	EgtGraphics 2.7h1 : - ricompilazione con cambio versione.	2025-08-22 11:46:02 +02:00
Dario Sassi	3a4c73f77f	EgtGraphics 2.7g2 : - corretta gestione SetCurrent degli ObjGraphics che non sono Multi (prima errori con visualizzazione solo spilloni di Zmap).	2025-07-11 11:42:45 +02:00
Dario Sassi	117511a04f	EgtGraphics 2.7g1 : - ricompilazione con cambio versione.	2025-07-02 19:50:26 +02:00
Dario Sassi	a83fdbda5e	EgtGraphics 2.7f2 : - ricompilazione con cambio versione.	2025-06-26 09:47:30 +02:00
Dario Sassi	5349437d28	EgtGraphics 2.7d2 : - ricompilazione con cambio versione.	2025-04-21 11:17:28 +02:00
Dario Sassi	b30fa0b55e	EgtGraphics 2.7c1 : - ricompilazione con cambio versione.	2025-03-11 17:00:41 +01:00
SaraP	95bceba089	EgtGraphics 2.7b3 : - in vista prospettica con zoom standard introdotto valore massimo per fov.	2025-02-19 16:16:59 +01:00
SaraP	d9c9622972	EgtGraphics 2.7a2 : - aggiunta vista prospettica con due modalità di zoom ( standard e dolly).	2025-01-23 10:07:48 +01:00
Dario Sassi	0a28896ab6	EgtGraphics 2.7a1 : - cambio annuale di versione - compilazione 32bit senza più limiti per Windows XP.	2025-01-09 17:58:52 +01:00
Dario Sassi	a357df9cd0	EgtGraphics : - piccola modifica in Snap Punto Intersezione (si preferisce il punto sull'eventuale entità selezionata).	2025-01-04 13:02:31 +01:00
Dario Sassi	2fb3ffb614	EgtGraphics 2.6l1 : - ricompilazione con cambio versione.	2024-12-02 09:51:21 +01:00
Dario Sassi	d7385ec15d	EgtGraphics 2.6i1 : - ricompilazione con cambio versione.	2024-09-23 13:05:22 +02:00
Dario Sassi	076c74488f	EgtGraphics : - migliorata gestione oggetti senza visualizzazione - migliorata gestione errori di visualizzazione.	2024-08-23 19:00:57 +02:00
Dario Sassi	c77d7cffe8	EgtGraphics 2.6h2 : - modifiche per permettere Mark di tipo 2.	2024-08-22 09:10:29 +02:00
Dario Sassi	08bbafc909	EgtGraphics 2.6h1 : - ricompilazione con cambio versione.	2024-08-20 12:53:32 +02:00
Dario Sassi	55021cf19c	EgtGraphics 2.6g5 : - ricompilazione con cambio versione.	2024-07-18 20:18:54 +02:00
Dario Sassi	adc7df9de7	EgtGraphics 2.6g1 : - ricompilazione con cambio versione.	2024-07-09 11:14:59 +02:00
Dario Sassi	1dcb86abe8	EgtGraphics 2.6f4 : - ricompilazione con cambio versione.	2024-06-26 08:43:06 +02:00
Dario Sassi	bfacbc23c6	EgtGraphics 2.6f3 : - ricompilazione con cambio versione.	2024-06-13 07:59:20 +02:00
Dario Sassi	4bfd4e4f5d	EgtGraphics 2.6f1 : - ricompilazione con cambio versione.	2024-06-07 19:00:02 +02:00
Dario Sassi	69ab09f5b3	EgtGraphics : - eliminata istruzione inutile.	2024-05-02 09:29:43 +02:00
Dario Sassi	7254d3dece	EgtGraphics 2.6e1 : - ricompilazione per modifiche a gestione chiave di rete.	2024-04-30 16:54:06 +02:00
Dario Sassi	f5bf52467a	EgtGraphics 2.6d4 : - ricompilazione con cambio versione.	2024-04-26 11:30:02 +02:00
Dario Sassi	588795960d	EgtGraphics 2.6d3 : - ricompilazione con cambio versione.	2024-04-13 17:09:54 +02:00
Dario Sassi	e2d54eee41	EgtGraphics 2.6d1 : - ricompilazione con cambio versione.	2024-04-05 16:52:36 +02:00
Dario Sassi	b11b39acbf	EgtGraphics : - modifiche estetiche.	2024-03-14 20:01:26 +01:00
Dario Sassi	fbe6c7232e	EgtGraphics : - migliorate GetPointFromSelect con superfici trimesh e FindSurfTMSnapPoint per ricerca triangolo/punto dell'oggetto inquadrato nel mirino.	2024-03-13 13:35:45 +01:00
Dario Sassi	7930a229f9	EgtGraphics 2.6c2 : - aggiunta possibilità di visualizzare curve di entità solo in shading - utilizzata questa possibilità per spigoli vivi di TriMesh e Zmap.	2024-03-10 10:22:18 +01:00
Dario Sassi	49dac32893	EgtGraphics : - adattamenti a modifche GeomKernel.	2024-02-26 15:15:58 +01:00
Dario Sassi	e8b10ef4e8	EgtGraphics 2.6b4 : - aggiunta possibilità di un offset angolare in viste standard.	2024-02-19 14:50:00 +01:00
Dario Sassi	1c37299baf	EgtGraphics 2.6b3 : - ricompilazione con cambio versione.	2024-02-16 08:44:23 +01:00
Dario Sassi	d61656fdd4	EgtGraphics 2.6a1 : - ricompilazione con cambio versione.	2024-01-16 15:12:52 +01:00