EgtExecutor/EXE_Scene.cpp

//----------------------------------------------------------------------------
//  EgalTech 2014-2015
//----------------------------------------------------------------------------
// File : EXE_Scene.cpp       Data : 05.05.15        Versione : 1.6e1
// Contenuto : Funzioni Scene per EXE.
//
//
//
// Modifiche : 01.09.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "EXE.h"
#include "EXE_Macro.h"
#include "DllGraphics.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EgtStringConverter.h"
#include "/EgtDev/Include/EgtPointerOwner.h"

using namespace std ;

//-----------------------------------------------------------------------------
bool
ExeInitScene( HWND hWnd, int nDriver, bool b2Buff, int nColorBits, int nDepthBits)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, false)
  // inizializzazione scena OpenGL
   PtrOwner<IEGrScene> pScene( MyCreateEGrScene()) ;
   VERIFY_NULL( Get( pScene), "Error in CreateEGrScene", false)
   HDC hdc = GetDC( hWnd) ; 
   if ( ! pScene->CreateContext( hdc, nDriver, b2Buff, nColorBits, nDepthBits))
      return false ;
   pScene->SetBackground( WHITE, WHITE) ;
   pScene->SetShowMode( SM_SHADING) ;
   pScene->SetShowCurveDirection( false) ;
   pScene->SetCamera( CT_TOP) ;
   pScene->ZoomAll() ;
   pScene->SetWinRectAttribs( true, BLACK) ;
   pScene->SetMark( YELLOW) ;
   pScene->Init( pGseCtx->m_pGeomDB) ;
  // assegno la scena al contesto
   pGseCtx->m_hWnd = hWnd ;
   pGseCtx->m_pScene = Release( pScene) ;
  // log con info sulla scena
   string sSceneInfo = pGseCtx->m_pScene->GetOpenGLInfo() + '\n' +
                       pGseCtx->m_pScene->GetGLSLInfo() + '\n' +
                       pGseCtx->m_pScene->GetPixelFormatInfo() ;
   LOG_INFO( GetLogger(), sSceneInfo.c_str())

   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeGetSceneInfo( string& sInfo)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // verifico parametro di ritorno
   if ( &sInfo == nullptr)
      return false ;
  // recupero le informazioni sulla scena
   sInfo += pScene->GetOpenGLInfo() ;
   sInfo += "\r\n" ;
   sInfo += pScene->GetGLSLInfo() ;
   sInfo += "\r\n" ;
   sInfo += pScene->GetPixelFormatInfo() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeSetBackground( Color TopCol, Color BottomCol, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto lo sfondo
   pScene->SetBackground( TopCol, BottomCol) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeGetBackground( Color& TopCol, Color& BottomCol)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // recupero lo sfondo
   pScene->GetBackground( TopCol, BottomCol) ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeSetLineAttribs( int nWidth)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto lo spessore delle linee
   return pScene->SetLineWidth( nWidth) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetMarkAttribs( Color MarkCol)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto il colore del Mark
   return pScene->SetMark( MarkCol) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetSelSurfAttribs( Color SelSurfCol)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto il colore del Mark
   return pScene->SetSelSurf( SelSurfCol) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetGeoLineAttribs( Color GlCol)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto il colore della linea geometrica gestita direttamente dalla scena
   return pScene->SetGeoLineAttribs( GlCol) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetGeoTriaAttribs( Color GtCol)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto il colore del triangolo immediato
   return pScene->SetGeoTriaAttribs( GtCol) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetWinRectAttribs( bool bOutline, Color WrCol)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto il colore della linea geometrica gestita direttamente dalla scena
   return pScene->SetWinRectAttribs( bOutline, WrCol) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetGlobFrameShow( bool bShow)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto stato visualizzazione griglia
   return pScene->SetGlobFrameShow( bShow) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetGridShow( bool bShowGrid, bool bShowFrame)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto stato visualizzazione griglia
   return pScene->SetGridShow( bShowGrid, bShowFrame) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetGridGeo( double dSnapStep, int nMinLineSstep, int nMajLineSstep, int nExtSstep)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto i parametri geometrici di griglia
   return pScene->SetGridGeo( dSnapStep, nMinLineSstep, nMajLineSstep, nExtSstep) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetGridColor( Color colMin, Color colMaj)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto i colori di griglia
   return pScene->SetGridColor( colMin, colMaj) ;
}

