Egalware/TestEGr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
30effc3d9cec0f61b742d66b7a5475d9e01f0bff
TestEGr/TestEGrView.cpp
T
Dario Sassi 2c32745e54 TestEGr 1.5k1 : 
- ricompilazione con adattamento.
2014-11-18 16:21:13 +00:00

668 lines
20 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2013-2014
//----------------------------------------------------------------------------
// File : TestEGrView.cpp Data : 05.02.14 Versione : 1.5b3
// Contenuto : Implementazione della classe gestione vista OpenGL.
//
//
//
// Modifiche : 29.01.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "TestEGrView.h"
#include "TestEGrUtils.h"
#include "SelectDlg.h"
#include "resource.h"
#include "/EgtDev/Include/EgkGdbConst.h"
#include "/EgtDev/Include/EgkGeomDB.h"
#include "/EgtDev/Include/EgkCurve.h"
#include "/EgtDev/Include/EgkStringUtils3d.h"
#include "/EgtDev/Include/EGrScene.h"
#include "/EgtDev/Include/EgtPerfCounter.h"
#include "/EgtDev/Include/EgtILogger.h"
#include "/EgtDev/Include/EgnStringConverter.h"
using namespace std ;
//----------------------------------------------------------------------------
static const int DIM_SEL = 13 ;
//----------------------------------------------------------------------------
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
//----------------------------------------------------------------------------
BEGIN_MESSAGE_MAP( TestEGrView, CWnd)
ON_WM_PAINT()
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONUP()
ON_WM_RBUTTONUP()
ON_WM_MBUTTONDOWN()
ON_WM_MBUTTONUP()
ON_WM_MOUSEMOVE()
ON_WM_MOUSEWHEEL()
ON_COMMAND_RANGE( IDM_ENDPOINT, IDM_NEARPOINT, OnSelSnapPoint)
END_MESSAGE_MAP()
//----------------------------------------------------------------------------
TestEGrView::TestEGrView( void)
{
m_pDC = nullptr ;
m_pScene = nullptr ;
m_nStatus = ST_NULL ;
m_nOldStatus = ST_NULL ;
m_PrevPoint.SetPoint( 0, 0) ;
m_ptPrev.Set( 0, 0, 0) ;
m_nSnapPoint = SP_END ;
}
//----------------------------------------------------------------------------
TestEGrView::~TestEGrView( void)
{
if ( m_pScene != nullptr)
delete m_pScene ;
m_pScene = nullptr ;
if ( m_pDC != nullptr)
delete m_pDC ;
m_pDC = nullptr ;
}
//----------------------------------------------------------------------------
bool
TestEGrView::Create( CWnd* pParent, int nID)
{
if ( pParent == nullptr ||
pParent->GetDlgItem( nID) == nullptr)
return false ;
CString className = AfxRegisterWndClass( CS_HREDRAW | CS_VREDRAW | CS_OWNDC,
NULL, NULL, NULL) ;
CRect rectWin ;
pParent->GetDlgItem( nID)->GetWindowRect( rectWin) ;
pParent->ScreenToClient( rectWin) ;
if ( CreateEx( 0, className, L"TestEGrView",
WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, rectWin, pParent, nID) != 0) {
SetWindowPos( &wndTop, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE) ;
SetCursor( AfxGetApp()->LoadCursor( IDC_SELECT)) ;
m_pDC = new CClientDC( this) ;
m_pScene = CreateEGrScene() ;
// configuro le gesture
CGestureConfig cfg ;
GetGestureConfig( &cfg) ;
cfg.EnablePan( TRUE, GC_PAN) ;
cfg.EnableRotate( TRUE) ;
SetGestureConfig( &cfg) ;
return ( m_pDC != nullptr && m_pScene != nullptr) ;
}
else
return false ;
}
//----------------------------------------------------------------------------
bool
TestEGrView::StartScene( int nDriver, bool b2Buff, int nColorBits, int nDepthBits)
{
if ( m_pScene == nullptr)
return false ;
// creazione della scena
if ( ! m_pScene->CreateContext( GetSafeHdc(), nDriver, b2Buff, nColorBits, nDepthBits))
return false ;
// impostazione dati di vista
m_pScene->SetCamera( CT_ISO_SW) ;
m_pScene->ZoomAll() ;
return true ;
}
//----------------------------------------------------------------------------
bool
TestEGrView::GetSceneInfo( string& sInfo)
{
if ( m_pScene == nullptr)
return false ;
sInfo = m_pScene->GetOpenGLInfo() + '\n' +
m_pScene->GetGLSLInfo() + '\n' +
m_pScene->GetPixelFormatInfo() ;
return true ;
}
//----------------------------------------------------------------------------
void
TestEGrView::Destroy( void)
{
if ( m_pScene != nullptr)
m_pScene->Destroy() ;
DestroyWindow() ;
}
//----------------------------------------------------------------------------
bool
TestEGrView::Resize( int nX, int nY, int nW, int nH)
{
// se non è ancora stata creata, esco subito
if ( m_pDC == nullptr || m_pScene == nullptr)
return true ;
MoveWindow( nX, nY, nW, nH, FALSE) ;
m_pScene->Resize( nW, nH) ;
return true ;
}
//----------------------------------------------------------------------------
void
TestEGrView::OnPaint( void)
{
if ( m_pScene == nullptr)
return ;
PerformanceCounter Counter ;
// ridisegno finestra OpenGL
Counter.Start() ;
m_pScene->Draw() ;
ValidateRgn( NULL) ;
Counter.Stop() ;
// emetto info
string sOut = "Redraw time = " + ToString( Counter.GetTime(), 2) + " ms" ;
::OutInfo( sOut, false) ;
}
//----------------------------------------------------------------------------
void
TestEGrView::Redraw( void)
{
RedrawWindow() ;
}
//----------------------------------------------------------------------------
void
TestEGrView::ShowMode( UINT nID)
{
if ( m_pScene == nullptr)
return ;
switch ( nID) {
case IDC_WIREFRAME :
m_pScene->SetShowMode( SM_WIREFRAME) ;
break ;
case IDC_HIDDENLINE :
m_pScene->SetShowMode( SM_HIDDENLINE) ;
break ;
case IDC_SHADING :
m_pScene->SetShowMode( SM_SHADING) ;
break ;
default :
return ;
break ;
}
RedrawWindow() ;
}
//----------------------------------------------------------------------------
void
TestEGrView::ShowCurveDir( bool bShow)
{
if ( m_pScene == nullptr)
return ;
m_pScene->SetShowCurveDirection( bShow) ;
RedrawWindow() ;
}
//----------------------------------------------------------------------------
void
TestEGrView::Zoom( UINT nID)
{
if ( m_pScene == nullptr)
return ;
const double COEFF_IN = 0.9 ;
const double COEFF_OUT = 1 / COEFF_IN ;
switch ( nID) {
case IDC_ZOOM_ALL :
m_pScene->ZoomAll() ;
break ;
case IDC_ZOOM_IN :
m_pScene->ZoomChange( COEFF_IN) ;
break ;
case IDC_ZOOM_OUT :
m_pScene->ZoomChange( COEFF_OUT) ;
break ;
default :
return ;
break ;
}
RedrawWindow() ;
}
//----------------------------------------------------------------------------
void
TestEGrView::View( UINT nID)
{
if ( m_pScene == nullptr)
return ;
switch ( nID) {
case IDC_VIEW_TOP :
m_pScene->SetCamera( CT_TOP) ;
break ;
case IDC_VIEW_FRONT :
m_pScene->SetCamera( CT_FRONT) ;
break ;
case IDC_VIEW_BACK :
m_pScene->SetCamera( CT_BACK) ;
break ;
case IDC_VIEW_LEFT :
m_pScene->SetCamera( CT_LEFT) ;
break ;
case IDC_VIEW_RIGHT :
m_pScene->SetCamera( CT_RIGHT) ;
break ;
case IDC_VIEW_ISO :
m_pScene->SetCamera( CT_ISO_SW) ;
break ;
default :
return ;
break ;
}
RedrawWindow() ;
}
//----------------------------------------------------------------------------
void
TestEGrView::SetAnalyze( void)
{
m_nStatus = ST_ANALYZE ;
}
//----------------------------------------------------------------------------
void
TestEGrView::SetGetDistance( void)
{
m_pScene->ResetGeoLine() ;
m_pScene->Draw() ;
m_nStatus = ST_GETDIST ;
}
//----------------------------------------------------------------------------
void
TestEGrView::OnLButtonDown( UINT nFlags, CPoint point)
{
if ( m_nStatus == ST_NULL) {
int nSel ;
m_pScene->Select( Point3d( point.x, point.y), DIM_SEL, DIM_SEL, nSel) ;
if ( nSel == 1) {
int nId = m_pScene->GetFirstSelectedObj() ;
if ( m_pScene->GetGeomDB()->IsSelectedObj( nId))
m_pScene->GetGeomDB()->DeselectObj( nId) ;
else
m_pScene->GetGeomDB()->SelectObj( nId) ;
m_pScene->Draw() ;
}
else if ( nSel > 1) {
CSelectDlg dlgSelect( m_pScene) ;
dlgSelect.DoModal() ;
int nId = dlgSelect.GetCurrId() ;
if ( nId != GDB_ID_NULL) {
if ( m_pScene->GetGeomDB()->IsSelectedObj( nId))
m_pScene->GetGeomDB()->DeselectObj( nId) ;
else
m_pScene->GetGeomDB()->SelectObj( nId) ;
m_pScene->Draw() ;
}
}
}
else if ( m_nStatus == ST_ANALYZE) {
int nSel = 0 ;
int nId = GDB_ID_NULL ;
m_pScene->Select( Point3d( point.x, point.y), DIM_SEL, DIM_SEL, nSel) ;
if ( nSel == 1)
nId = m_pScene->GetFirstSelectedObj() ;
else if ( nSel > 1) {
CSelectDlg dlgSelect( m_pScene) ;
dlgSelect.DoModal() ;
nId = dlgSelect.GetCurrId() ;
}
if ( nId != GDB_ID_NULL)
SelectIdInGeomDbTree( nId) ;
SetCursor( AfxGetApp()->LoadCursor( IDC_SELECT)) ;
m_nStatus = ST_NULL ;
}
else if ( m_nStatus == ST_GETDIST) {
if ( m_pScene->GetGraphicSnapPoint( m_nSnapPoint, Point3d( point.x, point.y), DIM_SEL, DIM_SEL, m_ptPrev)) {
// salvo il punto di riferimento
Point3d ptWin ;
m_pScene->Project( m_ptPrev, ptWin) ;
m_PrevPoint.SetPoint( int( ptWin.x), int( ptWin.y)) ;
m_nStatus = ST_GETDIST2 ;
}
else {
SetCursor( AfxGetApp()->LoadCursor( IDC_SELECT)) ;
m_nStatus = ST_NULL ;
}
}
else if ( m_nStatus == ST_GETDIST2) {
// recupero il punto selezionato
Point3d ptSel ;
if ( m_pScene->GetGraphicSnapPoint( m_nSnapPoint, Point3d( point.x, point.y), DIM_SEL, DIM_SEL, ptSel)) {
// disegno la linea (coordinate geo globali)
m_pScene->SetGeoLine( m_ptPrev, ptSel) ;
RedrawWindow() ;
// calcolo la distanza e il delta e li visualizzo
double dDist = Dist( ptSel, m_ptPrev) ;
Vector3d vtDiff = ptSel - m_ptPrev ;
string sOut ;
sOut = "Dist=" + ToString( dDist, 4) +
" dX=" + ToString( vtDiff.x, 4) +
" dY=" + ToString( vtDiff.y, 4) +
" dZ=" + ToString( vtDiff.z, 4) ;
AfxMessageBox( stringtoW( sOut), MB_ICONINFORMATION | MB_OK) ;
}
// annullo eventuale linea di misura e lo stato
m_pScene->ResetGeoLine() ;
RedrawWindow() ;
m_nStatus = ST_NULL ;
}
}
//----------------------------------------------------------------------------
void
TestEGrView::OnLButtonUp( UINT nFlags, CPoint point)
{
;
}
//----------------------------------------------------------------------------
void
TestEGrView::OnRButtonUp( UINT nFlags, CPoint point)
{
// se utile menù punti notevoli proseguo
if ( m_nStatus != ST_GETDIST && m_nStatus != ST_GETDIST2)
return ;
// inserisco menù per punti notevoli
CMenu Menu ;
Menu.CreatePopupMenu() ;
Menu.AppendMenu( MF_STRING, IDM_ENDPOINT, L"EndPoint") ;
Menu.CheckMenuItem( IDM_ENDPOINT, MF_BYCOMMAND | ( m_nSnapPoint == SP_END ? MF_CHECKED : MF_UNCHECKED)) ;
Menu.AppendMenu( MF_STRING, IDM_MIDPOINT, L"MidPoint") ;
Menu.CheckMenuItem( IDM_MIDPOINT, MF_BYCOMMAND | ( m_nSnapPoint == SP_MID ? MF_CHECKED : MF_UNCHECKED)) ;
Menu.AppendMenu( MF_STRING, IDM_CENTERPOINT, L"CenterPoint") ;
Menu.CheckMenuItem( IDM_CENTERPOINT, MF_BYCOMMAND | ( m_nSnapPoint == SP_CENTER ? MF_CHECKED : MF_UNCHECKED)) ;
Menu.AppendMenu( MF_STRING, IDM_NEARPOINT, L"NearPoint") ;
Menu.CheckMenuItem( IDM_NEARPOINT, MF_BYCOMMAND | ( m_nSnapPoint == SP_NEAR ? MF_CHECKED : MF_UNCHECKED)) ;
ClientToScreen( &point) ;
Menu.TrackPopupMenu( TPM_LEFTALIGN, point.x, point.y, this) ;
}
//----------------------------------------------------------------------------
void
TestEGrView::OnSelSnapPoint( UINT nID)
{
switch ( nID) {
case IDM_ENDPOINT :
m_nSnapPoint = SP_END ;
break ;
case IDM_MIDPOINT :
m_nSnapPoint = SP_MID ;
break ;
case IDM_CENTERPOINT :
m_nSnapPoint = SP_CENTER ;
break ;
case IDM_NEARPOINT :
m_nSnapPoint = SP_NEAR ;
break ;
}
}
//----------------------------------------------------------------------------
void
TestEGrView::OnMButtonDown( UINT nFlags, CPoint point)
{
if ( nFlags & MK_SHIFT) {
m_nOldStatus = ( m_nStatus == ST_GETDIST2) ? ST_GETDIST2 : ST_NULL ;
m_nStatus = ST_ZOOMWIN ;
SetCursor( AfxGetApp()->LoadCursor( IDC_ZOOMWIN)) ;
}
else if ( nFlags & MK_CONTROL) {
m_nOldStatus = ( m_nStatus == ST_GETDIST2) ? ST_GETDIST2 : ST_NULL ;
m_nStatus = ST_ROT ;
SetCursor( AfxGetApp()->LoadCursor( IDC_ROTATE)) ;
}
else {
m_nOldStatus = ( m_nStatus == ST_GETDIST2) ? ST_GETDIST2 : ST_NULL ;
m_nStatus = ST_PAN ;
SetCursor( AfxGetApp()->LoadCursor( IDC_PAN)) ;
}
// salvo il punto di riferimento
m_PrevPoint = point ;
}
//----------------------------------------------------------------------------
void
TestEGrView::OnMButtonUp( UINT nFlags, CPoint point)
{
// eseguo ZOOMWINDOWN
if ( m_nStatus == ST_ZOOMWIN) {
// annullo i dati del rettangolo di definizione della nuova vista
if ( m_pScene != nullptr)
m_pScene->ResetWinRect() ;
// eseguo lo zoom
if ( m_pScene != nullptr)
m_pScene->ZoomWin( Point3d( m_PrevPoint.x, m_PrevPoint.y), Point3d( point.x, point.y)) ;
// aggiorno il disegno
RedrawWindow() ;
}
// eventuale ripristino vecchio stato
if ( m_nOldStatus == ST_GETDIST2) {
m_nStatus = ST_GETDIST2 ;
SetCursor( AfxGetApp()->LoadCursor( IDC_GETDIST)) ;
}
// reset dello stato se non NULL
else if ( m_nStatus != ST_NULL) {
m_nStatus = ST_NULL ;
SetCursor( AfxGetApp()->LoadCursor( IDC_SELECT)) ;
}
}
//----------------------------------------------------------------------------
void
TestEGrView::OnMouseMove( UINT nFlags, CPoint point)
{
// visualizzo le coordinate del puntatore
ShowCursorCoordinates( Point3d( point.x, point.y)) ;
// se in modalità ZOOMWINDOW
if ( m_nStatus == ST_ZOOMWIN && nFlags & MK_MBUTTON) {
SetCursor( AfxGetApp()->LoadCursor( IDC_ZOOMWIN)) ;
// aggiorno i dati del rettangolo di definizione della nuova vista
if ( m_pScene != nullptr)
m_pScene->SetWinRect( Point3d( m_PrevPoint.x, m_PrevPoint.y), Point3d( point.x, point.y)) ;
// aggiorno il disegno
RedrawWindow() ;
// il punto di riferimento deve rimanere quello originale
}
// se in modalità ROTATE
else if ( m_nStatus == ST_ROT && nFlags & MK_MBUTTON) {
SetCursor( AfxGetApp()->LoadCursor( IDC_ROTATE)) ;
// eseguo la rotazione
if ( m_pScene != nullptr)
m_pScene->RotateCamera( Point3d( m_PrevPoint.x, m_PrevPoint.y), Point3d( point.x, point.y)) ;
// aggiorno il disegno
RedrawWindow() ;
// aggiorno i bottoni
UpdateButtons() ;
// salvo il punto di riferimento
m_PrevPoint = point ;
}
// se in modalità PAN
else if ( m_nStatus == ST_PAN && nFlags & MK_MBUTTON) {
SetCursor( AfxGetApp()->LoadCursor( IDC_PAN)) ;
// eseguo il pan
if ( m_pScene != nullptr)
m_pScene->PanCamera( Point3d( m_PrevPoint.x, m_PrevPoint.y), Point3d( point.x, point.y)) ;
// aggiorno il disegno
RedrawWindow() ;
// salvo il punto di riferimento
m_PrevPoint = point ;
}
// se in modalità ANALYZE
else if ( m_nStatus == ST_ANALYZE) {
SetCursor( AfxGetApp()->LoadCursor( IDC_ANALYZE)) ;
}
// se in modalità GETDIST
else if ( m_nStatus == ST_GETDIST) {
SetCursor( AfxGetApp()->LoadCursor( IDC_GETDIST)) ;
}
// se in modalità GETDIST2
else if ( m_nStatus == ST_GETDIST2) {
SetCursor( AfxGetApp()->LoadCursor( IDC_GETDIST)) ;
Point3d ptP ;
m_pScene->UnProject( Point3d( point.x, point.y, 0.5), ptP) ;
m_pScene->SetGeoLine( m_ptPrev, ptP) ;
// aggiorno il disegno
RedrawWindow() ;
}
// altrimenti reset dello stato e cursore standard
else {
SetCursor( AfxGetApp()->LoadCursor( IDC_SELECT)) ;
m_nStatus = ST_NULL ;
}
}
//----------------------------------------------------------------------------
BOOL
TestEGrView::OnMouseWheel( UINT nFlags, short zDelta, CPoint point)
{
// devo essere nello stato NULL o GETDIST
if ( m_nStatus != ST_NULL && m_nStatus != ST_GETDIST && m_nStatus != ST_GETDIST2)
return 0 ;
// calcolo coefficiente
double dCoeff = 1 - 0.1 * abs( zDelta) / WHEEL_DELTA ;
if ( zDelta < 0)
dCoeff = 1 / dCoeff ;
// porto il punto in coordinate client
ScreenToClient( &point) ;
// eseguo lo zoom sul punto
if ( m_pScene != nullptr)
m_pScene->ZoomOnPoint( Point3d( point.x, point.y), dCoeff) ;
// aggiorno il disegno
RedrawWindow() ;
return 0 ;
}
//----------------------------------------------------------------------------
BOOL
TestEGrView::OnGesturePan( CPoint ptFRom, CPoint ptTO)
{
if ( m_pScene == nullptr)
return false ;
// eseguo il pan
m_pScene->PanCamera( Point3d( ptFRom.x, ptFRom.y), Point3d( ptTO.x, ptTO.y)) ;
// aggiorno il disegno
RedrawWindow() ;
return true ;
}
//----------------------------------------------------------------------------
BOOL
TestEGrView::OnGestureRotate( CPoint ptCenter, double dblAngle)
{
if ( m_pScene == nullptr)
return false ;
// recupero gli angoli precedenti
double dAngVertDeg, dAngOrizzDeg, dDist ;
m_pScene->GetCamera( &dAngVertDeg, &dAngOrizzDeg, &dDist) ;
// imposto i nuovi
m_pScene->SetCamera( dAngVertDeg, dAngOrizzDeg - dblAngle, dDist) ;
// aggiorno il disegno
RedrawWindow() ;
return true ;
}
//----------------------------------------------------------------------------
BOOL
TestEGrView::OnGesturePressAndTap( CPoint ptPress, long lDelta)
{
if ( m_pScene == nullptr)
return false ;
// recupero gli angoli precedenti
double dAngVertDeg, dAngOrizzDeg, dDist ;
m_pScene->GetCamera( &dAngVertDeg, &dAngOrizzDeg, &dDist) ;
// imposto il nuovo angolo verticale
if ( lDelta > 10)
dAngVertDeg = max( 0, dAngVertDeg - 15) ;
else if ( lDelta < - 10)
dAngVertDeg = min( 180, dAngVertDeg + 15) ;
else
return true ;
m_pScene->SetCamera( dAngVertDeg, dAngOrizzDeg, dDist) ;
// aggiorno il disegno
RedrawWindow() ;
return true ;
}
//----------------------------------------------------------------------------
void
TestEGrView::ShowCursorCoordinates( const Point3d& ptWin)
{
if ( m_pScene == nullptr)
return ;
// trasformo il punto da coordinate view a coordinate mondo
Point3d ptView( ptWin.x, ptWin.y, m_pScene->GetProjectedCenter().z) ;
Point3d ptWorld ;
if ( ! m_pScene->UnProject( ptView, ptWorld))
return ;
// visualizzo le coordinate
std::string sCoord ;
switch ( m_pScene->GetCameraDir()) {
case CT_TOP :
case CT_BOTTOM :
sCoord = "X=" + ToString( ptWorld.x, 4) + " Y=" + ToString( ptWorld.y, 4) ;
break ;
case CT_FRONT :
case CT_BACK :
sCoord = "X=" + ToString( ptWorld.x, 4) + " Z=" + ToString( ptWorld.z, 4) ;
break ;
case CT_LEFT :
case CT_RIGHT :
sCoord = "Y=" + ToString( ptWorld.y, 4) + " Z=" + ToString( ptWorld.z, 4) ;
break ;
default :
sCoord = " " ;
break ;
}
GetParent()->GetDlgItem( IDC_COORD)->SetWindowText( stringtoW( sCoord)) ;
}
Reference in New Issue View Git Blame Copy Permalink