Merge commit '199ef1e26d47302b1e7e93f831fc6326164c64cc' into Cube

- utilizzo di GetPixelZ anche per Pan della camera.

EgtGraphics.vcxproj

@@ -263,6 +263,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="SceneCamera.cpp" />
     <ClCompile Include="SceneGeom.cpp" />
     <ClCompile Include="SceneDirect.cpp" />
+    <ClCompile Include="SceneGlobCube.cpp" />
     <ClCompile Include="SceneGlobFrame.cpp" />
     <ClCompile Include="SceneGrid.cpp" />
     <ClCompile Include="SceneImage.cpp" />

EgtGraphics.vcxproj.filters

@@ -140,6 +140,9 @@
     <ClCompile Include="ImageMgr.cpp">
       <Filter>File di origine</Filter>
     </ClCompile>
+    <ClCompile Include="SceneGlobCube.cpp">
+      <Filter>File di origine</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtGraphics.rc">

ObjMultiGraphics.cpp

@@ -13,6 +13,7 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
+#include "/EgtDev/Include/EGkColor.h"
 #include "ObjMultiGraphics.h"
 #include "ObjNewGraphics.h"
 #include "ObjOldGraphics.h"

ObjNewGraphics.h

@@ -83,6 +83,8 @@ class ObjNewGraphics : public ObjEGrGraphics
       bool AddTriangle( const Triangle3d& Tria, const TriFlags3d& TFlags, const TriNormals3d& TNrms) override ;
       bool EndTriangles( void) override ;
       bool Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlpha, bool bShowAux) override ;
+
+
       bool GetLocalBBox( BBox3d& b3Loc) const override
               { b3Loc = m_b3Loc ; return ! m_b3Loc.IsEmpty() ; }
 

ObjOldGraphics.h

@@ -88,6 +88,7 @@ class ObjOldGraphics : public ObjEGrGraphics
       bool AddTriangle( const Triangle3d& Tria, const TriFlags3d& TFlags, const TriNormals3d& TNrms) override ;
       bool EndTriangles( void) override ;
       bool Draw( int nStat, int nMark, bool bSurfSha, bool bSurf, int nAlpha, bool bShowAux) override ;
+
       bool GetLocalBBox( BBox3d& b3Loc) const override
               { b3Loc = m_b3Loc ; return ! m_b3Loc.IsEmpty() ; }
 

Scene.h

@@ -1,12 +1,13 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2014-2024
 //----------------------------------------------------------------------------
-// File : Scene.h           Data : 09.01.24           Versione : 2.5l7
+// File : Scene.h           Data : 16.02.24           Versione : 2.6b4
 // Contenuto : Dichiarazione della classe gestione scena.
 //
 //
 //
 // Modifiche : 29.01.14 DS Creazione modulo.
+//             16.02.24 DS Aggiunte Set/Get CameraDirOrizzOffset.
 //
 //
 //----------------------------------------------------------------------------
@@ -89,11 +90,15 @@ class Scene : public IEGrScene
       void Destroy( void) override ;
      // Camera
       bool SetCenter( const Point3d& ptCenter) override ;
+      bool SetCameraDirOrizzOffset( int nRightStepOffset = 0) override
+                { m_nOrizzOffsCamera = nRightStepOffset ; return true ; }
       bool SetCamera( double dAngVertDeg, double dAngOrizzDeg, double dDist) override ;
       bool SetCamera( int nDir, double dDist = 0) override ;
       const Point3d& GetCenter( void) const override
                 { return m_ptCenter ; }
       Point3d GetProjectedCenter( void) const override ;
+      int  GetCameraDirOrizzOffset( void) const override
+                { return m_nOrizzOffsCamera ; }
       void GetCamera( double* pdAngVertDeg, double* pdAngOrizzDeg, double* pdDist = nullptr) const override ;
       int  GetCameraDir( void) const override ;
       const Vector3d& GetCameraUp( void) const override
@@ -106,6 +111,10 @@ class Scene : public IEGrScene
       bool ZoomChange( double dCoeff) override ;
       bool ZoomOnPoint( const Point3d& ptWin, double dCoeff) override ;
       bool ZoomWin( const Point3d& ptWin1, const Point3d& ptWin2) override ;
+      bool RotateCameraWithCube() ;
+      bool RotateCameraWithBlockedAngle( Vector3d vDirS, Vector3d vDirE, double dDist, int nAdaptSpeed,
+                                         int nBlockedAngle, double dTheta_orig, double dPhi_orig,
+                                         double& dTheta_new, double& dPhi_new) ;
       void GetOrthoCamParam( double* pdWidth, double* pdHeight, double* pdNear, double* pdFar) const override ;
      // ShowMode
       bool SetShowMode( int nShowMode) override
@@ -133,6 +142,12 @@ class Scene : public IEGrScene
                 { m_nShowText = nMode ; }
       int  GetShowText( void) const override
                 { return m_nShowText ; }
+     // Colors
+      void SetSceneColors( Color cColX, Color cColY, Color cColZ, Color cColXm, Color cColYm, Color cColZm,
+                           Color cColEdge, Color cColCorner) override
+                { m_cColX = cColX ; m_cColY = cColY ; m_cColZ = cColZ ;
+                  m_cColXm = cColXm ; m_cColYm = cColYm ; m_cColZm = cColZm ;
+                  m_cColEdge = cColEdge ; m_cColCorner = cColCorner ; }
      // Geometry
       bool SetExtension( const BBox3d& b3Ext) override ;
       bool UpdateExtension( void) override ;
@@ -147,8 +162,17 @@ class Scene : public IEGrScene
       bool SetGridColor( Color colMinLine, Color colMajLine) override ;
       void GetGridParam( double& dSnapStep, int& nExtStep) const override ;
       bool GetShowGrid() override ;
-     // Glob Frame
+     // Axis Frame
       bool SetGlobFrameShow( bool bShow) override ;
+      bool SetGlobFrameParameters( int nPosFlag, double dDistX, double dDistY,
+                                   double dLenLine, double dWidthLine) override ;
+     // Glob Cube
+      bool DrawCube( bool bSurf) override ;
+      bool CreateFlatPart( ISurfTriMesh* pSrf) override ;
+      bool CreateEdgePart( ISurfTriMesh* pSrf) override ;
+      bool CreateCornerPart( ISurfTriMesh* pSrf) override ;
+      bool GetAngleByCubeFace( int nFaceId, double& dTheta, double& dPhi) ;
+      bool SetGlobCubeParameters( int nPosFlag, double dDistX, double dDistY, double dLenEdge) override ;
      // Direct
       bool SetGeoLineAttribs( Color GLcol) override ;
       bool SetGeoLine( const Point3d& ptP1, const Point3d& ptP2) override ;
@@ -239,8 +263,8 @@ class Scene : public IEGrScene
       bool Background( void) ;
       bool Prepare( void) ;
      // Camera
-      bool VerifyCamera( void) ;
-      bool CalcDirUp( void) ;
+      bool VerifyCamera( bool bUseOrizzOffsCamera = false) ;
+      bool CalcDirUp( bool bUseOrizzOffsCamera = false) ;
       bool CalcCameraFrame( Frame3d& frView) ;
      // Geometry
       bool DrawGroup( int nId, int nPass, const MdStMkCol& siParent) ;
@@ -255,8 +279,11 @@ class Scene : public IEGrScene
                  static Frame3d frGrid ;
                  return frGrid ; }
       bool DrawGrid( void) ;
+      bool DrawRectangularGrid( void) ;
      // Glob Frame
       bool DrawGlobFrame( void) ;
+     // Glob Cube
+      bool DrawGlobCube( bool bSurf) ;
      // Direct
       bool DrawDirect( void) ;
       bool DrawGeoLine( void) ;
@@ -288,10 +315,20 @@ 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)
+     // Colors
+      Color    m_cColX ;                  // colore asse x
+      Color    m_cColXm ;                 // colore asse -x
+      Color    m_cColY ;                  // colore asse y
+      Color    m_cColYm ;                 // colore asse -y
+      Color    m_cColZ ;                  // colore asse z
+      Color    m_cColZm ;                 // colore asse -z
+      Color    m_cColEdge ;               // colore per Edge ( per cubetto)
+      Color    m_cColCorner ;             // colore per Corner ( per cubetto)
      // Camera
-      Point3d  m_ptCenter ;               // centro verso cui è rivolta la camera
+      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
       Vector3d m_vtUp ;                   // versore direzione Su della camera
       bool     m_bUpOk ;                  // flag per stato aggiornamento di Up
@@ -306,7 +343,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,9 +368,9 @@ 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
@@ -363,9 +400,23 @@ class Scene : public IEGrScene
       double  m_dGridMaxY ;               // massima estensione in Y della griglia
       Color   m_colMinLine ;              // colore delle linee minori
       Color   m_colMajLine ;              // colore delle linee maggiori
-     // Glob Frame
+     // Axis Frame
       bool    m_bShowGlobFrame ;          // flag di visualizzazione del riferimento globale
-     // Direct
+      int     m_nAxisFrame_Flag ;         // flag per quadrante di visualizzazione del frame
+      double  m_dFrame_DistX ;            // X del Centro del frame sullo schermo
+      double  m_dFrame_DistY ;            // Y del Centro del frame sullo schetrmo
+      double  m_dFrameLineL ;             // lunghezza delle linee del frame
+      double  m_dFrameLineW ;             // spessore delle linee del frame
+     // Glob Cube
+      ISURFTMPOVECTOR m_vStm_Cube ;       // vettore contenente le superificie del cubo ( 26 in totale)
+      bool    m_bShowGlobCube ;           // flag di visualizzazione del cubetto
+      Point3d m_ptOrigCube ;              // centro del cubo in cordinate globali
+      int     m_nCube_Flag ;              // flag per posizione negli angoli del cubetto
+      double  m_dCubeEdge ;               // lunghezza del lato del cubo
+      double  m_dCubeX ;                  // X del Centro del cubo sullo schermo
+      double  m_dCubeY ;                  // Y del Centro del cubo sullo schermo
+      int     m_nStartFaceId ;            // nuovo id iniziale utilizzato per assegnare un id univoco e non in uso alle facce del cubo
+      // Direct
       Color   m_colorGL ;                 // colore per GeoLine
       bool    m_bGeoLine ;                // flag esistenza linea diretta in finestra
       Point3d m_ptGeoLineP1 ;             // primo estremo della linea diretta

