EgtGraphics/Scene.h

//----------------------------------------------------------------------------
//  EgalTech 2013-2014
//----------------------------------------------------------------------------
// File : Scene.h           Data : 03.02.14           Versione : 1.5b1
// Contenuto : Dichiarazione della classe gestione scena.
//
//
//
// Modifiche : 29.01.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

#pragma once

//----------------------------------------------------------------------------
#include "/EgtDev/Include/EGrScene.h"
#include "OpenGL.h"

class IGdbIterator ;

//----------------------------------------------------------------------------
class MdStMk
{
   public :
      MdStMk( int nMd, int nSt, int nMk) : nMode( nMd), nStat( nSt), nMark( nMk) {}

   public :
      int nMode ;
      int nStat ;
      int nMark ;
} ;

//----------------------------------------------------------------------------
struct SelRec {            // record di selezione per OpenGL (buffer di GLuint)
   GLuint nLen ;           // numero di Id sullo stack dei nomi al momento del disegno (sempre 1)
   GLuint nZmin ;          // Zdepth minima
   GLuint nZmax ;          // Zdepth massima
   GLuint nId ;            // nome dell'oggetto
} ;


//----------------------------------------------------------------------------
class Scene : public IEGrScene
{
   public :
     // Basic
      virtual ~Scene( void) ;
      virtual bool Init( IGeomDB* pGeomDB) ;
      virtual bool CreateContext( HDC hDC, int nDriver, bool b2Buff, int nColorBits, int nDepthBits) ;
      virtual bool IsValid( void)
                      { return ( m_hDC != nullptr  &&  m_hRC != nullptr) ; }
      virtual std::string GetOpenGLInfo( void) ;
      virtual std::string GetGLSLInfo( void) ;
      virtual std::string GetPixelFormatInfo( void) ;
      virtual IGeomDB* GetGeomDB( void)
                      { return m_pGeomDB ; }
      virtual bool RedrawWindow( void) ;
      virtual bool Resize( int nW, int nH) ;
      virtual bool SetBackground( Color colBackTop, Color colBackBottom) ;
      virtual bool Draw( void) ;
      virtual bool Select( const Point3d& ptView, int nW, int nH, int& nSel) ;
      virtual bool GetSelectedObjs( INTVECTOR& nIds) ;
      virtual int  GetFirstSelectedObj( void) ;
      virtual int  GetNextSelectedObj( void) ;
      virtual double GetSelectedObjWinZ( int nSel = - 1) ;
      virtual bool Project( const Point3d& ptWorld, Point3d& ptView) ;
      virtual bool UnProject( const Point3d& ptView, Point3d& ptWorld) ;
      virtual void Destroy( void) ;
     // Camera
      virtual bool SetCenter( const Point3d& ptCenter) ;
      virtual bool SetCamera( double dAngVertDeg, double dAngOrizzDeg, double dDist) ;
      virtual bool SetCamera( int nDir, double dDist = 0) ;
      virtual const Point3d& GetCenter( void)
                        { return m_ptCenter ; }
      virtual Point3d GetProjectedCenter( void) ;
      virtual void GetCamera( double* pdAngVertDeg, double* pdAngOrizzDeg, double* pdDist = nullptr) ;
      virtual int  GetCameraDir( void) ;
      virtual bool PanCamera( const Point3d& ptWinOld, const Point3d& ptWinNew) ;
      virtual bool RotateCamera( const Point3d& ptWinOld, const Point3d& ptWinNew) ;
      virtual bool ZoomAll( void) ;
      virtual bool ZoomChange( double dCoeff) ;
      virtual bool ZoomOnPoint( const Point3d& ptWin, double dCoeff) ;
      virtual bool ZoomWin( const Point3d& ptWin1, const Point3d& ptWin2) ;
     // ShowMode
      virtual bool SetShowMode( int nShowMode)
                        { if ( nShowMode != SM_WIREFRAME  &&
                               nShowMode != SM_HIDDENLINE  &&
                               nShowMode != SM_SHADING)
                             return false ;
                           m_nShowMode = nShowMode ;
                           return true ; }
      virtual int  GetShowMode( void)
                        { return m_nShowMode ;}
      virtual void SetShowCurveDirection( bool bShow)
                        { m_bShowCurveDirection = bShow ; }
      virtual bool GetShowCurveDirection( void)
                        { return m_bShowCurveDirection ; }
     // Geometry
      virtual bool SetExtension( const BBox3d& b3Ext) ;
      virtual bool UpdateExtension( void) ;
      virtual bool SetMark( Color colMark) ;
     // Direct
      virtual bool SetGeoLineAttribs( Color GLcol) ;
      virtual bool SetGeoLine( const Point3d& ptP1, const Point3d& ptP2) ;
      virtual bool ResetGeoLine( void) ;
      virtual bool SetWinRectAttribs( bool bOutline, Color WRcol) ;
      virtual bool SetWinRect( const Point3d& ptWinRectP1, const Point3d& ptWinRectP2) ;
      virtual bool ResetWinRect( void) ;
     // Snap
      virtual bool GetSelectedSnapPoint( int nSnap, const Point3d& ptWin, int nW, int nH, Point3d& ptSel) ;

