diff --git a/ObjMultiGraphics.cpp b/ObjMultiGraphics.cpp index 4b18894..b1f3584 100644 --- a/ObjMultiGraphics.cpp +++ b/ObjMultiGraphics.cpp @@ -13,6 +13,7 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" +#include "/EgtDev/Include/EGkColor.h" #include "ObjMultiGraphics.h" #include "ObjNewGraphics.h" #include "ObjOldGraphics.h" diff --git a/ObjNewGraphics.h b/ObjNewGraphics.h index 74f267c..1023c1b 100644 --- a/ObjNewGraphics.h +++ b/ObjNewGraphics.h @@ -78,6 +78,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() ; } diff --git a/ObjOldGraphics.h b/ObjOldGraphics.h index 3d99e4f..ef23c8e 100644 --- a/ObjOldGraphics.h +++ b/ObjOldGraphics.h @@ -83,6 +83,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() ; } diff --git a/Scene.h b/Scene.h index d677ec8..9db9134 100644 --- a/Scene.h +++ b/Scene.h @@ -107,6 +107,9 @@ class Scene : public IEGrScene 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 @@ -134,6 +137,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 ; @@ -146,11 +155,18 @@ class Scene : public IEGrScene bool SetGridColor( Color colMinLine, Color colMajLine) override ; void GetGridParam( double& dSnapStep, int& nExtStep) const override ; bool GetShowGrid() override ; - // Glob Frame + bool SetGlobGridParameters( int nPosFlag, double dLenX, double dLenY) override ; + // Axis Frame bool SetGlobFrameShow( bool bShow) override ; + bool SetGlobFrameParameters( int nPosFlag, double dDistX, double dDistY, + double dLenLine, double dWidthLine) override ; // Glob Cube - bool SetGlobCubeShow( bool bShow) override ; - bool SetGlobCubeParameters( double dposX, double dPosY, double dEdge) override ; + 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 ; @@ -200,8 +216,6 @@ class Scene : public IEGrScene // Image bool GetImage( int nShowMode, Color colBackTop, Color colBackBottom, int nDestWidth, int nDestHeight, const std::string& sFile) override ; - // Cube - bool GetAngleByCubeFace(int nFaceId, double& dTheta, double& dPhi) ; public : // Basic @@ -259,10 +273,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( void) ; + // Glob Cube + bool DrawGlobCube( bool bSurf) ; // Direct bool DrawDirect( void) ; bool DrawGeoLine( void) ; @@ -294,9 +309,18 @@ 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 double m_dDistCamera ; // distanza dal centro alla camera Vector3d m_vtUp ; // versore direzione Su della camera @@ -312,7 +336,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 @@ -339,7 +363,7 @@ class Scene : public IEGrScene // 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 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,18 +387,28 @@ class Scene : public IEGrScene int m_nMinLineSstep ; // interasse tra due linee minori come numero di passi di snap int m_nMajLineSstep ; // interasse tra due linee maggiori come numero di passi di snap int m_nExtSstep ; // estensione della griglia come numero di passi di snap + double m_dGridWidth ; // lunghezza della griglia rettangolare + double m_dGridHeight ; // altezza della griglia rettangolare + int m_nGridFrame_Flag ; // posizione dell'origine con gli assi sulla 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 + 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 ; // centro X del cubo sullo schermo - double m_dCubeY ; // centro Y del cubo sullo schermo + 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 + // Direct Color m_colorGL ; // colore per GeoLine bool m_bGeoLine ; // flag esistenza linea diretta in finestra Point3d m_ptGeoLineP1 ; // primo estremo della linea diretta diff --git a/SceneBasic.cpp b/SceneBasic.cpp index ae2bc49..ffdc3ab 100644 --- a/SceneBasic.cpp +++ b/SceneBasic.cpp @@ -54,6 +54,15 @@ 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 ; SetCamera( 0, 0, 0) ; @@ -98,16 +107,30 @@ Scene::Scene( void) SetExtension( BBox3d( -MIN_EXTENSION, -MIN_EXTENSION, -MIN_EXTENSION, MIN_EXTENSION, MIN_EXTENSION, MIN_EXTENSION)) ; // Grid - m_bShowGrid = false ; - m_bShowFrame = false ; - m_dSnapStep = 1 ; + m_bShowGrid = false ; + m_bShowFrame = false ; + m_dSnapStep = 1 ; m_nMinLineSstep = 10 ; m_nMajLineSstep = 100 ; - m_nExtSstep = 500 ; - m_colMinLine.Set( 160, 160, 160) ; - m_colMajLine.Set( 160, 160, 160) ; - // Global Frame - m_bShowGlobFrame = false ; + m_nExtSstep = 500 ; + m_colMinLine.Set( 160, 160, 160) ; + m_colMajLine.Set( 160, 160, 160) ; + m_dGridWidth = 1000 ; + m_dGridHeight = 1000 ; + m_nGridFrame_Flag = 1 ; + // Axis Frame + m_bShowGlobFrame = true ; + m_nAxisFrame_Flag = 3 ; + m_dFrame_DistX = 40.0 ; + m_dFrame_DistY = 120.0 ; + m_dFrameLineL = 25.0; + m_dFrameLineW = 2.0 ; + // Global Cube + m_bShowGlobCube = true ; + m_nCube_Flag = 1 ; + m_dCubeEdge = 55.0 ; + m_dCubeX = 40.0 ; + m_dCubeY = 40.0 ; // Direct m_colorGL.Set( 255, 0, 0) ; m_bGeoLine = false ; @@ -514,6 +537,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 ; } @@ -834,15 +858,28 @@ Scene::MyDraw( bool bSwapBF) // disegno riferimento globale DrawGlobFrame() ; - - // disegno il cubetto - DrawGlobCube(); - // aggiungo disegni diretti (con poligoni riempiti) 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() ; diff --git a/SceneCamera.cpp b/SceneCamera.cpp index f61df93..0b2b0e8 100644 --- a/SceneCamera.cpp +++ b/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) @@ -362,7 +367,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 ; @@ -373,6 +377,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 ; diff --git a/SceneGlobCube.cpp b/SceneGlobCube.cpp index 008de13..b13bc15 100644 --- a/SceneGlobCube.cpp +++ b/SceneGlobCube.cpp @@ -15,712 +15,756 @@ #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::SetGlobCubeShow( bool bShow) +Scene::CreateFlatPart( ISurfTriMesh* pSrf) { - m_bShowGlobCube = bShow ; - return true ; + + // 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::DrawGlobCube(void) +Scene::CreateEdgePart( ISurfTriMesh* pSrf) { - // se non devo disegnare, esco subito - if ( ! m_bShowGlobCube) - return true; + // 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) ; - // recupero il primo Id libero e aggiungo 1000 - m_nStartFaceId = m_pGeomDB->GetNewId() + 1000 ; + // verifico + pSrf->DoCompacting() ; - // recupero la matrice viewport - GLint Viewport[4] ; - glGetIntegerv( GL_VIEWPORT, Viewport) ; - - - // imposto il centro del cubo e la lunghezza del lato (m_dCubeX, m_dCubeY, m_dCubeEdge) <------------------ - if ( ! SetGlobCubeParameters( Viewport[2] - 50, 50, 50)) - return false ; - - // 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 ; - } - - const double HALF_LEN_EDGE = float( m_dCubeEdge / 2) ; - - // dimensioni facce FRONT, BACK, TOP, BOTTON, LEFT, RIGHT - const double PRIMARY_LEN_EDGE = float( m_dCubeEdge / 2) ; // dimensione lunghezza surf da 2 touches - const double PRIMAL_HALF_LEN_EDGE = PRIMARY_LEN_EDGE / 2 ; // dimensione altezza surf da 2 touches - - // imposto la lunghezza/2 del lato a seconda dello zoom - double d_main_HLen = PRIMAL_HALF_LEN_EDGE * ( 2 * m_dHalfWidth) / Viewport[2]; - - // dimensioni parti 2-clicks - const double SECONDARY_LEN_EDGE = float( m_dCubeEdge / 4) ; // dimensione lato degli otto cubetti sugli spigoli - const double SECONDARY_HALF_LEN_EDGE = SECONDARY_LEN_EDGE / 2 ; - - // imposto la lunghezza/2 del lato più lungo della superficie e 2 touches a seconda dello zoom - double d_second_Hlen = SECONDARY_HALF_LEN_EDGE * ( 2 * m_dHalfWidth) / Viewport[2] ; - - // facce ------------------------------------------------------------------------------------------------- - glEnable( GL_DEPTH_TEST) ; - glPolygonMode( GL_FRONT_AND_BACK, GL_FILL) ; - - - // disegno faccia TOP del cubo --> +Z - if ( m_bSelect) - glLoadName( m_nStartFaceId + 1) ; - glColor3d( 0, 0, 1) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - // disegno faccia BOTTOM del cubo --> -Z - if (m_bSelect) - glLoadName( m_nStartFaceId + 2) ; - glColor3d( 0, 0.5, 0.7) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - // disegno faccia RIGHT del cubo --> X - if ( m_bSelect) - glLoadName( m_nStartFaceId + 3) ; - glColor3d( 1, 0, 0); - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glEnd(); - if ( m_bSelect) - glLoadName( m_nStartFaceId + 4) ; - // disegno faccia LEFT del cubo --> -X - glColor3d( 0.5, 0.1, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glEnd() ; - if ( m_bSelect) - glLoadName( m_nStartFaceId + 5) ; - // disegno faccia BACK del cubo --> +Y - glColor3d( 0, 1, 0); - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glEnd(); - if ( m_bSelect) - glLoadName( m_nStartFaceId + 6) ; - // disegno faccia FRONT del cubo --> -Y - glColor3d( 0.3, 0.8, 0.5) ; - glBegin(GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glEnd() ; - // disegno faccia TOP-RIGHT del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 7) ; - glColor3d( 0.8, 0, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - glColor3d( 0, 0, 0.8) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen), float(ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - // disegno faccia TOP-LEFT del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 8) ; - glColor3d( 0.3, 0, 0); - glBegin( GL_POLYGON); - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - glColor3d( 0, 0, 0.8) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - // disegno faccia BOTTOM-RIGHT del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 9) ; - glColor3d( 0.8, 0, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - glColor3d( 0, 0.3, 0.5) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - // disegno faccia BOTTOM-LEFT del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 10) ; - glColor3d(0.3, 0, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - glColor3d( 0, 0.3, 0.5) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - // disegno faccia TOP-BACK del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 11) ; - glColor3d( 0, 0.8, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float(ptOrig.y + d_main_HLen + d_second_Hlen), float(ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float(ptOrig.y + d_main_HLen + d_second_Hlen), float(ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float(ptOrig.y + d_main_HLen + d_second_Hlen), float(ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float(ptOrig.y + d_main_HLen + d_second_Hlen), float(ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - glColor3d( 0, 0, 0.8) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float(ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float(ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float(ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float(ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - // disegno faccia TOP-FRONT del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 12) ; - glColor3d( 0.1, 0.6, 0.3) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - glColor3d( 0, 0, 0.8) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - // disegno faccia BOTTOM-BACK del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 13) ; - glColor3d( 0, 0.8, 0) ; - glBegin( GL_POLYGON); - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - glColor3d( 0, 0.3, 0.5) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - // disegno faccia BOTTOM-FRONT del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 14) ; - glColor3d( 0.1, 0.6, 0.3) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float(ptOrig.y - d_main_HLen - d_second_Hlen), float(ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float(ptOrig.y - d_main_HLen - d_second_Hlen), float(ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float(ptOrig.y - d_main_HLen - d_second_Hlen), float(ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float(ptOrig.y - d_main_HLen - d_second_Hlen), float(ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - glColor3d( 0, 0.3, 0.5) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - // disegno faccia RIGHT-BACK del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 15) ; - glColor3d( 0.8 , 0, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glEnd() ; - glColor3d( 0, 0.8, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glEnd() ; - // disegno faccia LEFT-BACK del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 16) ; - glColor3d( 0.3, 0, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glEnd() ; - glColor3d( 0, 0.8, 0) ; - glBegin( GL_POLYGON); - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glEnd() ; - // disegno faccia FRONT-RIGHT del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 17) ; - glColor3d( 0.8, 0, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glEnd() ; - glColor3d( 0.1, 0.6, 0.3) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glEnd() ; - // disegno faccia FRONT-LEFT del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 18) ; - glColor3d( 0.3, 0, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glEnd() ; - glColor3d( 0.1, 0.6, 0.3) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glEnd() ; - // disegno faccia TOP-RIGHT-BACK del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 19); - glColor3d( 0, 0, 1) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - glColor3d( 1, 0, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - glColor3d( 0, 1, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - // disegno faccia TOP-LEFT-BACK del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 20) ; - glColor3d( 0, 0, 1) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - glColor3d( 0.5, 0.1, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - glColor3d( 0, 1, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - // disegno faccia TOP-RIGHT-FRONT del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 21) ; - glColor3d( 0, 0, 1) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - glColor3d( 1, 0, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - glColor3d( 0.3, 0.8, 0.5) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - // disegno faccia TOP-LEFT-FRONT del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 22) ; - glColor3d( 0, 0, 1) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - glColor3d( 0.5, 0.1, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - glColor3d( 0.3, 0.8, 0.5) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z + d_main_HLen + d_second_Hlen)) ; - glEnd() ; - // disegno faccia BOTTOM-RIGHT-BACK del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 23) ; - glColor3d( 0, 0.5, 0.7) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - glColor3d( 1, 0, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd(); - glColor3d( 0, 1, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - // disegno faccia BOTTOM-LEFT-BACK del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 24) ; - glColor3d( 0, 0.5, 0.7) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - glColor3d( 0.5, 0.1, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - glColor3d( 0, 1, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y + d_main_HLen + d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - // disegno faccia BOTTOM-RIGHT-BACK del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 25) ; - glColor3d( 0, 0.5, 0.7) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - glColor3d( 1, 0, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - glColor3d( 0.3, 0.8, 0.5) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen + d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float(ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x + d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float(ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - // disegno faccia BOTTOM-LEFT-FRONT del cubo - if ( m_bSelect) - glLoadName( m_nStartFaceId + 26) ; - glColor3d( 0, 0.5, 0.7) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd(); - glColor3d( 0.5, 0.1, 0) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - glColor3d( 0.3, 0.8, 0.5) ; - glBegin( GL_POLYGON) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen - d_second_Hlen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen)) ; - glVertex3f( float( ptOrig.x - d_main_HLen), float( ptOrig.y - d_main_HLen - d_second_Hlen), float( ptOrig.z - d_main_HLen - d_second_Hlen)) ; - glEnd() ; - - if (m_bSelect) - glLoadName( 0) ; - - // ripristino lo stack delle matrici - glPopMatrix() ; - return true ; + return true ; } - //---------------------------------------------------------------------------- bool -Scene::RotateCameraWithCube() -{ - // controllo se il cubetto è abilitato - if (! m_bShowGlobCube) - return false ; - - // controllo se ho almeno un Id dalla selezione nel buffer - if ( m_nSelNbr == 0) - return false ; - - int nId = m_nSelBuff[0].nId ; - // controllo che l'Id appartenga ad una superificie del cubetto - if ( nId <= m_nStartFaceId || nId >= m_nStartFaceId + 27) - return false ; - - // prendo i parametri della telecamera - double dTheta, dPhi, dDist ; - GetCamera( &dPhi, &dTheta, &dDist) ; - - // ottengo la faccia del cubo selezionato (valore tra 1 e 26) - int nCubeface = nId - m_nStartFaceId ; - - // imposto i nuovi angoli theta e phi mantenendo la distanza - if ( GetAngleByCubeFace( nCubeface, dTheta, dPhi)) - SetCamera( dPhi, dTheta, dDist) ; - - m_nSelNbr = 0 ; - RedrawWindow() ; - - return true ; -} - -//---------------------------------------------------------------------------- -bool -Scene::GetAngleByCubeFace( int nFaceId, double &dTheta, double &dPhi) +Scene::CreateCornerPart( ISurfTriMesh* pSrf) { - 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 : // BACK - dPhi = 90 ; - dTheta = 90; - break ; - case 6 : // FRONT - 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-BACK - dPhi = 45 ; - dTheta = 90 ; - break ; - case 12 : // TOP-FRONT - dPhi = 45 ; - dTheta = 270 ; - break ; - case 13 : // BOTTOM-BACK - dPhi = 225 ; - dTheta = 270 ; - break ; - case 14 : // BOTTOM-FRONT - dPhi = 225 ; - dTheta = 90 ; - break ; - case 15 : // RIGHT-BACK - dPhi = 90 ; - dTheta = 45 ; - break ; - case 16 : // LEFT-BACK - dPhi = 90 ; - dTheta = 135 ; - break ; - case 17 : // FRONT-RIGHT - dPhi = 90 ; - dTheta = 315 ; - break; - case 18 : // FRONT-LEFT - dPhi = 90; - dTheta = 225 ; - break ; - case 19 : // TOP-RIGHT-BACK - dPhi = 45 ; - dTheta = 45 ; - break ; - case 20 : // TOP-LEFT-BACK - dPhi = 45 ; - dTheta = 135 ; - break ; - case 21 : // TOP-RIGHT-FRONT - dPhi = 45 ; - dTheta = 315 ; - break; - case 22 : // TOP-LEFT-FRONT - dPhi = 45 ; - dTheta = 225 ; - break; - case 23 : // BOTTOM-RIGHT-BACK - 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-FRONT - dPhi = 135; - dTheta = 215 ; - break ; - default : - break ; - } - return true; + // 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 ; } //---------------------------------------------------------------------------- -bool -Scene::SetGlobCubeParameters( double dposX, double dPosY, double dEdge) -{ +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) ; - // controllo che il cubo stia nella Viewport verticale - if (dposX <= sqrt(3) * m_dCubeEdge / 2 * sqrt(2) / 2 + 3 || dposX >= Viewport[2] - sqrt(3) * m_dCubeEdge / 2 * sqrt(2) / 2 - 3) + // se il vettore delle superifici è vuoto, allora lo creo + if ( m_vStm_Cube.empty()) { + // Z+ -> 1 -> TOP + PtrOwner 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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> vGraphics ; + for ( int i = 0 ; i < 26 ; ++ i) { + PtrOwner 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 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 ; - // controllo che il cubo stia nella Viewport orizzontale - if ( dPosY <= Viewport[1] + sqrt(3) * m_dCubeEdge / 2 * sqrt(2) / 2 + 3 || dPosY >= Viewport[3] - sqrt(3) * m_dCubeEdge / 2 * sqrt(2) / 2 - 3) + // 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 ; - // controllo il raggio del cubo - if ( dEdge < 20) + // 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 = dposX ; - m_dCubeY = dPosY ; - m_dCubeEdge = dEdge ; + m_dCubeX = dCoordX ; + m_dCubeY = dCoordY ; + m_dCubeEdge = dLenEdge ; + return true ; } + + diff --git a/SceneGlobFrame.cpp b/SceneGlobFrame.cpp index 8bef1c6..2ea6d46 100644 --- a/SceneGlobFrame.cpp +++ b/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 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 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 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> vGraphics ; + for ( int i = 0 ; i < 3 ; ++ i) { + PtrOwner 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 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 ; } + + diff --git a/SceneGrid.cpp b/SceneGrid.cpp index afa901f..39847b7 100644 --- a/SceneGrid.cpp +++ b/SceneGrid.cpp @@ -20,6 +20,11 @@ using namespace std ; +// costanti parametri per la griglia +const double GRID_MIN_LEN_X = 10 ; +const double GRID_MIN_LEN_Y = 10 ; +const double GRID_AXIS_WIDTH = 1 ; + //---------------------------------------------------------------------------- bool Scene::SetGridShow( bool bShowGrid, bool bShowFrame) @@ -74,12 +79,16 @@ GetSpecialCoeff( double dVal) bool Scene::DrawGrid( void) { + // se richista griglia avanzata ... + if ( m_nGridFrame_Flag != 1) + return DrawRectangularGrid() ; + // se non devo disegnare, esco subito if ( ! m_bShowGrid && ! m_bShowFrame) return true ; // spessore linee - glLineWidth( (float) GetGridLineWidth()) ; + glLineWidth(( float) GetGridLineWidth()) ; // imposto il riferimento glPushMatrix() ; @@ -105,16 +114,16 @@ Scene::DrawGrid( void) // se non si sovrappongono alle maggiori if ( ( i % m_nMajLineSstep) != 0) { float dPos = float( i * m_dSnapStep) ; - // X + + // X + glVertex3f( dPos, - dExt, Z_DOWN) ; glVertex3f( dPos, dExt, Z_DOWN) ; - // X - + // X - glVertex3f( - dPos, - dExt, Z_DOWN) ; glVertex3f( - dPos, dExt, Z_DOWN) ; - // Y + + // Y + glVertex3f( - dExt, dPos, Z_DOWN) ; glVertex3f( dExt, dPos, Z_DOWN) ; - // Y - + // Y - glVertex3f( - dExt, - dPos, Z_DOWN) ; glVertex3f( dExt, - dPos, Z_DOWN) ; } @@ -129,16 +138,16 @@ Scene::DrawGrid( void) glColor3f( m_colMajLine.GetRed(), m_colMajLine.GetGreen(), m_colMajLine.GetBlue()) ; for ( int i = min( nCoeff * m_nMajLineSstep, m_nExtSstep) ; i <= m_nExtSstep ; i += nCoeff * m_nMajLineSstep) { float dPos = float( i * m_dSnapStep) ; - // X + + // X + glVertex3f( dPos, - dExt, Z_DOWN) ; glVertex3f( dPos, dExt, Z_DOWN) ; - // X - + // X - glVertex3f( - dPos, - dExt, Z_DOWN) ; glVertex3f( - dPos, dExt, Z_DOWN) ; - // Y + + // Y + glVertex3f( - dExt, dPos, Z_DOWN) ; glVertex3f( dExt, dPos, Z_DOWN) ; - // Y - + // Y - glVertex3f( - dExt, - dPos, Z_DOWN) ; glVertex3f( dExt, - dPos, Z_DOWN) ; } @@ -147,26 +156,26 @@ Scene::DrawGrid( void) // se richiesto, disegno assi del frame if ( m_bShowFrame) { - // calcolo lunghezza asse Z + // calcolo lunghezza asse Z GLint Viewport[4] ; - glGetIntegerv(GL_VIEWPORT, Viewport) ; + glGetIntegerv( GL_VIEWPORT, Viewport) ; const double LEN_AX = 28 ; double dLenZ = LEN_AX * ( 2 * m_dHalfWidth) / Viewport[2] ; float fLenZ = float( min( m_dSnapStep, dLenZ)) ; glBegin( GL_LINES) ; - // asse X+ - glColor3f( 0.8f, 0, 0) ; + // asse X+ + glColor3f( m_cColX.GetRed(), m_cColX.GetGreen(), m_cColX.GetBlue()) ; glVertex3f( 0, 0, Z_DOWN) ; glVertex3f( dExt, 0, Z_DOWN) ; - // asse Y+ - glColor3f( 0, 0.8f, 0) ; + // asse Y+ + glColor3f( m_cColY.GetRed(), m_cColY.GetGreen(), m_cColY.GetBlue()) ; glVertex3f( 0, 0, Z_DOWN) ; glVertex3f( 0, dExt, Z_DOWN) ; - // asse Z+ - glColor3f( 0, 0, 0.8f) ; + // asse Z+ + glColor3f( m_cColZ.GetRed(), m_cColZ.GetGreen(), m_cColZ.GetBlue()) ; glVertex3f( 0, 0, Z_DOWN) ; glVertex3f( 0, 0, fLenZ) ; - // se richiesta griglia, assi X- e Y- + // se richiesta griglia, assi X- e Y- if ( m_bShowGrid) { glColor3f( m_colMajLine.GetRed(), m_colMajLine.GetGreen(), m_colMajLine.GetBlue()) ; glVertex3f( 0, 0, Z_DOWN) ; @@ -180,10 +189,10 @@ Scene::DrawGrid( void) else if ( m_bShowGrid) { glBegin( GL_LINES) ; glColor3f( m_colMajLine.GetRed(), m_colMajLine.GetGreen(), m_colMajLine.GetBlue()) ; - // asse X + // asse X glVertex3f( - dExt, 0, Z_DOWN) ; glVertex3f( dExt, 0, Z_DOWN) ; - // asse Y + // asse Y glVertex3f( 0, - dExt, Z_DOWN) ; glVertex3f( 0, dExt, Z_DOWN) ; glEnd() ; @@ -198,6 +207,187 @@ Scene::DrawGrid( void) return true ; } +//---------------------------------------------------------------------------- +bool +Scene::DrawRectangularGrid() +{ + // se non devo disegnare, esco subito + if ( ! m_bShowGrid && ! m_bShowFrame) + return true ; + + // controllo dimensione del rettangolo + if ( m_dGridWidth < m_dSnapStep || m_dGridHeight < m_dSnapStep) + return true ; + + // controllo dove devo posizionare l'origine degli assi + bool bStandardOrig = m_nGridFrame_Flag == 2 ? true : false ; + + // spessore linee + glLineWidth(( float) GetGridLineWidth()) ; + + // imposto il riferimento + glPushMatrix() ; + double Matrix[OGLMAT_DIM] ; + if ( FrameToOpenGlMatrix( GetGridFrame(), Matrix)) + glMultMatrixd( Matrix) ; + + // semi-estensione della griglia + float dExt_y = ( float) floor( m_dGridHeight * ( bStandardOrig ? 0.5 : 1.0)) ; + float dExt_x = ( float) floor( m_dGridWidth * ( bStandardOrig ? 0.5 : 1.0)) ; + + int nX_Step = ( int) floor( dExt_x / m_dSnapStep) ; + int nY_Step = ( int) floor( dExt_y / m_dSnapStep) ; + + // abbassamento in Z per evitare sovrapposizioni con geometria + const float Z_DOWN = float( - 0.01) ; + + // se richiesto, disegno la griglia + if ( m_bShowGrid) { + // disegno linee minori ( a trattini), se non troppe + double dMinRapp = min( m_dHalfWidth, m_dHalfHeight) / ( m_dSnapStep * m_nMinLineSstep) ; + if ( dMinRapp < 60) { + glLineStipple( 2, 0xAAAA) ; + glEnable( GL_LINE_STIPPLE) ; + glBegin( GL_LINES) ; + glColor3f( m_colMinLine.GetRed(), m_colMinLine.GetGreen(), m_colMinLine.GetBlue()) ; + for ( int i = m_nMinLineSstep ; i <= nX_Step ; i += m_nMinLineSstep) { + if (( i % m_nMajLineSstep) != 0) { + float dPos = float( i * m_dSnapStep) ; + // X + + glVertex3f( dPos, bStandardOrig ? - dExt_y : 0.0, Z_DOWN) ; + glVertex3f( dPos, dExt_y, Z_DOWN) ; + if ( bStandardOrig) { + // X - + glVertex3f( - dPos, - dExt_y, Z_DOWN) ; + glVertex3f( - dPos, dExt_y, Z_DOWN) ; + } + } + } + for ( int i = m_nMinLineSstep ; i <= nY_Step ; i += m_nMinLineSstep) { + if (( i % m_nMajLineSstep) != 0) { + float dPos = float( i * m_dSnapStep) ; + // Y + + glVertex3f( bStandardOrig ? - dExt_x : 0.0, dPos, Z_DOWN) ; + glVertex3f( dExt_x, dPos, Z_DOWN) ; + if ( bStandardOrig) { + // Y - + glVertex3f( - dExt_x, - dPos, Z_DOWN) ; + glVertex3f( dExt_x, - dPos, Z_DOWN) ; + } + } + } + glEnd() ; + glDisable( GL_LINE_STIPPLE) ; + } + // disegno linee maggiori + double dMaxRapp = min( m_dHalfWidth, m_dHalfHeight) / ( m_dSnapStep * m_nMajLineSstep) ; + int nCoeff = GetSpecialCoeff( 0.06 * dMaxRapp) ; + glBegin( GL_LINES) ; + glColor3f( m_colMajLine.GetRed(), m_colMajLine.GetGreen(), m_colMajLine.GetBlue()) ; + for ( int i = min( nCoeff * m_nMajLineSstep, ( int)dExt_x) ; i <= ( int)nX_Step ; i += nCoeff * m_nMajLineSstep) { + float dPos = float( i * m_dSnapStep) ; + // X + + glVertex3f( dPos, bStandardOrig ? - dExt_y : 0.0, Z_DOWN) ; + glVertex3f( dPos, dExt_y, Z_DOWN) ; + if ( bStandardOrig) { + // X - + glVertex3f( - dPos, - dExt_y, Z_DOWN) ; + glVertex3f( - dPos, dExt_y, Z_DOWN) ; + } + } + for ( int i = min( nCoeff * m_nMajLineSstep, ( int)dExt_y) ; i <= ( int)nY_Step ; i += nCoeff * m_nMajLineSstep) { + float dPos = float( i * m_dSnapStep) ; + // Y + + glVertex3f( bStandardOrig ? - dExt_x : 0.0, dPos, Z_DOWN) ; + glVertex3f( dExt_x, dPos, Z_DOWN) ; + if ( bStandardOrig) { + // Y - + glVertex3f( - dExt_x, - dPos, Z_DOWN) ; + glVertex3f( dExt_x, - dPos, Z_DOWN) ; + } + } + glEnd() ; + } + // se richiesto, disegno assi del frame + if ( m_bShowFrame) { + // calcolo lunghezza asse Z + GLint Viewport[4] ; + glGetIntegerv( GL_VIEWPORT, Viewport) ; + const double LEN_AX = 28 ; + double dLenZ = LEN_AX * ( 2 * m_dHalfWidth) / Viewport[2] ; + float fLenZ = float( min( m_dSnapStep, dLenZ)) ; + glBegin( GL_LINES) ; + // asse X+ + glColor3f( m_cColX.GetRed(), m_cColX.GetGreen(), m_cColX.GetBlue()) ; + glVertex3f( 0, 0, Z_DOWN) ; + glVertex3f( dExt_x, 0, Z_DOWN) ; + // asse Y+ + glColor3f( m_cColY.GetRed(), m_cColY.GetGreen(), m_cColY.GetBlue()) ; + glVertex3f( 0, 0, Z_DOWN) ; + glVertex3f( 0, dExt_y, Z_DOWN) ; + // asse Z+ + glColor3f( m_cColZ.GetRed(), m_cColZ.GetGreen(), m_cColZ.GetBlue()) ; + glVertex3f( 0, 0, Z_DOWN) ; + glVertex3f( 0, 0, fLenZ) ; + // se richiesta griglia, assi X- e Y- + if ( m_bShowGrid) { + glColor3f( m_colMajLine.GetRed(), m_colMajLine.GetGreen(), m_colMajLine.GetBlue()) ; + glVertex3f( 0, 0, Z_DOWN) ; + glVertex3f( bStandardOrig ? - dExt_x : 0.0, 0, Z_DOWN) ; + glVertex3f( 0, 0, Z_DOWN) ; + glVertex3f( 0, bStandardOrig ? - dExt_y : 0.0, Z_DOWN) ; + glLineWidth( (float) GetGridLineWidth()) ; + } + glEnd() ; + } + // altrimenti, se richiesta sola griglia li disegno come linee principali + else if ( m_bShowGrid) { + glBegin( GL_LINES) ; + glColor3f( m_colMajLine.GetRed(), m_colMajLine.GetGreen(), m_colMajLine.GetBlue()) ; + // asse X + glVertex3f( bStandardOrig ? - dExt_x : 0.0, 0, Z_DOWN) ; + glVertex3f( dExt_x, 0, Z_DOWN) ; + // asse Y + glVertex3f( 0, bStandardOrig ? - dExt_y : 0.0, Z_DOWN) ; + glVertex3f( 0, dExt_y, Z_DOWN) ; + glEnd() ; + } + + // ripristino lo stack delle matrici + glPopMatrix() ; + + // ripristino spessore linee + glLineWidth(( float) GetLineWidth()) ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +Scene::SetGlobGridParameters( int nPosFlag, double dLenX, double dLenY) +{ + // controllo validità dei parametri... + if ( dLenX < GRID_MIN_LEN_X || dLenY < GRID_MIN_LEN_Y || + nPosFlag < 0 || nPosFlag > 3 ) { + m_bShowFrame = false ; + m_bShowGrid = false ; + return false ; + } + + if ( nPosFlag == 0) { + m_bShowFrame = false ; + m_bShowGrid = false ; + return true ; + } + + // setto i parametri membro + m_dGridWidth = dLenX ; + m_dGridHeight = dLenY ; + m_nGridFrame_Flag = nPosFlag ; + return true ; + +} + //---------------------------------------------------------------------------- void Scene::GetGridParam( double& dSnapStep, int& nExtStep) const diff --git a/SceneSelect.cpp b/SceneSelect.cpp index 1e3bc4f..78b2c07 100644 --- a/SceneSelect.cpp +++ b/SceneSelect.cpp @@ -96,7 +96,11 @@ Scene::Select( const Point3d& ptSelCenter, int nW, int nH, int& nSel) // 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 - DrawGlobCube() ; + glEnable( GL_CULL_FACE) ; + glCullFace( GL_BACK) ; + glFrontFace( GL_CCW) ; + DrawGlobCube( false) ; + glDisable( GL_CULL_FACE) ; // pulisco stack nomi glPopName() ; @@ -111,11 +115,9 @@ 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 ;