SceneBasic.cpp

@@ -51,8 +51,18 @@ Scene::Scene( void)
    m_hRC = nullptr ;
    m_nOglVer = 0 ;
    m_bNewWay = false ;
+  // Colors
+   m_cColX = Color( 255, 0, 0, 1) ;
+   m_cColXm = Color( 167, 27, 11, 1) ;
+   m_cColY = Color( 0, 255, 0, 1) ;
+   m_cColYm = Color( 36, 163, 25, 1) ;
+   m_cColZ = Color( 0, 0, 255, 1) ;
+   m_cColZm = Color( 36, 17, 120, 1) ;
+   m_cColEdge = Color( 200, 200, 200, 1) ;
+   m_cColCorner = Color( 200, 200, 200, 1) ;
   // Camera e viewport
    m_ptCenter = ORIG ;
+   m_nOrizzOffsCamera = 0 ;
    SetCamera( 0, 0, 0) ;
    m_nViewportW = 0 ;
    m_nViewportH = 0 ;
@@ -61,7 +71,7 @@ Scene::Scene( void)
   // 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 ;
@@ -136,7 +146,7 @@ Scene::Init( IGeomDB* pGeomDB)
 bool
 Scene::CreateContext( HDC hDC, int nDriver, bool b2Buff, int nColorBits, int nDepthBits)
 {
-  // verifico validità Device Context
+  // verifico validit� Device Context
    if ( hDC == nullptr)
       return false ;
    m_hDC = hDC ;
@@ -213,7 +223,7 @@ Scene::CreateContext( HDC hDC, int nDriver, bool b2Buff, int nColorBits, int nDe
       LOG_INFO( GetEGrLogger(), "WGL_ARB_create_context missing !")
    }
 
-  // verifico validità Rendering Context
+  // verifico validit� Rendering Context
    if ( m_hRC == nullptr)
       return false ;
 
@@ -224,7 +234,7 @@ Scene::CreateContext( HDC hDC, int nDriver, bool b2Buff, int nColorBits, int nDe
    if ( GlewInitResult != GLEW_OK)
       LOG_INFO( GetEGrLogger(), "GLEW is not initialized !")
 
-  // verifico se posso lavorare in modalità nuova
+  // verifico se posso lavorare in modalit� nuova
    m_bNewWay = ( nDriver == OD_NEW  &&  glewIsSupported( "GL_VERSION_3_0") == 1) ;
    if ( ! m_bNewWay)
       LOG_INFO( GetEGrLogger(), "OpenGL old way rendering !")
@@ -286,11 +296,11 @@ Scene::ChooseGenPixelFormat( int nPfd, bool b2Buff, int nColorBits, int nDepthBi
 bool
 Scene::MakeCurrent( void) const
 {
-  // se RC della scena non è definito, errore
+  // se RC della scena non � definito, errore
    if ( m_hRC == nullptr)
       return false ;
 
-  // se RC della scena è quello corrente, ok
+  // se RC della scena � quello corrente, ok
    HGLRC hRC = wglGetCurrentContext() ;
    if ( m_hRC == hRC)
      return true ;
@@ -417,7 +427,7 @@ Scene::SetExtension( const BBox3d& b3Ext)
 bool
 Scene::CalcExtView( void)
 {
-  // verifico se il calcolo è necessario
+  // verifico se il calcolo � necessario
    if ( m_bExtViewOk  &&  m_bUpOk)
       return true ;
   // calcolo direzione camera Up
@@ -515,6 +525,7 @@ Scene::CalcClippingPlanesFromExtView( void)
    double dExtent = max( ( EXP_COEFF * vtExtent.z), MIN_ZCLIP_EXT) ;
    m_dZNear = - ( ptCenter.z + dExtent) ;
    m_dZFar = - ( ptCenter.z - dExtent) ;
+
    return true ;
 }
 
@@ -729,12 +740,12 @@ Scene::MyDraw( bool bSwapBF)
    if ( m_pGeomDB != nullptr)
       m_pGeomDB->GetDefaultMaterial( m_colDef) ;
 
-  // impostazioni dipendenti dalla modalità di visualizzazione
+  // impostazioni dipendenti dalla modalit� di visualizzazione
    switch ( m_nShowMode) {
    case SM_WIREFRAME :
      // disabilito illuminazione
       glDisable( GL_LIGHTING) ;
-     // disegno griglia senza illuminazione (già impostato)
+     // disegno griglia senza illuminazione (gi� impostato)
       DrawGrid() ;
      // imposto dati standard per punti e linee
       glPointSize( (float) GetPointSize()) ;
@@ -747,7 +758,7 @@ Scene::MyDraw( bool bSwapBF)
    case SM_HIDDENLINE :
      // disabilito illuminazione
       glDisable( GL_LIGHTING) ;
-     // disegno griglia senza illuminazione (già impostato)
+     // disegno griglia senza illuminazione (gi� impostato)
       DrawGrid() ;
      // imposto dati standard per punti e linee
       glPointSize( (float) GetPointSize()) ;
@@ -833,6 +844,10 @@ Scene::MyDraw( bool bSwapBF)
    glDisable( GL_DEPTH_TEST) ;
    glDisable( GL_LIGHTING) ;
 
+  // da togliere e richiamare esternamente...
+   SetGlobCubeParameters( 1, 60, 60, 75) ;
+   SetGlobFrameParameters( 3, 40, 40, 25, 2) ;
+
   // disegno riferimento globale
    DrawGlobFrame() ;
 
@@ -840,6 +855,24 @@ Scene::MyDraw( bool bSwapBF)
    glPolygonMode( GL_FRONT_AND_BACK, GL_FILL) ;
    DrawDirect() ;
 
+
+  // disegno il cubetto
+   glDisable( GL_LIGHTING) ;
+   glEnable( GL_DEPTH_TEST) ;
+   glEnable( GL_POLYGON_OFFSET_FILL) ;
+   glFrontFace( GL_CCW) ;
+   glCullFace( GL_BACK) ;
+   glEnable( GL_CULL_FACE) ;
+   glPolygonMode( GL_FRONT_AND_BACK, GL_FILL) ;
+   glPolygonOffset( 0.5, 0.5) ;
+   DrawGlobCube( true) ;  // superifici
+   glPolygonMode( GL_FRONT_AND_BACK, GL_LINE) ;
+   glLineWidth( 1) ;
+   DrawGlobCube( false) ;  // linee
+   glLineWidth( GetLineWidth()) ;
+   glDisable( GL_CULL_FACE) ;
+   glDisable( GL_DEPTH_TEST) ;
+
   // aggiorno
    glFlush() ;
 

SceneCamera.cpp

@@ -24,6 +24,11 @@ using namespace std ;
 static const double MIN_DIST_CAMERA = 10 ;
 static const double STD_DIST_CAMERA = 1000 ;
 
+static const double MIN_HALF_WIDTH_STD = 0.7 ;
+static const double MAX_HALF_WIDTH_STD = 180000 ;
+static const double MIN_HALF_HEIGHT_STD = 0.5 ;
+static const double MAX_HALF_HEIGHT_STD = 140000 ;
+
 //----------------------------------------------------------------------------
 bool
 Scene::SetCenter( const Point3d& ptCenter)
@@ -83,16 +88,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,14 +106,15 @@ Scene::SetCamera( int nDir, double dDist)
       return false ;
       break ;
    }
+   if ( nDir != CT_CPLANE)
+      m_vtDirCamera.Rotate( Z_AX, m_nOrizzOffsCamera * ANG_RIGHT) ;
    m_dDistCamera = dDist ;
-
-   return VerifyCamera() ;
+   return VerifyCamera( nDir != CT_CPLANE) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Scene::VerifyCamera( void)
+Scene::VerifyCamera( bool bUseOrizzOffsCamera)
 {
   // verifico il versore
    if ( ! m_vtDirCamera.Normalize())
@@ -118,12 +124,16 @@ Scene::VerifyCamera( void)
       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 ;
+  // ricalcolo ExtView
    m_bExtViewOk = false ;
+   if ( ! CalcExtView())
+      return false ;
   // calcolo nuovi dati di Z clipping
-   CalcClippingPlanesFromExtView() ;
-   return true ;
+   return CalcClippingPlanesFromExtView() ;
 }
 
 //----------------------------------------------------------------------------
@@ -157,25 +167,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,7 +206,7 @@ Scene::GetProjectedCenter( void) const
 
 //----------------------------------------------------------------------------
 bool
-Scene::CalcDirUp( void)
+Scene::CalcDirUp( bool bUseOrizzOffsCamera)
 {
   // verifico se il calcolo è necessario
    if ( m_bUpOk)
@@ -202,8 +214,11 @@ Scene::CalcDirUp( void)
   // direzione perpendicolare giacente nel piano XY
   // ( 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() ;
@@ -358,7 +373,6 @@ Scene::ZoomChange( double dCoeff)
       dCoeff = MIN_COEFF ;
    else if ( dCoeff > MAX_COEFF)
       dCoeff = MAX_COEFF ;
-  // cambio le dimensioni di zoom
    m_dHalfWidth *= dCoeff ;
    m_dHalfHeight *= dCoeff ;
 
@@ -369,6 +383,22 @@ Scene::ZoomChange( double dCoeff)
 bool
 Scene::ZoomOnPoint( const Point3d& ptWin, double dCoeff)
 {
+  // recupero la matrice viewport
+   GLint Viewport[4] ;
+   glGetIntegerv( GL_VIEWPORT, Viewport) ;
+
+  // range valori delle Viewport
+   double dLimInfHW = MIN_HALF_WIDTH_STD * Viewport[2] / 1152.0 ;
+   double dLimInfHH = MIN_HALF_HEIGHT_STD * Viewport[3] / 928.0 ;
+   double dLimSupHW = MAX_HALF_WIDTH_STD * Viewport[2] / 1152.0 ;
+   double dLimSupHH = MAX_HALF_WIDTH_STD * Viewport[3] / 928.0 ;
+
+  // controllo se i parametri di Zoom minimo e massimo sono rispettati, altrimenti esco
+   if ( m_dHalfWidth * dCoeff > dLimSupHW  ||  m_dHalfHeight * dCoeff > dLimSupHH)
+      return true ;
+   if ( m_dHalfWidth * dCoeff < dLimInfHW  ||  m_dHalfHeight * dCoeff < dLimInfHH)
+      return true ;
+
   // porto il punto in coordinate mondo
    Point3d ptView( ptWin.x, ptWin.y, GetProjectedCenter().z) ;
    Point3d ptWorld ;

SceneGlobCube.cpp

@@ -0,0 +1,770 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2022
+//----------------------------------------------------------------------------
+// File : SceneGlobCube.cpp       Data : 10.10.22         Versione : 1
+// Contenuto : Implementazione gestione e disegno Cubetto per viste.
+//
+//
+//
+// Modifiche : 11.10.22 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "Scene.h"
+#include "EGrUtils.h"
+#include "ObjOldGraphics.h"
+#include "ObjNewGraphics.h"
+#include "ObjMultiGraphics.h"
+#include "/EgtDev/Include/EGkSurfTriMesh.h"
+#include "/EgtDev/Include/EGkSfrCreate.h"
+#include "/EgtDev/Include/EGkGeomDB.h"
+#include "/EgtDev/Include/EGkObjGraphics.h"
+
+
+using namespace std ;
+
+// posizione X e Y dello schermo
+const double MIN_EDGE_SIZE = 20 ;
+const double MAX_EDGE_SIZE = 200.0 ;
+
+// colore render dei bordi delle superifici del cubo
+const Color CUBE_LINES( 0, 0, 0, 1) ;
+
+// angolo di tolleranza per rotazioni con vettori quasi paralleli
+const double ANG_ROT_TOLL = 5 ;
+
+//----------------------------------------------------------------------------
+bool
+Scene::CreateFlatPart( ISurfTriMesh* pSrf)
+{
+
+  // vertici
+   pSrf->AddVertex( Point3d( 0.33 * m_dCubeEdge, 0.33 * m_dCubeEdge, 0)),
+   pSrf->AddVertex( Point3d( - 0.33 * m_dCubeEdge, 0.33 * m_dCubeEdge, 0)) ;
+   pSrf->AddVertex( Point3d( - 0.33 * m_dCubeEdge, - 0.33 * m_dCubeEdge, 0)) ;
+   pSrf->AddVertex( Point3d( 0.33 * m_dCubeEdge, - 0.33 * m_dCubeEdge, 0)) ;
+
+  // triangoli
+   int nNewInd_0[3] = { 0, 1, 2} ;
+   pSrf->AddTriangle( nNewInd_0) ;
+   int nNewInd_1[3] = { 0, 2, 3} ;
+   pSrf->AddTriangle( nNewInd_1) ;
+
+  // verifico
+   pSrf->DoCompacting() ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Scene::CreateEdgePart( ISurfTriMesh* pSrf)
+{
+  // vertici
+   pSrf->AddVertex( Point3d( 0.33 * m_dCubeEdge, - 0.085 * m_dCubeEdge, 0)) ;
+   pSrf->AddVertex( Point3d( - 0.33 * m_dCubeEdge, - 0.085 * m_dCubeEdge, 0)) ;
+   pSrf->AddVertex( Point3d( - 0.33 * m_dCubeEdge, 0, - 0.085 * m_dCubeEdge)) ;
+   pSrf->AddVertex( Point3d( 0.33 * m_dCubeEdge, 0, - 0.085 * m_dCubeEdge)) ;
+   pSrf->AddVertex( Point3d( - 0.33 * m_dCubeEdge, 0.085 * m_dCubeEdge, - 0.17 * m_dCubeEdge)) ;
+   pSrf->AddVertex( Point3d( 0.33 * m_dCubeEdge, 0.085 * m_dCubeEdge, - 0.17 * m_dCubeEdge)) ;
+
+  // triangoli
+   int nNewInd_0[3] = { 2, 1 ,0} ;
+   pSrf->AddTriangle( nNewInd_0) ;
+   int nNewInd_1[3] = { 3, 2, 0} ;
+   pSrf->AddTriangle( nNewInd_1) ;
+   int nNewInd_2[3] = { 2, 5, 4} ;
+   pSrf->AddTriangle( nNewInd_2) ;
+   int nNewInd_3[3] = { 2, 3, 5} ;
+   pSrf->AddTriangle( nNewInd_3) ;
+
+  // verifico
+   pSrf->DoCompacting() ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Scene::CreateCornerPart( ISurfTriMesh* pSrf)
+{
+  // vertici
+   pSrf->AddVertex( Point3d( - 0.085 * m_dCubeEdge, 0.085 * m_dCubeEdge, -0.17 * m_dCubeEdge)) ;
+   pSrf->AddVertex( Point3d( - 0.085 * m_dCubeEdge, - 0.085 * m_dCubeEdge, 0)) ;
+   pSrf->AddVertex( Point3d( 0.085 * m_dCubeEdge, - 0.085 * m_dCubeEdge, - 0.17 * m_dCubeEdge)) ;
+
+  // triangoli
+   int nNewInd_0[3] = { 0, 1, 2} ;
+   pSrf->AddTriangle( nNewInd_0) ;
+
+  // verifico
+   pSrf->DoCompacting() ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+static ObjEGrGraphics*
+CreateObjEGrGraphics( int nCount, bool bNewWay)
+{
+   if ( nCount > 1)
+      return ( new( nothrow) ObjMultiGraphics( nCount, bNewWay)) ;
+   else if ( bNewWay)
+      return ( new( nothrow) ObjNewGraphics) ;
+   else
+      return ( new( nothrow) ObjOldGraphics) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Scene::DrawCube( bool bSurf)
+{
+
+  // recupero la matrice viewport
+   GLint Viewport[4] ;
+   glGetIntegerv( GL_VIEWPORT, Viewport) ;
+
+  // se il vettore delle superifici č vuoto, allora lo creo
+   if ( m_vStm_Cube.empty()) {
+     // Z+ -> 1 -> TOP
+      PtrOwner<ISurfTriMesh> pStm_Zp( CreateSurfTriMesh()) ;
+      CreateFlatPart( pStm_Zp) ;
+      pStm_Zp->Translate( Vector3d( 0, 0, 0.5 * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_Zp)) ;
+
+     // Z- -> 2 -> BOTTOM
+      PtrOwner<ISurfTriMesh> pStm_Zm( CreateSurfTriMesh()) ;
+      CreateFlatPart( pStm_Zm) ;
+      pStm_Zm->Rotate( ORIG, Y_AX, 180) ;
+      pStm_Zm->Translate( Vector3d( 0, 0, - 0.5 * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_Zm)) ;
+
+     // X+ -> 3 -> RIGHT
+      PtrOwner<ISurfTriMesh> pStm_Xp( CreateSurfTriMesh()) ;
+      CreateFlatPart( pStm_Xp) ;
+      pStm_Xp->Rotate( ORIG, Y_AX, 180) ;
+      pStm_Xp->Rotate( ORIG, -Y_AX, 90) ;
+      pStm_Xp->Translate( Vector3d( 0.5 * m_dCubeEdge, 0, 0)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_Xp)) ;
+
+     // X- -> 4 -> LEFT
+      PtrOwner<ISurfTriMesh> pStm_Xm( CreateSurfTriMesh()) ;
+      CreateFlatPart( pStm_Xm) ;
+      pStm_Xm->Rotate( ORIG, -Y_AX, 90) ;
+      pStm_Xm->Translate( Vector3d( -0.5 * m_dCubeEdge, 0, 0)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_Xm)) ;
+
+      // Y+ -> 5 -> FRONT
+      PtrOwner<ISurfTriMesh> pStm_Yp( CreateSurfTriMesh()) ;
+      CreateFlatPart( pStm_Yp) ;
+      pStm_Yp->Rotate( ORIG, -X_AX, 90) ;
+      pStm_Yp->Translate( Vector3d( 0, 0.5 * m_dCubeEdge, 0)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_Yp)) ;
+
+     // Y- -> 6 -> BACK
+      PtrOwner<ISurfTriMesh> pStm_Ym( CreateSurfTriMesh()) ;
+      CreateFlatPart( pStm_Ym) ;
+      pStm_Ym->Rotate( ORIG, Y_AX, 180) ;
+      pStm_Ym->Rotate( ORIG, -X_AX, 90) ;
+      pStm_Ym->Translate( Vector3d( 0, -0.5 * m_dCubeEdge, 0)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_Ym)) ;
+  
+     // Z+X+ -> 7 -> TOP-RIGHT
+      PtrOwner<ISurfTriMesh> pStm_ZpXp( CreateSurfTriMesh()) ;
+      CreateEdgePart( pStm_ZpXp) ;
+      pStm_ZpXp->Rotate( ORIG, -Z_AX, 90) ;
+      pStm_ZpXp->Translate( Vector3d(( 0.5 - 0.085) * m_dCubeEdge , 0, 0.5 * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_ZpXp)) ;
+
+     // Z+X- -> 8 -> TOP-LEFT
+      PtrOwner<ISurfTriMesh> pStm_ZpXm( CreateSurfTriMesh()) ;
+      CreateEdgePart( pStm_ZpXm) ;
+      pStm_ZpXm->Rotate( ORIG, Z_AX, 90) ;
+      pStm_ZpXm->Translate( Vector3d(( - 0.5 + 0.085) * m_dCubeEdge, 0, 0.5 * m_dCubeEdge));
+      m_vStm_Cube.emplace_back( Release( pStm_ZpXm)) ;
+
+     // Z-X+ -> 9 -> BOTTOM-RIGHT
+      PtrOwner<ISurfTriMesh> pStm_ZmXp( CreateSurfTriMesh()) ;
+      CreateEdgePart( pStm_ZmXp) ;
+      pStm_ZmXp->Rotate( ORIG, -Z_AX, 90) ;
+      pStm_ZmXp->Rotate( ORIG, Y_AX, 90) ;
+      pStm_ZmXp->Translate( Vector3d( 0.5 * m_dCubeEdge, 0,( - 0.5 + 0.085) * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_ZmXp)) ;
+
+     // Z-X- -> 10 -> BOTTOM-LEFT
+      PtrOwner<ISurfTriMesh> pStm_ZmXm( CreateSurfTriMesh()) ;
+      CreateEdgePart( pStm_ZmXm) ;
+      pStm_ZmXm->Rotate( ORIG, Z_AX, 90) ;
+      pStm_ZmXm->Rotate( ORIG, -Y_AX, 90) ;
+      pStm_ZmXm->Translate( Vector3d( - 0.5 * m_dCubeEdge, 0, ( - 0.5 + 0.085) * m_dCubeEdge)) ;;
+      m_vStm_Cube.emplace_back( Release( pStm_ZmXm)) ;
+
+     // Z+Y+ -> 11 -> TOP-FRONT
+      PtrOwner<ISurfTriMesh> pStm_ZpYp( CreateSurfTriMesh()) ;
+      CreateEdgePart( pStm_ZpYp) ;
+      pStm_ZpYp->Translate( Vector3d( 0, ( 0.5 - 0.085) * m_dCubeEdge, 0.5  * m_dCubeEdge)) ;
+      pStm_ZpYp->SetTempProp( 5, 0) ;
+      m_vStm_Cube.emplace_back( Release( pStm_ZpYp)) ;
+
+     // Z+Y- -> 12 -> TOP-BACK
+      PtrOwner<ISurfTriMesh> pStm_ZpYm( CreateSurfTriMesh()) ;
+      CreateEdgePart( pStm_ZpYm) ;
+      pStm_ZpYm->Rotate( ORIG, -Z_AX, 180) ;
+      pStm_ZpYm->Translate( Vector3d( 0, ( - 0.5 + 0.085) * m_dCubeEdge, 0.5  * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_ZpYm)) ;
+
+     // Z-Y+ -> 13 -> BOTTOM-FRONT
+      PtrOwner<ISurfTriMesh> pStm_ZmYp( CreateSurfTriMesh()) ;
+      CreateEdgePart( pStm_ZmYp) ;
+      pStm_ZmYp->Rotate( ORIG, -X_AX, 90) ;
+      pStm_ZmYp->Translate( Vector3d( 0, ( 0.5) * m_dCubeEdge ,
+                                      ( - 0.5 + 0.085)  * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_ZmYp)) ;
+
+     // Z-Y- -> 14 -> BOTTOM-BACK
+      PtrOwner<ISurfTriMesh> pStm_ZmYm( CreateSurfTriMesh()) ;
+      CreateEdgePart( pStm_ZmYm) ;
+      pStm_ZmYm->Rotate( ORIG, -Z_AX, 180) ;
+      pStm_ZmYm->Rotate( ORIG, X_AX, 90) ;
+      pStm_ZmYm->Translate( Vector3d( 0, - 0.5 * m_dCubeEdge, ( - 0.5 + 0.085)  * m_dCubeEdge )) ;
+      m_vStm_Cube.emplace_back( Release( pStm_ZmYm)) ;
+
+     // X+Y+ -> 15 -> RIGHT-FRONT
+      PtrOwner<ISurfTriMesh> pStm_XpYp( CreateSurfTriMesh()) ;
+      CreateEdgePart( pStm_XpYp) ;
+      pStm_XpYp->Rotate( ORIG, Y_AX, 90) ;
+      pStm_XpYp->Translate( Vector3d( 0.5 * m_dCubeEdge,( 0.5 - 0.085) * m_dCubeEdge, 0)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_XpYp)) ;
+
+     // X-Y+ -> 16 -> LEFT-FRONT
+      PtrOwner<ISurfTriMesh> pStm_XmYp( CreateSurfTriMesh()) ;
+      CreateEdgePart( pStm_XmYp) ;
+      pStm_XmYp->Rotate( ORIG, -Y_AX, 90) ;
+      pStm_XmYp->Translate( Vector3d( - 0.5 * m_dCubeEdge, ( 0.5 - 0.085) * m_dCubeEdge, 0)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_XmYp)) ;
+
+     // X+Y- -> 17 -> RIGHT-BACK
+      PtrOwner<ISurfTriMesh> pStm_XpYm( CreateSurfTriMesh()) ;
+      CreateEdgePart( pStm_XpYm) ;
+      pStm_XpYm->Rotate( ORIG, -Y_AX, 90) ;
+      pStm_XpYm->Rotate( ORIG, Z_AX, 180) ;
+      pStm_XpYm->Translate( Vector3d( 0.5 * m_dCubeEdge, ( - 0.5 + 0.085) * m_dCubeEdge , 0)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_XpYm)) ;
+
+     // X-Y- -> 18 -> LEFT-BACK
+      PtrOwner<ISurfTriMesh> pStm_XmYm( CreateSurfTriMesh()) ;
+      CreateEdgePart( pStm_XmYm) ;
+      pStm_XmYm->Rotate( ORIG, Y_AX, 90) ;
+      pStm_XmYm->Rotate( ORIG, Z_AX, 180) ;
+      pStm_XmYm->Translate( Vector3d( - 0.5 * m_dCubeEdge,- ( 0.5 - 0.085) * m_dCubeEdge, 0)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_XmYm)) ;
+
+     // Z+X+Y+ -> 19 -> TOP-RIGHT-FRONT
+      PtrOwner<ISurfTriMesh> pStm_XpYpZp( CreateSurfTriMesh()) ;
+      CreateCornerPart( pStm_XpYpZp ) ;
+      pStm_XpYpZp->Translate( Vector3d(( 0.5 - 0.085) * m_dCubeEdge, ( 0.5 - 0.085) * m_dCubeEdge, 0.5 * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_XpYpZp)) ;
+
+     // Z+X-Y+ -> 20 -> TOP-LEFT-FRONT
+      PtrOwner<ISurfTriMesh> pStm_XmYpZp( CreateSurfTriMesh()) ;
+      CreateCornerPart( pStm_XmYpZp) ;
+      pStm_XmYpZp->Rotate( ORIG, Z_AX, 90) ;
+      pStm_XmYpZp->Translate( Vector3d(( - 0.5 + 0.085) * m_dCubeEdge,( 0.5 - 0.085) * m_dCubeEdge,0.5 * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_XmYpZp)) ;
+
+     // Z+X+Y- -> 21 -> TOP-RIGHT-BACK
+      PtrOwner<ISurfTriMesh> pStm_XpYmZp( CreateSurfTriMesh()) ;
+      CreateCornerPart( pStm_XpYmZp) ;
+      pStm_XpYmZp->Rotate( ORIG, -Z_AX, 90) ;
+      pStm_XpYmZp->Translate( Vector3d(( + 0.5 - 0.085) * m_dCubeEdge, ( - 0.5 + 0.085) * m_dCubeEdge,0.5 * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_XpYmZp)) ;
+   
+     // Z+X-Y- -> 22 -> TOP-LEFT-BACK
+      PtrOwner<ISurfTriMesh> pStm_XmYmZp( CreateSurfTriMesh()) ;
+      CreateCornerPart( pStm_XmYmZp) ;
+      pStm_XmYmZp->Rotate( ORIG, Z_AX, 180) ;
+      pStm_XmYmZp->Translate( Vector3d(( - 0.5 + 0.085) * m_dCubeEdge, ( - 0.5 + 0.085) * m_dCubeEdge, 0.5 * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_XmYmZp)) ;
+
+     // Z-X+Y+ -> 23 -> BOTTOM-RIGHT-FRONT
+      PtrOwner<ISurfTriMesh> pStm_XpYpZm( CreateSurfTriMesh()) ;
+      CreateCornerPart( pStm_XpYpZm) ;
+      pStm_XpYpZm->Rotate( ORIG, X_AX, 180) ;
+      pStm_XpYpZm->Rotate( ORIG, Z_AX, 90) ;
+      pStm_XpYpZm->Translate( Vector3d(( 0.5 - 0.085) * m_dCubeEdge, ( 0.5 - 0.085) * m_dCubeEdge, - 0.5 * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_XpYpZm)) ;
+
+     // Z-X-Y+ -> 24 -> BOTTOM-LEFT-FRONT
+      PtrOwner<ISurfTriMesh> pStm_XmYpZm( CreateSurfTriMesh()) ;
+      CreateCornerPart( pStm_XmYpZm) ;
+      pStm_XmYpZm->Rotate(ORIG, -X_AX, 90) ;
+      pStm_XmYpZm->Rotate( ORIG, Z_AX, 90) ;
+      pStm_XmYpZm->Translate( Vector3d( - 0.5 * m_dCubeEdge, ( 0.5 - 0.085) * m_dCubeEdge,( - 0.5 + 0.085) * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_XmYpZm)) ;
+
+    // Z-X+Y- -> 25 -> BOTTOM-RIGHT-BACK
+      PtrOwner<ISurfTriMesh> pStm_XpYmZm( CreateSurfTriMesh()) ;
+      CreateCornerPart( pStm_XpYmZm) ;
+      pStm_XpYmZm->Rotate( ORIG, X_AX, 180) ;
+      pStm_XpYmZm->Translate( Vector3d(( + 0.5 - 0.085) * m_dCubeEdge, ( - 0.5 + 0.085) * m_dCubeEdge, - 0.5 * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_XpYmZm)) ;
+
+     // Z-X-Y- -> 26 -> BOTTOM-LEFT-BACK
+      PtrOwner<ISurfTriMesh> pStm_XmYmZm( CreateSurfTriMesh()) ;
+      CreateCornerPart( pStm_XmYmZm) ;
+      pStm_XmYmZm->Rotate( ORIG, X_AX, 180) ;
+      pStm_XmYmZm->Rotate( ORIG, -Z_AX, 90) ;
+      pStm_XmYmZm->Translate( Vector3d(( - 0.5 + 0.085) * m_dCubeEdge, ( - 0.5 + 0.085) * m_dCubeEdge, - 0.5 * m_dCubeEdge)) ;
+      m_vStm_Cube.emplace_back( Release( pStm_XmYmZm)) ;
+   }
+
+  // creo un vettore di Graphics, uno per ogni superificie del cubetto
+   vector<PtrOwner<ObjEGrGraphics>> vGraphics ;
+   for ( int i = 0 ; i < 26 ; ++ i) {
+      PtrOwner<ObjEGrGraphics> pNewGraphics( CreateObjEGrGraphics( 0, false)) ;
+      vGraphics.emplace_back( Release( pNewGraphics)) ;
+      vGraphics[i]->SetScene( this) ;
+   }
+
+  // render delle superifici del cubo ( superfici o Linee a seconda del Flag)
+   for ( int s = 0 ; s < 26 ; ++ s) {
+
+     // recupero la superificie corrente del cubo da visualizzare
+      PtrOwner<ISurfTriMesh> pStmCurr( CloneSurfTriMesh( m_vStm_Cube[s])) ;
+      if ( IsNull( pStmCurr))
+         return false ;
+
+     // scalo la superificie a seconda della viewport corrente ( per Zoom)
+      pStmCurr->Scale( GLOB_FRM, ( 2 * m_dHalfWidth) / Viewport[2], ( 2 * m_dHalfWidth) / Viewport[2],
+                                 ( 2 * m_dHalfWidth) / Viewport[2]) ;
+     // sposto la superificie nel sistema di riferimento relativo alla telecamera ( per Pan)
+      pStmCurr->Translate(( m_ptOrigCube - ORIG)) ;
+
+     // definisco colori per i vertici e colore per le linee
+      Color cCol_Vertex ;
+      Color cCol_Line = CUBE_LINES ;
+
+      switch ( s) {
+         case 0 :
+            cCol_Vertex = m_cColZ ; break ;
+         case 1 :
+            cCol_Vertex = m_cColZm ; break ;
+         case 2 :
+            cCol_Vertex = m_cColX ; break ;
+         case 3 :
+            cCol_Vertex = m_cColXm ; break ;
+         case 4 :
+            cCol_Vertex = m_cColY ; break ;
+         case 5 :
+            cCol_Vertex = m_cColYm ; break ;
+            break ;
+         case 6 : case 7 : case 8 : case 9 : case 10 : case 11 :
+         case 12 : case 13 : case 14 : case 15 : case 16 : case 17 :
+            cCol_Vertex = m_cColEdge ; break ;
+         case 18 : case 19 : case 20 : case 21: case 22: case 23 : case 24 : case 25 :
+            cCol_Vertex = m_cColCorner ; break ;
+         default :
+            break ;
+      }
+      vGraphics[s]->AddColor( bSurf ? cCol_Vertex : CUBE_LINES) ;
+      int nTria = pStmCurr->GetTriangleCount() ;
+      vGraphics[s]->StartTriangles( nTria) ;
+      Triangle3dEx Tria ;
+      int nId = pStmCurr->GetFirstTriangle( Tria) ;
+      while ( nId != SVT_NULL) {
+        // edge solo se boundary e normali ai vertici smussate
+         vGraphics[s]->AddTriangle( Tria, Tria.GetTriFlags(), Tria.GetTriNormals()) ;
+         nId = pStmCurr->GetNextTriangle( nId, Tria) ;
+      }
+      vGraphics[s]->EndTriangles() ;
+     // assegno un id temporaneo alla superificie caricata ( modalita wireFrame, come nella Select)
+      if ( ! bSurf)
+         glLoadName( m_nStartFaceId + s + 1) ;
+      vGraphics[s]->Draw( GDB_ST_ON, GDB_MK_OFF, true, true, 80, false) ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Scene::DrawGlobCube( bool bSurf)
+{
+  // se non devo disegnare il cubetto, esco
+   if ( ! m_bShowGlobCube)
+       return true ;
+
+  // recupero il primo Id libero ( e aggiungo 1000)
+   m_nStartFaceId = m_pGeomDB->GetNewId() + 1000 ;
+
+  // recupero la matrice viewport
+   GLint Viewport[4] ;
+   glGetIntegerv( GL_VIEWPORT, Viewport) ;
+
+  // imposto il riferimento
+   glPushMatrix() ;
+
+  // se sono in selezione il cubo lo lascio nella posizione precedente ( cambio di viewport => cambio centro del cubo)
+   Point3d ptOrig ;
+   if ( m_bSelect)
+      ptOrig = m_ptOrigCube ;
+   else {
+      UnProject( Point3d( m_dCubeX, m_dCubeY, 0.25), ptOrig) ; // posizione Z del cubo sempre 0.25 dallo schermo
+      m_ptOrigCube = ptOrig ;
+   }
+
+  // creo il cubo
+   if ( ! DrawCube( bSurf))
+      return true ;
+
+  // tolgo lo stack dei nomi in modalitŕ selezione
+   if ( m_bSelect)
+     glLoadName( 0) ;
+
+  // ripristino lo stack delle matrici
+   glPopMatrix() ;
+   return true ;
+}
+
+
+//----------------------------------------------------------------------------
+bool
+Scene::RotateCameraWithCube()
+{
+  // controllo se il cubetto č abilitato e ho almeno un Id dalla selezione nel buffer
+   if ( ! m_bShowGlobCube  ||  m_nSelNbr == 0)
+       return false ;
+
+  // controllo che la selezione non sia avvenuta mediante Drag
+   if ( m_nSelW != 13  ||  m_nSelH != 13)
+      return false ;
+
+  // se ho piů di un elemento trovato, do prioritŕ alla superificie con piů facce
+   int nId = 0 ;
+   int nFace = 1 ;
+   bool bSelStm_Cube = false ;
+
+   for ( int i = 0 ; i < m_nSelNbr ; ++ i) {
+     // recupero l'Id corrente
+      int nCurrId = m_nSelBuff[i].nId ;
+     // controllo che l'Id appartenga ad una superificie del cubetto
+      if ( nCurrId <= m_nStartFaceId  ||  nCurrId > m_nStartFaceId + 26)
+         continue ;
+
+      bSelStm_Cube = true ;
+      int nCurrFace = 1 ;
+      if ( nCurrId - m_nStartFaceId > 6  &&  nCurrId - m_nStartFaceId <= 18) // se superificie Edge
+         nCurrFace = 2 ;
+      else if ( nCurrId - m_nStartFaceId > 18)  // se superificie Corner
+         nCurrFace = 3 ;
+
+      nFace = max( nFace, nCurrFace) ;
+      if ( nFace == 1  ||  nFace == nCurrFace)
+         nId = nCurrId ;
+   }
+   if ( ! bSelStm_Cube)
+      return false ;
+
+  // ottengo la faccia del cubo selezionato ( valore tra 1 e 26)
+   int nCubeface = nId - m_nStartFaceId ;
+
+  // prendo i parametri della telecamera
+   double dTheta, dPhi, dDist ;
+   GetCamera( &dPhi, &dTheta, &dDist) ;
+   double dPhi_orig = dPhi ;
+   double dTheta_orig = dTheta ;
+
+  // flag per numero di Step fatti e valore forzato di Theta per Z+ e Z-
+   bool bHasTwoStep = false ;
+   double dTheta_Forced = 0.0 ;
+
+  // imposto i nuovi angoli theta e phi mantenendo la distanza
+   if ( GetAngleByCubeFace( nCubeface, dTheta, dPhi)) {
+     // ricavo il vettore iniziale della telecamera
+      Vector3d v_q1 = m_vtDirCamera ;
+     // ricavo il vettore finale della telecamera
+      Vector3d v_q2 = FromSpherical( 1 , dPhi, dTheta) ;
+     // flag per rotazione necessaria o superflua
+      bool bDoRotation = true ;
+     // nuovi angoli nel caso di doppie rotazioni
+      double dTheta_new ; double dPhi_new ;
+
+     // controllo se voglio mettere la vista in Z+ o Z-
+      if ( AreSameOrOppositeVectorApprox( v_q2, Z_AX)) {
+        // controllo se sono giŕ in posizione questa posizione ( Z+ o Z-)
+         if ( AreSameVectorApprox( v_q1, v_q2)) {
+           // se sono giŕ orientato in maniera corretta non faccio nulla, altrimenti...
+            if ( abs( dTheta_orig - ( ANG_RIGHT - ANG_STRAIGHT)) > EPS_ANG_SMALL) {
+               Vector3d v_q1S = FromSpherical( 1, 90, dTheta_orig) ;
+              // ... ruoto la telecamera solo lungo theta
+               RotateCameraWithBlockedAngle( v_q1S, -Y_AX, dDist, true, 1, dTheta_orig, dPhi_orig, dTheta_new, dPhi_new) ;
+            }
+            bDoRotation = false ;
+         }
+        // se non sono in posizione Z+ o Z- e devo andare in una di queste due, allora... 
+         else if ( ! (( v_q2.IsZplus()  ||  v_q2.IsZminus())  &&  
+                 ( abs( dTheta_orig - ( ANG_STRAIGHT + ANG_RIGHT)) < EPS_SMALL  &&  v_q1.y < 0))) {
+           // controllo se sono nel caso limite della faccia quasi opposta
+            bool bForceCoeff = false ;
+            if ( abs( dTheta_orig - ( ANG_RIGHT)) < EPS_ANG_SMALL)
+               v_q1.Rotate( Z_AX, 5) ;
+            bHasTwoStep = true ;
+           // ... ruoto la telecamera solo lungo theta
+            RotateCameraWithBlockedAngle( v_q1, - Y_AX, 1, true, 1, dTheta_orig, dPhi_orig, dTheta_new, dPhi_new) ;
+               dTheta_Forced = ANG_RIGHT + ANG_STRAIGHT ;
+            v_q1 = FromSpherical( 1, dPhi_orig, dTheta_Forced) ;
+         }
+      }
+     // controllo se sono in posizione Z+ o Z- e devo sistemare la vista in un'altra posizione
+      else if ( AreSameOrOppositeVectorApprox( v_q1, Z_AX)) {
+        // ho giŕ controllato di non aver v_q1 e v_q2 paralleli...
+         double dTheta_S, dPhi_S , dLenS_ ;
+         v_q2.ToSpherical( &dLenS_, &dPhi_S, &dTheta_S) ;
+
+         if ( abs( dTheta_orig - dTheta_S) > EPS_SMALL) {
+            Vector3d v_q1S = FromSpherical( 1, 90, dTheta_orig) ;
+
+           // controllo nel caso di angoli opposti ( o quasi)
+            bool bForceCoeff = false ;
+            if ( abs( dTheta_S - ANG_RIGHT ) < EPS_ANG_SMALL) {
+               v_q1S.Rotate( Z_AX, dTheta_S - ANG_RIGHT >= 0 ? ANG_ROT_TOLL : -ANG_ROT_TOLL) ;
+               bForceCoeff = true ;
+            }
+
+           // ... ruoto la telecamera solo lungo theta
+            RotateCameraWithBlockedAngle( v_q1S, v_q2, dDist, bForceCoeff ? 2 : 1, 1, dTheta_orig, dPhi_orig, 
+                                          dTheta_new, dPhi_new) ;
+            
+            dTheta_Forced = dTheta_new ;
+            v_q1 = FromSpherical( 1, dPhi_orig, dTheta_Forced) ;
+            bHasTwoStep = true ;
+         }
+         else {
+            bHasTwoStep = true ;
+            dTheta_Forced = ANG_RIGHT + ANG_STRAIGHT ;
+         }
+      }
+     // se devo ruotare ... animazione mediante Slerp con parametro u tra 0 e 1
+      if ( bDoRotation)
+         RotateCameraWithBlockedAngle( v_q1, v_q2, dDist, true, bHasTwoStep ? 2 : 0, dTheta_Forced, dPhi_orig,
+                                       dTheta_new, dPhi_new) ;
+   }
+
+  // refresh finale per sicurezza
+   RedrawWindow() ;
+  // annullo il numero di elementi selezionati
+   m_nSelNbr = 0 ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool 
+Scene::RotateCameraWithBlockedAngle( Vector3d vDirS, Vector3d vDirE, double dDist, int nAdaptSpeed,
+                                     int nBlockedAngle, double dTheta_orig, double dPhi_orig,
+                                     double& dTheta_new, double& dPhi_new)
+{
+  // controllo dei parametri
+   if ( vDirS.IsSmall()  ||  vDirE.IsSmall()  ||  dDist < EPS_SMALL)
+      return false ;
+   if ( nBlockedAngle < 0  ||  nBlockedAngle > 2)
+      nBlockedAngle = 0 ;
+   vDirS.Normalize() ;
+   vDirE.Normalize() ;
+
+  // angolo per interpolazione sferica
+   double dAng = acos( vDirS * vDirE) ;
+
+  // imposto la velocitŕ di rotazione a seconda dell'angolo da percorrere... ( se richisto, altrimenti 1)
+   int nCoeff = 1 ;
+   if (( nAdaptSpeed == 1  &&  dAng * RADTODEG > ANG_RIGHT * ( 2.0 / 3.0) - 50 * EPS_ANG_SMALL)  ||  nAdaptSpeed == 2)
+      nCoeff = 2 ;
+   double dThetaSs, dPhiSs, dLenSs, dThetaEs, dPhiEs, dLenEs ;
+   vDirS.ToSpherical( &dLenSs, &dPhiSs, &dThetaSs) ;
+   vDirE.ToSpherical( &dLenEs, &dPhiEs, &dThetaEs) ;
+   if (( abs ( abs( dThetaEs - dThetaSs) - ANG_STRAIGHT)) < 3 * ANG_ROT_TOLL + 5 * EPS_ANG_SMALL)
+      nCoeff = 4 ;
+
+  // ricavo i parametri per l'interpolazione sferica
+   for ( int u = 0 ; u <= 10 * nCoeff  &&  abs( dAng) > EPS_SMALL ; ++ u) {
+      double du = u ;
+      if ( nCoeff == 2) du = 0.5 * u ;
+      if ( nCoeff == 4) du = 0.25 * u ;
+      Vector3d vSlerp = (( sin( 1 - 0.1 * du) * dAng) / sin( dAng)) * vDirS +
+                         ( sin( 0.1 * du * dAng) / sin( dAng)) * vDirE ;
+      double dTheta_u ,dPhi_u ,dLen ;
+      vSlerp.ToSpherical( &dLen, &dPhi_u, &dTheta_u) ;
+      if ( abs( u - 10 * nCoeff) < EPS_SMALL  &&
+         ( abs( dPhi_u) < EPS_ANG_SMALL  ||  abs( dPhi_u - ANG_STRAIGHT) < EPS_ANG_SMALL))
+         dTheta_u = ANG_STRAIGHT + ANG_RIGHT ;
+      SetCamera( nBlockedAngle == 1 ? dPhi_orig : dPhi_u,
+                 nBlockedAngle == 2 ? dTheta_orig : dTheta_u, dDist) ;
+      RedrawWindow() ;
+      dTheta_new = dTheta_u ;
+      dPhi_new = dPhi_u ;
+   }
+
+   return true ;
+}
+
+
+//----------------------------------------------------------------------------
+bool 
+Scene::GetAngleByCubeFace( int nFaceId, double &dTheta, double &dPhi)
+{
+   switch ( nFaceId)
+   {
+   case 1 : // TOP
+       dPhi = 0 ; dTheta = 270 ;
+       break ;
+   case 2 : // BOTTOM
+       dPhi = 180 ; dTheta = 270 ;
+       break ; 
+   case 3 : // RIGHT
+       dPhi = 90 ; dTheta = 0 ;
+       break ;
+   case 4 : // LEFT
+       dPhi = 90 ; dTheta = 180 ;
+       break ;
+   case 5 : // FRONT
+       dPhi = 90 ; dTheta = 90 ;
+       break ;
+   case 6 : // BACK
+       dPhi = 90 ; dTheta = 270 ;
+       break ;
+   case 7 : // TOP-RIGHT
+       dPhi = 45 ; dTheta = 0 ;
+       break ;
+   case 8 : // TOP-LEFT
+       dPhi = 45 ; dTheta = 180 ;
+       break ;
+   case 9 : // BOTTOM-RIGHT
+       dPhi = 225 ; dTheta = 180 ;
+       break ;
+   case 10 : // BOTTOM-LEFT
+       dPhi = 225 ; dTheta = 0 ;
+       break ;
+   case 11 : // TOP-FRONT
+       dPhi = 45 ; dTheta = 90 ;
+       break ;
+   case 12  : // TOP-BACK
+       dPhi = 45 ; dTheta = 270 ;
+       break ;
+   case 13 : // BOTTOM-FRONT
+       dPhi = 225 ; dTheta = 270 ;
+       break ;
+   case 14 : // BOTTOM-BACK
+       dPhi = 225 ; dTheta = 90 ;
+       break ;
+   case 15 : // RIGHT-FRONT
+       dPhi = 90 ; dTheta = 45 ;
+       break ;
+   case 16 : // LEFT-FRONT
+       dPhi = 90 ; dTheta = 135 ;
+       break ;
+   case 17 : // RIGHT-BACK
+       dPhi = 90 ; dTheta = 315 ;
+       break ;
+   case 18 : // LEFT-BACK
+       dPhi = 90 ; dTheta = 225 ;
+       break ;
+   case 19 : // TOP-RIGHT-FRONT
+       dPhi = 45 ; dTheta = 45 ;
+       break ;
+   case 20 : // TOP-LEFT-FRONT
+       dPhi = 45 ; dTheta = 135 ;
+       break ;
+   case 21 : // TOP-RIGHT-BACK
+       dPhi = 45 ; dTheta = 315 ;
+       break ;
+   case 22 : // TOP-LEFT-BACK
+       dPhi = 45 ; dTheta = 225 ;
+       break ;
+   case 23 : // BOTTOM-RIGHT-FRONT
+       dPhi = 135 ; dTheta = 45 ;
+       break ;
+   case 24 : // BOTTOM-LEFT-FRONT
+       dPhi = 135 ; dTheta = 135 ;
+       break ;
+   case 25 : // BOTTOM-RIGHT-BACK
+       dPhi = 135 ; dTheta = 315 ;
+       break ;
+   case 26: // BOTTOM-LEFT-BACK
+       dPhi = 135 ; dTheta = 215 ;
+       break ;
+   default :
+       break ;
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool 
+Scene::SetGlobCubeParameters( int nPosFlag, double dDistX, double dDistY, double dLenEdge)
+{ 
+  // controllo ammissibilitŕ dei parametri
+   if ( nPosFlag < 0  ||  nPosFlag > 4  ||
+      dDistX < 0 ||  dDistY < 0  ||
+      dLenEdge < MIN_EDGE_SIZE  ||  dLenEdge > MAX_EDGE_SIZE )
+   return false ;
+
+  // se visualizzazione del cubo non ammessa, esco
+   if ( nPosFlag == 0) {
+      m_bShowGlobCube = false ;
+      return true ;
+   }
+
+  // imposto il flag di scelta dell'angolo del cubetto
+   m_nCube_Flag = nPosFlag ;
+
+  // recupero la matrice viewport
+   GLint Viewport[4] ;
+   glGetIntegerv( GL_VIEWPORT, Viewport) ;
+
+  // imposto le coordinate del centro del cubo ( X e Y coordinate in ViewPort)
+   double dCoordX = 0 ;
+   double dCoordY = 0 ;
+   switch ( m_nCube_Flag)
+   {
+   case 1 : // cubo in alto a destra
+      dCoordX = Viewport[2] - dDistX ;
+      dCoordY = dDistY ;
+      break ;
+   case 2 : // cubo in alto a sinistra
+      dCoordX = dDistX ;
+      dCoordY = dDistY ;
+      break ;
+   case 3 : // cubo in basso a sinistra
+      dCoordX = dDistX ;
+      dCoordY = Viewport[3] - dDistY ;
+      break ;
+   case 4 : // cubo in basso a destra
+      dCoordX = Viewport[2] - dDistX ;
+      dCoordY = Viewport[3] - dDistY ;
+      break ;
+   default :
+      return false ;
+      break ;
+   }
+
+  // controllo che il cubo stia nella Viewport verticale con l'ingombro del suo lato
+   if ( dCoordX <= sqrt( 3) * dLenEdge * 0.5 * sqrt( 2) * 0.5 + 3  ||
+        dCoordX >= Viewport[2] - sqrt( 3) * dLenEdge * 0.5 * sqrt( 2) / 2 - 3)
+      return false ;
+
+  // controllo che il cubo stia nella Viewport orizzontale con l'ingombro del suo lato
+   if ( dCoordY <= Viewport[1] + sqrt( 3) * dLenEdge * 0.5 * sqrt( 2) * 0.5 + 3  ||
+        dCoordY >= Viewport[3] - sqrt( 3) * dLenEdge * 0.5 * sqrt( 2) * 0.5 - 3)
+      return false ;
+
+  // imposto le variabili membro
+   m_dCubeX = dCoordX ;
+   m_dCubeY = dCoordY ;
+   m_dCubeEdge = dLenEdge ;
+
+   return true ;
+}
+
+

SceneGlobFrame.cpp

@@ -15,10 +15,69 @@
 #include "stdafx.h"
 #include "Scene.h"
 #include "EGrUtils.h"
+#include "/EgtDev/Include/EGkStmStandard.h"
+#include "ObjOldGraphics.h"
+#include "ObjNewGraphics.h"
+#include "ObjMultiGraphics.h"
 
 
 using namespace std ;
 
+// posizione X e Y dello schermo
+const int POSITION_FLAG = 3 ;
+const double DIST_X = 40 ;
+const double DIST_Y = 40 ;
+
+// dimensione lunghezza delle linee
+const double LINE_LEN = 25 ;
+const double MIN_LINE_LEN = 20.0 ;
+const double MAX_LINE_LEN = 100.0 ;
+
+// dimensione spessore delle linee
+const double LINE_WIDTH = 2 ;
+
+// colore origine del Frame
+const Color FRAME_ORIG( 0, 0, 0, 1) ;
+
+// flag creazione coni per assi e vettore delle tre rispettive superifici
+static bool bConeCreated = false ;
+ISURFTMPOVECTOR vStmCones ;
+
+//----------------------------------------------------------------------------
+bool CreateCone( double dConeRad, double dConeLen, double dLen) {
+
+   vStmCones.clear() ;
+   
+   PtrOwner<ISurfTriMesh> pStmConeX( GetSurfTriMeshCone( dConeRad, dConeLen, 10)) ;
+   pStmConeX->Rotate( ORIG, Y_AX, ANG_RIGHT) ;
+   pStmConeX->Translate( Vector3d( 1, 0, 0) * dLen) ;
+   vStmCones.emplace_back( Release( pStmConeX)) ;
+
+   PtrOwner<ISurfTriMesh> pStmConeY( GetSurfTriMeshCone( dConeRad, dConeLen, 10)) ;
+   pStmConeY->Rotate( ORIG, -X_AX, ANG_RIGHT) ;
+   pStmConeY->Translate( Vector3d( 0, 1, 0) * dLen) ;
+   vStmCones.emplace_back( Release( pStmConeY)) ;
+
+   PtrOwner<ISurfTriMesh> pStmConeZ( GetSurfTriMeshCone( dConeRad, dConeLen, 10)) ;
+   pStmConeZ->Translate( Vector3d( 0, 0, 1) * dLen) ;
+   vStmCones.emplace_back( Release( pStmConeZ)) ;
+
+   bConeCreated = true ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+static ObjEGrGraphics*
+CreateObjEGrGraphics( int nCount, bool bNewWay)
+{
+   if ( nCount > 1)
+      return ( new( nothrow) ObjMultiGraphics( nCount, bNewWay)) ;
+   else if ( bNewWay)
+      return ( new( nothrow) ObjNewGraphics) ;
+   else
+      return ( new( nothrow) ObjOldGraphics) ;
+}
+
 //----------------------------------------------------------------------------
 bool
 Scene::SetGlobFrameShow( bool bShow)
@@ -27,6 +86,76 @@ Scene::SetGlobFrameShow( bool bShow)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool 
+Scene::SetGlobFrameParameters( int nPosFlag, double dDistX, double dDistY,
+                               double dLenLine, double dWidthLine)
+{
+   // controllo ammissibilità dei parametri
+   if ( nPosFlag < 0  ||  nPosFlag > 4  ||
+      dDistX < 0 ||  dDistY < 0  ||
+      dLenLine < MIN_LINE_LEN  ||  dLenLine > MAX_LINE_LEN  ||
+      dWidthLine < 1.0)
+   return false ;
+
+  // se visualizzazione del frame non ammessa, esco
+   if ( nPosFlag == 0) {
+      m_bShowGlobFrame = false ;
+      bConeCreated = false ;
+      return true ;
+   }
+
+  // setto il flag di scelta per l'angolo di visualizzazione del Frame
+   m_nAxisFrame_Flag = nPosFlag ;
+
+  // recupero la matrice viewport
+   GLint Viewport[4] ;
+   glGetIntegerv( GL_VIEWPORT, Viewport) ;
+
+  // imposto le coordinate del centro del Frame ( X e Y coordinate in ViewPort)
+   double dCoordX = 0 ;
+   double dCoordY = 0 ;
+   switch ( m_nAxisFrame_Flag)
+   {
+   case 1 : // frame in alto a destra
+      dCoordX = Viewport[2] - dDistX ;
+      dCoordY = dDistY ;
+      break ;
+   case 2 : // frame in alto a sinistra
+      dCoordX = dDistX ;
+      dCoordY = dDistY ;
+      break ;
+   case 3 : // frame in basso a sinistra
+      dCoordX = dDistX ;
+      dCoordY = Viewport[3] - dDistY ;
+      break ;
+   case 4 : // frame in basso a destra
+      dCoordX = Viewport[2] - dDistX ;
+      dCoordY = Viewport[3] - dDistY ;
+      break ;
+   default :
+      break ;
+   }
+
+  // controllo che il frame stia nella Viewport verticale con l'ingombro dei suoi versori
+   if ( dCoordX <= dLenLine * 0.5 * sqrt( 2) + 3  ||
+        dCoordX >= Viewport[2] - sqrt( 2) * dLenLine * 0.5 - 3)
+      return false ;
+
+  // controllo che il frame stia nella Viewport orizzontale con l'ingombro dei suoi versori
+   if ( dCoordY <= Viewport[1] + sqrt( 2) * dLenLine * 0.5 + 3  ||
+        dCoordY >= Viewport[3] - sqrt( 2) * dLenLine * 0.5 - 3)
+      return false ;
+
+  // imposto le variabili membro
+   m_dFrame_DistX = dCoordX ;
+   m_dFrame_DistY = dCoordY ;
+   m_dFrameLineL = dLenLine ;
+   m_dFrameLineW = dWidthLine ;
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 Scene::DrawGlobFrame( void)
@@ -42,38 +171,137 @@ Scene::DrawGlobFrame( void)
   // imposto il riferimento
    glPushMatrix() ;
 
-  // origine del riferimento globale
-   const double DIST_BORDER = 30 ;
-   const double POS_Z = 0.5 ;
+  // imposto l'origine del sistema di riferimento nelle coordinate della ViewPort
    Point3d ptOrig ;
-   UnProject( Point3d( DIST_BORDER, Viewport[3] - DIST_BORDER, POS_Z), ptOrig) ;
+   const double POS_Z = 0.25 ;
+   UnProject( Point3d( m_dFrame_DistX, m_dFrame_DistY, POS_Z), ptOrig) ;
 
-  // lunghezza degli assi
-   const double LEN_AX = DIST_BORDER - 2 ;
-   double dLen = LEN_AX * ( 2 * m_dHalfWidth) / Viewport[2] ;
+  // abilito Ztest per rendering delle linee e dei punti
+   glEnable( GL_DEPTH_TEST) ;
 
-  // disegno degli assi
-   glLineWidth( (float) GetFrameLineWidth()) ;
+  // controllo gli angoli correnti della telecamera per decidere il rendering delle linee ( continue o stripped)
+   double dTheta, dPhi, dDist ;
+   GetCamera( &dPhi, &dTheta, &dDist) ;
+   bool bStripped_X = false ;
+   bool bStripped_Y = false ;
+   bool bStripped_Z = false ;
+   if ( abs( dPhi) > ANG_RIGHT)
+      bStripped_Z = true ;
+   if ( abs( dTheta) > ANG_RIGHT  &&  abs( dTheta) < ANG_RIGHT + ANG_STRAIGHT)
+      bStripped_X = true ;
+   if ( abs( dTheta) > ANG_STRAIGHT)
+      bStripped_Y = true ;
+
+  // scalo la lunghezza degli assi
+   double dLen = m_dFrameLineL * ( 2 * m_dHalfWidth) / Viewport[2] ;
+   double dOrigOff = 0.875 * m_dFrameLineW * ( 2 * m_dHalfWidth) / Viewport[2] ;
+   double dConeRad = m_dFrameLineW * 1.0 ;
+   double dConeLen = 0.4 * m_dFrameLineL ;
+
+  // imposto la dimensione degli assi
+   glLineWidth(( float) m_dFrameLineW) ;
+
+      // asse X
+   if ( bStripped_X)
+      glEnable( GL_LINE_STIPPLE) ;
+   else 
+      glEnable( GL_LINES) ;
    glBegin( GL_LINES) ;
-   // asse X+
-   glColor3f( 1, 0, 0) ;
-   glVertex3f( float( ptOrig.x), float(  ptOrig.y), float( ptOrig.z)) ;
+   glColor3f( m_cColX.GetRed(), m_cColX.GetGreen(), m_cColX.GetBlue()) ;
+   glVertex3f( float( ptOrig.x + dOrigOff), float( ptOrig.y), float( ptOrig.z)) ;
    glVertex3f( float( ptOrig.x + dLen), float( ptOrig.y), float( ptOrig.z)) ;
-   // asse Y+
-   glColor3f( 0, 1, 0) ;
-   glVertex3f( float( ptOrig.x), float( ptOrig.y), float( ptOrig.z)) ;
+   glEnd() ;
+   if ( bStripped_X)
+      glDisable( GL_LINE_STIPPLE) ;
+
+     // asse Y
+   if ( bStripped_Y)
+      glEnable( GL_LINE_STIPPLE) ;
+   else 
+      glEnable( GL_LINES) ;
+   glBegin( GL_LINES) ;
+   glColor3f( m_cColY.GetRed(), m_cColY.GetGreen(), m_cColY.GetBlue()) ;
+   glVertex3f( float( ptOrig.x), float( ptOrig.y + dOrigOff), float( ptOrig.z)) ;
    glVertex3f( float( ptOrig.x), float( ptOrig.y + dLen), float( ptOrig.z)) ;
-   // asse Z+
-   glColor3f( 0, 0, 1) ;
-   glVertex3f( float( ptOrig.x), float( ptOrig.y), float( ptOrig.z)) ;
+   glEnd() ;
+   if ( bStripped_Y)
+      glDisable( GL_LINE_STIPPLE) ;
+
+      // asse Z
+  if ( bStripped_Z)
+      glEnable( GL_LINE_STIPPLE) ;
+   else 
+      glEnable( GL_LINES) ;
+   glBegin( GL_LINES) ;
+   glColor3f( m_cColZ.GetRed(), m_cColZ.GetGreen(), m_cColZ.GetBlue()) ;
+   glVertex3f( float( ptOrig.x), float( ptOrig.y), float( ptOrig.z + dOrigOff)) ;
    glVertex3f( float( ptOrig.x), float( ptOrig.y), float( ptOrig.z + dLen)) ;
    glEnd() ;
+   if ( bStripped_Z)
+      glDisable( GL_LINE_STIPPLE) ;
 
-  // ripristino spessore linee
-   glLineWidth( (float) GetLineWidth()) ;
+  // TEST PUNTI !
+   glEnable( GL_POINT_SMOOTH ) ;
+   glPointSize(( float) 2.5 * m_dFrameLineW) ;
+   glBegin( GL_POINTS) ;
+   glColor3f( FRAME_ORIG.GetRed(), FRAME_ORIG.GetGreen(), FRAME_ORIG.GetBlue()) ;
+   glVertex3f( float( ptOrig.x), float( ptOrig.y), float( ptOrig.z)) ;
+   glEnd() ;
+   glPointSize(( float) GetPointSize()) ;
+   glDisable( GL_POINT_SMOOTH) ;
+
+  // disegno i tre coni ( se precedentemente non già creati)
+   if ( ! bConeCreated)
+      CreateCone( dConeRad, dConeLen, m_dFrameLineL) ;
+
+  // creo un vettore di Graphics, uno per ogni cono del frame
+   vector<PtrOwner<ObjEGrGraphics>> vGraphics ;
+   for ( int i = 0 ; i < 3 ; ++ i) {
+      PtrOwner<ObjEGrGraphics> pNewGraphics( CreateObjEGrGraphics( 0, false)) ;
+      vGraphics.emplace_back( Release( pNewGraphics)) ;
+      vGraphics[i]->SetScene( this) ;
+   }
+
+   for ( int s = 0 ; s < 3 ; ++ s) {
+     // recupero la superificie corrente del cubo da visualizzare
+      PtrOwner<ISurfTriMesh> pStmCurr_Cone( CloneSurfTriMesh( vStmCones[s])) ;
+      if ( IsNull( pStmCurr_Cone))
+         return false ;
+
+     // scalo la superificie a seconda della viewport corrente ( per Zoom)
+      pStmCurr_Cone->Scale( GLOB_FRM, ( 2 * m_dHalfWidth) / Viewport[2], ( 2 * m_dHalfWidth) / Viewport[2],
+                                      ( 2 * m_dHalfWidth) / Viewport[2]) ;
+     // sposto la superificie nel sistema di riferimento relativo alla telecamera ( per Pan)
+      pStmCurr_Cone->Translate(( ptOrig - ORIG)) ;
+
+      Color cCurrColor ;
+      if ( s == 0) cCurrColor = m_cColX ;
+      if ( s == 1) cCurrColor = m_cColY ;
+      if ( s == 2) cCurrColor = m_cColZ ;
+      vGraphics[s]->AddColor( cCurrColor) ;
+      int nTria = pStmCurr_Cone->GetTriangleCount() ;
+      vGraphics[s]->StartTriangles( nTria) ;
+      Triangle3dEx Tria ;
+      int nId = pStmCurr_Cone->GetFirstTriangle( Tria) ;
+      while ( nId != SVT_NULL) {
+        // edge solo se boundary e normali ai vertici smussate
+         vGraphics[s]->AddTriangle( Tria, Tria.GetTriFlags(), Tria.GetTriNormals()) ;
+         nId = pStmCurr_Cone->GetNextTriangle( nId, Tria) ;
+      }
+      vGraphics[s]->EndTriangles() ;
+     // assegno un id temporaneo alla superificie caricata ( modalita wireFrame, come nella Select)
+      vGraphics[s]->Draw( GDB_ST_ON, GDB_MK_OFF, true, true, 80, false) ;
+   }
+
+  // torno a spessore della linee impostato in precedenza
+   glLineWidth((float) GetLineWidth()) ;
+
+   glDisable( GL_DEPTH_TEST) ;
 
   // ripristino lo stack delle matrici
    glPopMatrix() ;
 
    return true ;
 }
+
+

SceneSelect.cpp

@@ -95,6 +95,12 @@ Scene::Select( const Point3d& ptSelCenter, int nW, int nH, int& nSel)
    // non imposto glPolygonMode secondo il tipo di rendering perchè ignorato in selezione
    // disegno le geometrie del DB in una sola passata
    DrawGroup( GDB_ID_ROOT, 1, MdStMkCol( GDB_MD_STD, GDB_ST_ON, GDB_MK_OFF, m_colDef)) ;
+   // disegno il cubetto
+   glEnable( GL_CULL_FACE) ;
+   glCullFace( GL_BACK) ;
+   glFrontFace( GL_CCW) ;
+   DrawGlobCube( false) ;
+   glDisable( GL_CULL_FACE) ;
 
   // pulisco stack nomi
    glPopName() ;
@@ -109,6 +115,10 @@ Scene::Select( const Point3d& ptSelCenter, int nW, int nH, int& nSel)
   // riordino il buffer di selezione secondo la Zdepth minima crescente
    qsort( m_nSelBuff, m_nSelNbr, sizeof( SelRec), CompareSelRec) ;
 
+   // controllo se ho selezionato una superficie sul cubetto
+   if ( RotateCameraWithCube())
+      m_nSelNbr = 0 ;
+
    nSel = m_nSelNbr ;
    return true ;
 }

SceneSnap.cpp

@@ -32,6 +32,7 @@
 #include "/EgtDev/Include/EGkIntersCurves.h"
 #include "/EgtDev/Include/EGkIntersLinePlane.h"
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
+#include "/EgtDev/Include/EGkIntersLineVolZmap.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include <array>
 
@@ -969,7 +970,7 @@ 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
    Vector3d vtWinD( -1, -1, 0) ;
@@ -984,7 +985,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)