   public :
     // Basic
      Scene( void) ;
      bool MakeCurrent( void) ;
      GLEWContext* glewGetContext( void)
                      { return &m_glewc ; }
     // Geometry
      Color GetMark( void)
               { return m_colMark ; }

   private :
     // Basic
      int ChooseGenPixelFormat( int nPfd, bool b2Buff, int nColorBits, int nDepthBits) ;
      WGLEWContext* wglewGetContext( void)
                      { return &m_wglewc ; }
      bool CalcExtView( void) ;
      bool CalcDimViewFromExtView( void) ;
      bool AdjustDimView( double dHalfWidth, double dHalfHeight) ;
      bool CalcClippingPlanesFromExtView( void) ;
      bool Background( void) ;
      bool Prepare( void) ;
     // Camera
      bool VerifyCamera( void) ;
      bool CalcDirUp( void) ;
      bool CalcCameraFrame( Frame3d& frView) ;
     // Geometry
      bool DrawGroup( int nId, int nPass, MdStMk siParent) ;
      bool DrawGroup( const IGdbIterator& iIter, int nPass, MdStMk siParent) ;
      bool DrawGeoObj( const IGdbIterator& iIter, int nPass, MdStMk siObj) ;
      bool DeleteObjGraphicsGroup( int nId) ;
     // Direct
      bool DrawDirect( void) ;
      bool DrawGeoLine( void) ;
      bool DrawWinRect( void) ;
     // Snap
      bool VerifySnapPoint( const Point3d& ptP, const Point3d& ptWin, double& dMinSqDist) ;


   private :
      HDC          m_hDC ;                // Device Context
      HGLRC        m_hRC ;                // OpenGL Rendering Context 
      WGLEWContext m_wglewc ;             // WGLEW Context
      GLEWContext  m_glewc ;              // GLEW Context
      bool         m_bNewWay ;            // flag che indica nuova modalità (OpenGL 3.0 in poi)

      Point3d  m_ptCenter ;               // centro verso cui è rivolta la camera
      Vector3d m_vtDirCamera ;            // versore direzione dal centro alla camera
      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
      int      m_nViewportW ;             // larghezza della finestra
      int      m_nViewportH ;             // altezza della finestra

      Color    m_colBackTop ;             // colore di sfondo in alto
      Color    m_colBackBottom ;          // colore di sfondo in basso

      int      m_nShowMode ;              // modo di visualizzazione (wireframe, hiddenline, shading)
      bool     m_bShowCurveDirection ;    // flag di visualizzazione direzione curve

      bool     m_bSelect ;                // flag di selezione attiva
      Point3d  m_ptSelCent ;              // centro di selezione
      int      m_nSelW ;                  // larghezza finestra di selezione
      int      m_nSelH ;                  // altezza finestra di selezione
      int      m_nSelNbr ;                // numero di selezioni registrate
      int      m_nSelCurr ;               // indice oggetto selezionato corrente
      static const int DIM_SEL_BUF = 4096 ;
      SelRec   m_nSelBuff[DIM_SEL_BUF] ;  // buffer per selezione con OpenGL

      IGeomDB* m_pGeomDB ;                // puntatore al DB geometrico
      Color    m_colDef ;                 // colore di default
      Color    m_colMark ;                // colore per marcatura

      BBox3d m_b3ExtWorld ;               // estensione della geometria nel riferimento globale (mondo)
      BBox3d m_b3ExtView ;                // estensione nel riferimento di vista
      bool   m_bExtViewOk ;               // flag per stato aggiornamento di EView
      double m_dHalfWidth ;               // semialtezza della vista
      double m_dHalfHeight ;              // semilarghezza della vista
      double m_dZNear ;                   // distanza del piano di clipping vicino
      double m_dZFar ;                    // distanza del piano di clipping lontano

      Color   m_colorGL ;                 // colore per GeoLine
      bool    m_bGeoLine ;                // flag esistenza linea diretta in finestra
      Point3d m_ptGeoLineP1 ;             // primo estremo della linea diretta
      Point3d m_ptGeoLineP2 ;             // secondo estremo della linea diretta
      bool    m_bOutlineWR ;              // flag per disegno WinRect con solo contorno o pieno
      Color   m_colorWR ;                 // colore per WinRect
      bool    m_bWinRect ;                // flag esistenza rettangolo diretto in finestra
      Point3d m_ptWinRectP1 ;             // primo estremo del rettangolo diretto
      Point3d m_ptWinRectP2 ;             // secondo estremo del rettangolo diretto
} ;