Egalware/EgtGraphics
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
Cube
EgtGraphics/SceneGlobFrame.cpp
T
Riccardo Elitropi 147964cf6a EgtGraphics : 
- Cubetto
- Assi
- Griglia
- Zoom.
2023-06-01 13:03:24 +02:00

308 lines
10 KiB
C++
Raw Permalink Blame History

//----------------------------------------------------------------------------
// EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : SceneGlobFrame.cpp Data : 02.12.14 Versione : 1.5l1
// Contenuto : Implementazione gestione e disegno terna di riferimento globale.
//
//
//
// Modifiche : 02.12.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#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)
{
m_bShowGlobFrame = 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)
{
// se non devo disegnare, esco subito
if ( ! m_bShowGlobFrame)
return true ;
// recupero la matrice viewport
GLint Viewport[ 4] ;
glGetIntegerv( GL_VIEWPORT, Viewport) ;
// imposto il riferimento
glPushMatrix() ;
// imposto l'origine del sistema di riferimento nelle coordinate della ViewPort
Point3d ptOrig ;
const double POS_Z = 0.25 ;
UnProject( Point3d( m_dFrame_DistX, m_dFrame_DistY, POS_Z), ptOrig) ;
// abilito Ztest per rendering delle linee e dei punti
glEnable( GL_DEPTH_TEST) ;
// 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) ;
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)) ;
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)) ;
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) ;
// 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 ;
}
Reference in New Issue View Git Blame Copy Permalink