//----------------------------------------------------------------------------
//  EgalTech 2014-2023
//----------------------------------------------------------------------------
// File : ObjOldGraphics.h           Data : 08.07.23         Versione : 2.5g1
// Contenuto : Dichiarazione della classe grafica di un oggetto geometrico.
//
//
//
// Modifiche : 13.02.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

#pragma once

#include "ObjEGrGraphics.h"
#include "OpenGL.h"
#include "/EgtDev/Include/EGkPoint3d.h"

class Color ;

//----------------------------------------------------------------------------
// Definizione di OgAtom
class OgAtom {
   public :
      OgAtom( void) : m_nType( NONE), m_fX( 0), m_fY( 0), m_fZ( 0), m_fW( 1) {}

   public :
      enum GrType { NONE = 0, START = 1, START_A = 2, END = 3, VERT = 4, BND_FLAG = 5, NORMAL = 6,
                    COLOR = 7, MAT_A = 8, MAT_D = 9, MAT_S = 10, MAT_SH = 11, MAT_B = 12, LINE_STIPPLE = 13} ;

   public :
      GrType m_nType ;
      union {
         int   m_nMode ;
         struct {
            float m_fX ;
            float m_fY ;
            float m_fZ ;
            float m_fW ;
         } ;
         int   m_nFlag ;
         struct {
            float m_fRed ;
            float m_fGreen ;
            float m_fBlue ;
            float m_fAlpha ;
         } ;
         float m_fVal[4] ;
         struct {
            int m_nFactor ;
            int m_nPattern ;
         } ;
      } ;
} ;

//----------------------------------------------------------------------------
// Vettore di OgAtom
typedef std::vector<OgAtom>   OGAVECT ;

//----------------------------------------------------------------------------
class ObjOldGraphics : public ObjEGrGraphics
{
   public :             // IObjGraphics
      ~ObjOldGraphics( void) override ;
      void Reset( void) override ;
      void ResetAll( void) override 
              { Reset() ; }

   public :             // ObjEGrGraphics
      bool IsValid( void) override
              { return m_bValid ; }
      void SetScene( Scene* pScene) override
              { m_pScene = pScene ; }
      Scene* GetScene( void) override
              { return m_pScene ; }
      void Clear( void) override ;
      bool AddColor( const Color& colC) override ;
      bool AddMaterial( const Color& colAmb, const Color& colDiff,
                        const Color& colSpec, float fShin) override ;
      bool AddBackMaterial( const Color& colAmbDiff) override ;
      bool AddLineStipple( int nFactor, int nPattern) override ;
      bool AddPoint( const Point3d& ptP, bool bAux = false) override ;
      bool AddPoints( const PNTVECTOR& vPnt, bool bAux = false) override ;
      bool AddLines( const PNTVECTOR& vPnt, bool bAux = false) override ;
      bool AddPolyLine( const PolyLine& PL, bool bAux = false) override ;
      bool StartTriangles( int nNum, bool bAux = false) override ;
      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() ; }

   public :
      ObjOldGraphics( void) : m_pScene( nullptr), m_bValid( false), m_nCurrMode( GL_NONE) {}

   private :
      bool AddOgAtom( const OgAtom& oga)
              { try { m_ogaVect.push_back( oga) ; }
                catch(...) { return false ; }
                return true ; }
      bool AddOgaStart( int nMode, bool bAux = false)
              { OgAtom oga ;
                oga.m_nType = ( bAux ? OgAtom::START_A : OgAtom::START) ;
                oga.m_nMode = nMode ;
                return AddOgAtom( oga) ; }
      bool AddOgaEnd( void)
              { OgAtom oga ;
                oga.m_nType = OgAtom::END ;
                return AddOgAtom( oga) ; }
      bool AddOgaVert3f( const Point3d& ptP)
              { OgAtom oga ;
                oga.m_nType = OgAtom::VERT ;
                oga.m_fX = float( ptP.x) ; oga.m_fY = float( ptP.y) ; oga.m_fZ = float( ptP.z) ;
                return AddOgAtom( oga) ; }
      bool AddOgaBndFlag( bool bFlag)
              { OgAtom oga ;
                oga.m_nType = OgAtom::BND_FLAG ;
                oga.m_nFlag = ( bFlag ? TRUE : FALSE) ;
                return AddOgAtom( oga) ; }
      bool AddOgaNormal3f( const Vector3d& vtN)
              { OgAtom oga ;
                oga.m_nType = OgAtom::NORMAL ;
                oga.m_fX = float( vtN.x) ; oga.m_fY = float( vtN.y) ; oga.m_fZ = float( vtN.z) ;
                return AddOgAtom( oga) ; }
      bool AddOgaColor( float fRed, float fGreen, float fBlue, float fAlpha = 1)
              { OgAtom oga ;
                oga.m_nType = OgAtom::COLOR ;
                oga.m_fRed = fRed ; oga.m_fGreen = fGreen ; oga.m_fBlue = fBlue ; oga.m_fAlpha = fAlpha ;
                return AddOgAtom( oga) ; }
      bool AddOgaMaterial( OgAtom::GrType nMat, float fRed, float fGreen, float fBlue, float fAlpha = 1)
              { OgAtom nga ;
                nga.m_nType = nMat ;
                nga.m_fRed = fRed ; nga.m_fGreen = fGreen ; nga.m_fBlue = fBlue ; nga.m_fAlpha = fAlpha ;
                return AddOgAtom( nga) ; }
      bool AddOgaLineStipple( int nFactor, int nPattern)
              { OgAtom oga ;
                oga.m_nType = OgAtom::LINE_STIPPLE ;
                oga.m_nFactor = nFactor ;
                oga.m_nPattern = nPattern ;
                return AddOgAtom( oga) ; }

   private :
      Scene*  m_pScene ;           // puntatore alla scena
      bool    m_bValid ;           // flag
      int     m_nCurrMode ;        // modo corrente
      OGAVECT m_ogaVect ;          // vettore di atomi per vecchia grafica
      BBox3d  m_b3Loc ;            // BoundingBox locale
} ;

//----------------------------------------------------------------------------
inline const ObjOldGraphics* GetObjOldGraphics( const IGeoObj* pGObj)
               { return (dynamic_cast<const ObjOldGraphics*>(pGObj->GetObjGraphics())) ; }
inline ObjOldGraphics* GetObjOldGraphics( IGeoObj* pGObj)
               { return (dynamic_cast<ObjOldGraphics*>(pGObj->GetObjGraphics())) ; }