//----------------------------------------------------------------------------
//  EgalTech 2022
//----------------------------------------------------------------------------
// File : SceneGlobCube.cpp       Data : 10.10.22         Versione : 1
// Contenuto : Implementazione gestione e disegno Cubetto per viste.
//
//
//
// Modifiche : 11.10.22 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "Scene.h"
#include "EGrUtils.h"
#include "/EgtDev/Include/EGkGeomDB.h"


using namespace std ;

//----------------------------------------------------------------------------
bool
Scene::SetGlobCubeShow( bool bShow)
{
    m_bShowGlobCube = bShow ;
    return true ;
}

//----------------------------------------------------------------------------
bool
Scene::DrawGlobCube(void)
{
    // se non devo disegnare, esco subito
    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 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 ;
}


//----------------------------------------------------------------------------
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) 
{
    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;
}

//----------------------------------------------------------------------------
bool 
Scene::SetGlobCubeParameters( double dposX, double dPosY, double dEdge) 
{ 
  // 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)
      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)
      return false ;

  // controllo il raggio del cubo
   if ( dEdge < 20)
      return false ;

  // imposto le variabili membro
   m_dCubeX = dposX ;
   m_dCubeY = dPosY ;
   m_dCubeEdge = dEdge ;
   return true ;
}