//-----------------------------------------------------------------------------
bool
ExeResize( int nW, int nH)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // eseguo resize
   pScene->Resize( nW, nH) ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeDraw( void)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_SCENE( pGseCtx, false)
  // se abilitato, eseguo disegno
   if ( ExeGetEnableUI())
      pGseCtx->m_pScene->Draw() ;
  // valido la finestra disegnata
   ValidateRgn( pGseCtx->m_hWnd, NULL) ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeSelect( int nWinX, int nWinY, int nSelW, int nSelH, int* pnSel)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // verifico parametro di ritorno
   if ( pnSel == nullptr)
      return false ;
  // eseguo la selezione
   return pScene->Select( Point3d( nWinX, nWinY), nSelW, nSelH, *pnSel) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetObjFilterForSelWin( bool bZerodim, bool bCurve, bool bSurf, bool bVolume, bool bExtra)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto il filtro
   return pScene->SetObjFilterForSelect( bZerodim, bCurve, bSurf, bVolume, bExtra) ;
}

//-----------------------------------------------------------------------------
bool
ExeUnselectableRemove( int nId)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // tolgo dai non selezionabili
   return pScene->UnselectableRemove( nId) ;
}

//-----------------------------------------------------------------------------
bool
ExeUnselectableAdd( int nId)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // aggiungo ai non selezionabili
   return pScene->UnselectableAdd( nId) ;
}

//-----------------------------------------------------------------------------
bool
ExeUnselectableClearAll( void)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // cancello tutti i non selezionabili
   return pScene->UnselectableClearAll() ;
}

//-----------------------------------------------------------------------------
int
ExeGetFirstObjInSelWin( void)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, GDB_ID_NULL)
  // restituisco il primo oggetto selezionato
   return pScene->GetFirstSelectedObj() ;
}

//-----------------------------------------------------------------------------
int
ExeGetNextObjInSelWin( void)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, GDB_ID_NULL)
  // restituisco il successivo oggetto selezionato
   return pScene->GetNextSelectedObj() ;
}

//-----------------------------------------------------------------------------
bool
ExeGetPointFromSelect( int nSelId, int nWinX, int nWinY, Point3d& ptSel, int* pnAux)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // trovo il punto usato in selezione
   if ( &ptSel == nullptr  ||  pnAux == nullptr)
      return false ;
   return pScene->GetPointFromSelect( nSelId, Point3d( nWinX, nWinY), ptSel, *pnAux) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetGraphicSnapPoint( int nSnap, int nWinX, int nWinY, int nSelW, int nSelH, Point3d& ptP)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // trovo il punto snap da selezione
   if ( &ptP == nullptr)
      return false ;
   return pScene->GetGraphicSnapPoint( nSnap, Point3d( nWinX, nWinY), nSelW, nSelH, ptP) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetGridSnapPointZ( bool bSketch, int nWinX, int nWinY, const Point3d& ptGrid, Point3d& ptP)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // trovo il punto snap da griglia con elevazione in Z
   if ( &ptP == nullptr)
      return false ;
   return pScene->GetGridSnapPointZ( bSketch, Point3d( nWinX, nWinY), ptGrid, ptP) ;
}

//-----------------------------------------------------------------------------
int
ExeGetLastSnapId( void)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, GDB_ID_NULL)
  // restituisco Id di ultima entità generatrice di punto snap
   return pScene->GetLastSnapId() ;
}

//-----------------------------------------------------------------------------
bool
ExeGetLastSnapDir( Vector3d& vtV)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // restituisco, se definita, direzione associata ad ultimo punto di snap
   if ( &vtV == nullptr)
      return false ;
   return pScene->GetLastSnapDir( vtV) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetPlaneSnapPoint( int nWinX, int nWinY, const Plane3d& Plane, Point3d& ptP)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // trovo il punto snap da piano indicato
   if ( &ptP == nullptr)
      return false ;
   return pScene->GetPlaneSnapPoint( Point3d( nWinX, nWinY), Plane, ptP) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetShowMode( int nShowMode, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto il modo di visualizzazione
   if ( nShowMode >= SM_WIREFRAME  &&  nShowMode <= SM_SHADING) {
      pScene->SetShowMode( nShowMode) ;
      if ( bRedraw)
         pScene->RedrawWindow() ;
      return true ;
   }
   else
      return false ;
}

//-----------------------------------------------------------------------------
int
ExeGetShowMode( void)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, SM_WIREFRAME)
  // recupero il modo di visualizzazione
   return pScene->GetShowMode() ;
}

//-----------------------------------------------------------------------------
bool
ExeSetShowCurveDirection( bool bShow, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto stato
   pScene->SetShowCurveDirection( bShow) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeGetShowCurveDirection( void)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // recupero lo stato
   return pScene->GetShowCurveDirection() ;
}

//-----------------------------------------------------------------------------
bool
ExeSetShowTriaAdv( bool bAdvanced, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto stato
   pScene->SetShowTriaAdvanced( bAdvanced) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
bool
ExeGetShowTriaAdv( void)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // recupero lo stato
   return pScene->GetShowTriaAdvanced() ;
}

//-----------------------------------------------------------------------------
bool
ExeSetShowZmap( int nMode, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto stato
   pScene->SetShowZmap( nMode) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
int
ExeGetShowZmap( void)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // recupero lo stato
   return pScene->GetShowZmap() ;
}

//-----------------------------------------------------------------------------
bool
ExeZoomRadius( double dRadius, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // eseguo lo zoom
   pScene->ZoomRadius( dRadius) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeZoom( int nZoom, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)

   const double COEFF_IN = 0.9 ;
   const double COEFF_OUT = 1 / COEFF_IN ;

   switch ( nZoom) {
   case ZM_ALL :
      pScene->ZoomAll() ;
      if ( bRedraw)
         pScene->RedrawWindow() ;
      return true ;
      break ;
   case ZM_IN :
      pScene->ZoomChange( COEFF_IN) ;
      if ( bRedraw)
         pScene->RedrawWindow() ;
      return true ;
      break ;
   case ZM_OUT :
      pScene->ZoomChange( COEFF_OUT) ;
      if ( bRedraw)
         pScene->RedrawWindow() ;
      return true ;
      break ;
   }

   return false ;
}

//-----------------------------------------------------------------------------
bool
ExeZoomObject( int nId, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // eseguo zoom
   bool bOk = pScene->ZoomObject( nId) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeZoomOnPoint( int nWinX, int nWinY, double dCoeff, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // eseguo zoom
   pScene->ZoomOnPoint( Point3d( nWinX, nWinY), dCoeff) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeSetGeoLine( const Point3d& ptP1, const Point3d& ptP2, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // disegno linea per distanza o similari
   pScene->SetGeoLine( ptP1, ptP2) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeResetGeoLine( bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // cancello linea per distanza o similari 
   pScene->ResetGeoLine() ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeSetGeoTria( const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptP3, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // disegno triangolo immediato
   pScene->SetGeoTria( ptP1, ptP2, ptP3) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeResetGeoTria( bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // cancello triangolo immediato
   pScene->ResetGeoTria() ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeSetWinRect( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // disegno finestra per zoom
   pScene->SetWinRect( Point3d( nPrevX, nPrevY), Point3d( nCurrX, nCurrY)) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeResetWinRect( bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // cancello finestra per zoom
   pScene->ResetWinRect() ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeZoomWin( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // eseguo zoom su finestra
   pScene->ZoomWin( Point3d( nPrevX, nPrevY), Point3d( nCurrX, nCurrY)) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeSetView( int nDir, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto vista
   if ( nDir >= CT_TOP  &&  nDir <= CT_CPLANE) {
      pScene->SetCamera( nDir) ;
      if ( bRedraw)
         pScene->RedrawWindow() ;
      return true ;
   }
   else
      return false ;
}

//-----------------------------------------------------------------------------
bool
ExeSetGenericView( double dAngVertDeg, double dAngHorizDeg, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto vista
   pScene->SetCamera( dAngVertDeg, dAngHorizDeg, 0) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeSetViewCenter( const Point3d& ptP, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // imposto vista
   pScene->SetCenter( ptP) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExePanView( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // eseguo panoramica
   pScene->PanCamera( Point3d( nPrevX, nPrevY), Point3d( nCurrX, nCurrY)) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeRotateView( int nPrevX, int nPrevY, int nCurrX, int nCurrY, bool bRedraw)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // eseguo rotazione camera
   pScene->RotateCamera( Point3d( nPrevX, nPrevY), Point3d( nCurrX, nCurrY)) ;
   if ( bRedraw)
      pScene->RedrawWindow() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeGetView( int* pnDir)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // recupero direzione di vista
   if ( pnDir == nullptr)
      return false ;
   *pnDir = pScene->GetCameraDir() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeGetGenericView( double* pdAngVertDeg, double* pdAngHorizDeg)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // recupero direzione di vista
   if ( pdAngVertDeg == nullptr  ||  pdAngHorizDeg == nullptr)
      return false ;
   pScene->GetCamera( pdAngVertDeg, pdAngHorizDeg) ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeGetViewUp( Vector3d& vtUp)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // recupero direzione in alto di vista
   if ( &vtUp == nullptr)
      return false ;
   vtUp = pScene->GetCameraUp() ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
ExeProjectPoint( const Point3d& ptP, Point3d& ptWin)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // eseguo la proiezione
   if ( &ptWin == nullptr)
      return false ;
   Point3d ptView ;
   return pScene->Project( ptP, ptView) ;
}

//-----------------------------------------------------------------------------
bool
ExeUnProjectPoint( int nWinX, int nWinY, Point3d& ptP)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // eseguo l'inverso della proiezione (considero Z punto su centro)
   if ( &ptP == nullptr)
      return false ;
   Point3d ptView( nWinX, nWinY, pScene->GetProjectedCenter().z) ;
   return pScene->UnProject( ptView, ptP) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetTextureMaxLinPixels( int nMaxLinPix)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // lancio il caricamento della texture
   return pScene->SetTextureMaxLinPixels( nMaxLinPix) ;
}

//-----------------------------------------------------------------------------
bool
ExeLoadTexture( const string& sName, const string& sFile,
                double dMMxPix, double dDimX, double dDimY, int nRepeat)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // lancio il caricamento della texture
   return pScene->LoadTexture( sName, sFile, dMMxPix, dDimX, dDimY, nRepeat) ;
}

//-----------------------------------------------------------------------------
bool
ExeUnloadTexture( const string& sName)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // lancio lo scaricamento della texture
   return pScene->UnloadTexture( sName) ;
}

//-----------------------------------------------------------------------------
bool
ExeExistsTexture( const string& sName)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // verifico esistenza della texture
   return pScene->ExistsTexture( sName) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetTexturePixels( const string& sName, int& nWidth, int& nHeight)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // recupero la dimensione in pixels della texture
   return pScene->GetTexturePixels( sName, nWidth, nHeight) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetTextureImagePixels( const string& sName, int& nWidth, int& nHeight)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // recupero la dimensione in pixels della immagine da cui è derivata la texture
   return pScene->GetTextureImagePixels( sName, nWidth, nHeight) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetTextureDimensions( const string& sName, double& dDimX, double& dDimY)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // recupero la dimensione fisica della texture
   return pScene->GetTextureDimensions( sName, dDimX, dDimY) ;
}

//-----------------------------------------------------------------------------
bool
ExeChangeTextureDimensions( const string& sName, double dDimX, double dDimY)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // modifico le dimensioni della texture
   return pScene->ChangeTextureDimensions( sName, dDimX, dDimY) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetImage( int nShowMode, Color colBackTop, Color colBackBottom,
             int nWidth, int nHeight, const string& sFile)
{
   IEGrScene* pScene = GetCurrScene() ;
   VERIFY_SCENE( pScene, false)
  // creo e salvo una immagine della scena
   return pScene->GetImage( nShowMode, colBackTop, colBackBottom, nWidth, nHeight, sFile) ;
}