Egalware/EgtGraphics
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
EgtGraphics/SceneCamera.cpp
T
Dario Sassi ac78227f0b EgtGraphics : 
- piccoli aggiustamenti su ZoomOnPoint e ZoomWin per impostazione centro vista.
2026-05-14 16:07:02 +02:00

636 lines
20 KiB
C++
Raw Permalink Blame History

//----------------------------------------------------------------------------
// EgalTech 2013-2014
//----------------------------------------------------------------------------
// File : SceneCamera.cpp Data : 10.02.14 Versione : 1.5b1
// Contenuto : Implementazione della gestione camera della classe scena.
//
//
//
// Modifiche : 10.02.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "Scene.h"
#include "/EgtDev/Include/EGkFrame3d.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EgtILogger.h"
using namespace std ;
//--------------------------- Constants --------------------------------------
static const double MIN_DIST_CAMERA = 10 ;
static const double STD_DIST_CAMERA = 1000 ;
//----------------------------------------------------------------------------
bool
Scene::SetCameraType( bool bOrthoOrPersp)
{
m_bOrthographic = bOrthoOrPersp ;
// ricalcolo i parametri di vista
m_bDistOk = false ;
CalcDistCamera() ;
CalcClippingPlanesFromExtView() ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::SetZoomType( int nZoomMode)
{
if ( nZoomMode != ZT_STD && nZoomMode != ZT_DOLLY)
return false ;
m_nPerspZoomType = nZoomMode ;
return true ;
}
//----------------------------------------------------------------------------
double
Scene::CalcMinCameraDistance()
{
double dMinDist = MIN_DIST_CAMERA ;
// nel caso di vista prospettica la distanza della camera deve garantire di non finire dentro gli oggetti
if ( ! m_bOrthographic) {
// calcolo il box di tutti gli oggetti visibili nel frame della camera
Frame3d frCamera ;
CalcCameraFrame( frCamera) ;
BBox3d b3Tot ;
if ( m_pGeomDB != nullptr)
m_pGeomDB->GetGlobalBBox( GDB_ID_ROOT, b3Tot, BBF_ONLY_VISIBLE) ;
b3Tot.ToLoc( frCamera) ;
// la distanza minima della camera è quella che garantisce di trovarsi ad una distanza pari almeno a PERSPECTIVE_NEAR_PLANE
// dalla faccia del box davanti alla camera
Point3d ptMax = b3Tot.GetMax() ;
ptMax.ToGlob( frCamera) ;
dMinDist = ( ptMax - m_ptCenter) * m_vtDirCamera + PERSPECTIVE_NEAR_PLANE + 10 * EPS_SMALL ;
}
return dMinDist ;
}
//----------------------------------------------------------------------------
bool
Scene::CalcDistCamera()
{
// verifico se il calcolo è necessario
if ( m_bDistOk)
return true ;
if ( m_dDistCamera < EPS_SMALL)
m_dDistCamera = STD_DIST_CAMERA ;
else {
double dMinDist = CalcMinCameraDistance() ;
if ( m_dDistCamera < dMinDist)
m_dDistCamera = dMinDist ;
}
m_bDistOk = true ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::SetCenter( const Point3d& ptCenter)
{
// assegno il punto
m_ptCenter = ptCenter ;
// invalido ExtView
m_bExtViewOk = false ;
// calcolo nuovi dati di Z clipping
CalcClippingPlanesFromExtView() ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::SetCamera( double dAngVertDeg, double dAngOrizzDeg, double dDist)
{
// assegno la direzione ed eventuale distanza
m_vtDirCamera = FromSpherical( 1, dAngVertDeg, dAngOrizzDeg) ;
if ( dDist > EPS_SMALL)
m_dDistCamera = dDist ;
if ( ! VerifyCamera())
return false ;
// se vista da sopra, impongo vtUp da angolo orizzontale
if ( abs( dAngVertDeg) < EPS_ANG_SMALL) {
m_vtUp = - FromPolar( 1, dAngOrizzDeg) ;
m_bUpOk = true ;
}
// lo stesso anche per vista da sotto
else if ( abs( dAngVertDeg - ANG_STRAIGHT) < EPS_ANG_SMALL) {
m_vtUp = FromPolar( 1, dAngOrizzDeg) ;
m_bUpOk = true ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::SetCamera( int nDir, double dDist)
{
switch ( nDir) {
case CT_TOP :
m_vtDirCamera.Set( 0, 0, 1) ;
break ;
case CT_FRONT :
m_vtDirCamera.Set( 0, -1, 0) ;
break ;
case CT_RIGHT :
m_vtDirCamera.Set( 1, 0, 0) ;
break ;
case CT_BACK :
m_vtDirCamera.Set( 0, 1, 0) ;
break ;
case CT_LEFT :
m_vtDirCamera.Set( -1, 0, 0) ;
break ;
case CT_BOTTOM :
m_vtDirCamera.Set( 0, 0, -1) ;
break ;
case CT_ISO_SW :
m_vtDirCamera.Set( -SQRT1_3, -SQRT1_3, SQRT1_3) ;
break ;
case CT_ISO_SE :
m_vtDirCamera.Set( SQRT1_3, -SQRT1_3, SQRT1_3) ;
break ;
case CT_ISO_NE :
m_vtDirCamera.Set( SQRT1_3, SQRT1_3, SQRT1_3) ;
break ;
case CT_ISO_NW :
m_vtDirCamera.Set( -SQRT1_3, SQRT1_3, SQRT1_3) ;
break ;
case CT_CPLANE :
m_vtDirCamera = GetGridFrame().VersZ() ;
break ;
default :
return false ;
break ;
}
if ( nDir != CT_CPLANE)
m_vtDirCamera.Rotate( Z_AX, m_nOrizzOffsCamera * ANG_RIGHT) ;
// assegno eventuale distanza
if ( dDist > EPS_SMALL)
m_dDistCamera = dDist ;
return VerifyCamera( nDir != CT_CPLANE) ;
}
//----------------------------------------------------------------------------
bool
Scene::VerifyCamera( bool bUseOrizzOffsCamera)
{
// verifico il versore
if ( ! m_vtDirCamera.Normalize())
m_vtDirCamera.Set( 0, 0, 1) ;
// ricalcolo direzione Up
m_bUpOk = false ;
if ( ! CalcDirUp( bUseOrizzOffsCamera))
return false ;
// verifico la distanza
m_bDistOk = false ;
CalcDistCamera() ;
// ricalcolo ExtView
m_bExtViewOk = false ;
if ( ! CalcExtView())
return false ;
// calcolo nuovi dati di Z clipping
return CalcClippingPlanesFromExtView() ;
}
//----------------------------------------------------------------------------
void
Scene::GetCamera( double* pdAngVertDeg, double* pdAngOrizzDeg, double* pdDist) const
{
double dAngVertDeg ;
double dAngOrizzDeg ;
m_vtDirCamera.ToSpherical( nullptr, &dAngVertDeg, &dAngOrizzDeg) ;
if ( abs( dAngVertDeg) < EPS_ANG_SMALL) {
if ( m_bUpOk)
(-m_vtUp).ToSpherical( nullptr, nullptr, &dAngOrizzDeg) ;
else
dAngOrizzDeg = -90 ;
}
else if ( abs( dAngVertDeg - ANG_STRAIGHT) < EPS_ANG_SMALL) {
if ( m_bUpOk)
(m_vtUp).ToSpherical( nullptr, nullptr, &dAngOrizzDeg) ;
else
dAngOrizzDeg = 90 ;
}
if ( pdAngVertDeg != nullptr)
*pdAngVertDeg = dAngVertDeg ;
if ( pdAngOrizzDeg != nullptr)
*pdAngOrizzDeg = dAngOrizzDeg ;
if ( pdDist != nullptr)
*pdDist = m_dDistCamera ;
}
//----------------------------------------------------------------------------
int
Scene::GetCameraDir( void) const
{
Vector3d vtDir = m_vtDirCamera ;
vtDir.Rotate( Z_AX, - m_nOrizzOffsCamera * ANG_RIGHT) ;
if ( vtDir.IsZplus())
return CT_TOP ;
else if ( vtDir.IsYminus())
return CT_FRONT ;
else if ( vtDir.IsXplus())
return CT_RIGHT ;
else if ( vtDir.IsYplus())
return CT_BACK ;
else if ( vtDir.IsXminus())
return CT_LEFT ;
else if ( vtDir.IsZminus())
return CT_BOTTOM ;
else if ( AreSameVectorApprox( vtDir, Vector3d( - SQRT1_3, - SQRT1_3, SQRT1_3)))
return CT_ISO_SW ;
else if ( AreSameVectorApprox( vtDir, Vector3d( SQRT1_3, - SQRT1_3, SQRT1_3)))
return CT_ISO_SE ;
else if ( AreSameVectorApprox( vtDir, Vector3d( SQRT1_3, SQRT1_3, SQRT1_3)))
return CT_ISO_NE ;
else if ( AreSameVectorApprox( vtDir, Vector3d( - SQRT1_3, SQRT1_3, SQRT1_3)))
return CT_ISO_NW ;
else
return CT_NONE ;
}
//----------------------------------------------------------------------------
Point3d
Scene::GetProjectedCenter( void) const
{
Point3d ptVCen ;
if ( ! Project( m_ptCenter, ptVCen))
ptVCen.Set( 0, 0, 0) ;
return ptVCen ;
}
//----------------------------------------------------------------------------
bool
Scene::CalcDirUp( bool bUseOrizzOffsCamera)
{
// verifico se il calcolo è necessario
if ( m_bUpOk)
return true ;
// direzione perpendicolare giacente nel piano XY
// ( m_vtDirCamera è opposta alla direzione in cui si guarda)
Vector3d vtPerpXY = m_vtDirCamera ^ Z_AX ;
if ( ! vtPerpXY.Normalize()) {
vtPerpXY = -X_AX ;
if ( bUseOrizzOffsCamera)
vtPerpXY.Rotate( Z_AX, m_nOrizzOffsCamera * ANG_RIGHT) ;
}
// direzione Up
m_vtUp = vtPerpXY ^ m_vtDirCamera ;
m_bUpOk = m_vtUp.Normalize() ;
// invalido ExtView
m_bExtViewOk = false ;
return m_bUpOk ;
}
//----------------------------------------------------------------------------
bool
Scene::CalcCameraFrame( Frame3d& frView)
{
// verifico direzione camera Up
if ( ! CalcDirUp())
return false ;
// eseguo il calcolo
Vector3d vtZ = m_vtDirCamera ;
Vector3d vtY = m_vtUp ;
Vector3d vtX = vtY ^ vtZ ;
if ( ! frView.Set( m_ptCenter + m_dDistCamera * vtZ, vtX, vtY, vtZ))
return false ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::PanCamera( const Point3d& ptWinOld, const Point3d& ptWinNew)
{
// porto i due punti in coordinate mondo
double dOldZCenter ;
GetPixelZ( ptWinOld, dOldZCenter) ;
Point3d ptViewOld( ptWinOld.x, ptWinOld.y, dOldZCenter) ;
Point3d ptWorldOld ;
if ( ! UnProject( ptViewOld, ptWorldOld))
return false ;
double dNewZCenter ;
GetPixelZ( ptWinNew, dNewZCenter) ;
Point3d ptViewNew( ptWinNew.x, ptWinNew.y, dNewZCenter) ;
Point3d ptWorldNew ;
if ( ! UnProject( ptViewNew, ptWorldNew))
return false ;
// calcolo lo spostamento tra i due punti
Vector3d vtMove = ptWorldNew - ptWorldOld ;
// applico questo spostamento al centro di vista
SetCenter( GetCenter() - vtMove) ;
// se dolly aggiusto la distanza per non entrare negli oggetti
if ( ! m_bOrthographic && m_nPerspZoomType == ZT_DOLLY)
CalcDistCamera() ;
else
m_bDistOk = true ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::RotateCamera( const Point3d& ptWinOld, const Point3d& ptWinNew)
{
// angoli correnti della camera
double dAngVertDeg ;
double dAngOrizzDeg ;
GetCamera( &dAngVertDeg, &dAngOrizzDeg) ;
// incrementi
double dDeltaAngVertDeg = ( ptWinNew.y - ptWinOld.y) / m_nViewportH * 360 ;
double dDeltaAngOrizzDeg = ( ptWinNew.x - ptWinOld.x) / m_nViewportW * 360 ;
// calcolo nuovi angoli e limitazione dell'angolo verticale
const double MIN_ANG_VERT = 0.0 ;
const double MAX_ANG_VERT = 180.0 ;
dAngVertDeg -= dDeltaAngVertDeg ;
if ( dAngVertDeg < MIN_ANG_VERT)
dAngVertDeg = MIN_ANG_VERT ;
else if ( dAngVertDeg > MAX_ANG_VERT)
dAngVertDeg = MAX_ANG_VERT ;
dAngOrizzDeg -= dDeltaAngOrizzDeg ;
// imposto nuova direzione camera
return SetCamera( dAngVertDeg, dAngOrizzDeg, 0) ;
}
//----------------------------------------------------------------------------
bool
Scene::ZoomAll( void)
{
// aggiorno l'ingombro
UpdateExtension() ;
// traslo il centro di vista nel centro del box
Point3d ptExtCent ;
if ( ! m_b3ExtWorld.GetCenter( ptExtCent))
return false ;
m_ptCenter = ptExtCent ;
m_bExtViewOk = false ;
// calcolo nuovi dati di ingombro
CalcDimViewFromExtView() ;
if ( ! m_bOrthographic) {
if ( m_nPerspZoomType == ZT_DOLLY) {
// adatto la distanza della camera in modo che il fov resti al valore standard
m_dDistCamera = m_dHalfHeight / tan( PERSPECTIVE_STD_FOV * 0.5 * DEGTORAD) + ( m_b3ExtView.GetMax().z - m_b3ExtView.GetMin().z) * 0.5 ;
}
else {
// aggiusto la distanza della camera
m_b3ExtView.GetDiameter( m_dDistCamera) ;
// il valore di m_dHalfHeight calcolato dal box non garantisce che l'oggetto sia interamente contenuto nel frustum
// perchè è il valore in corrispondenza della faccia del box davanti alla camera. Per il calcolo del fov m_dHalfHeight
// deve essere calcolato in corrispondenza di m_ptCenter
// distanza della camera dalla faccia davanti del box
double dDist = m_dDistCamera - ( m_b3ExtView.GetMax().z - m_b3ExtView.GetMin().z) * 0.5 ;
// aggiorno le dimensioni
double dAspect = m_dHalfWidth / m_dHalfHeight ;
m_dHalfHeight = m_dHalfHeight / dDist * m_dDistCamera ;
m_dHalfWidth = m_dHalfHeight * dAspect ;
}
}
// la distanza della camera è calcolata correttamente
m_bDistOk = true ;
CalcClippingPlanesFromExtView() ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::ZoomObject( int nId)
{
// Verifico puntatore a DB geometrico
if ( m_pGeomDB == nullptr)
return false ;
// determino l'ingombro dell'oggetto/i in globale
BBox3d b3Obj ;
if ( nId == GDB_ID_SEL) {
int nMyId = m_pGeomDB->GetFirstSelectedObj() ;
while ( nMyId != GDB_ID_NULL) {
BBox3d b3Curr ;
if ( m_pGeomDB->GetGlobalBBox( nMyId, b3Curr, BBF_ONLY_VISIBLE))
b3Obj.Add( b3Curr) ;
nMyId = m_pGeomDB->GetNextSelectedObj() ;
}
}
else
m_pGeomDB->GetGlobalBBox( nId, b3Obj, BBF_ONLY_VISIBLE) ;
// recupero centro
Point3d ptCent ;
if ( ! b3Obj.GetCenter( ptCent))
return false ;
// determino le dimensioni di vista nel riferimento di vista
Frame3d frView ;
if ( ! CalcCameraFrame( frView))
return false ;
b3Obj.ToLoc( frView) ;
const double COEFF = 1.05 ;
double dHalfWidth = COEFF * ( b3Obj.GetMax().x - b3Obj.GetMin().x) / 2 ;
double dHalfHeight = COEFF * ( b3Obj.GetMax().y - b3Obj.GetMin().y) / 2 ;
// imposto il centro e le dimensioni di vista
m_ptCenter = ptCent ;
if ( ! AdjustDimView( dHalfWidth, dHalfHeight))
return false ;
if ( ! m_bOrthographic) {
// cfr conti analoghi in ZoomAll
if ( m_nPerspZoomType == ZT_DOLLY) {
m_dDistCamera = m_dHalfHeight / tan( PERSPECTIVE_STD_FOV * 0.5 * DEGTORAD) + ( b3Obj.GetMax().z - b3Obj.GetMin().z) * 0.5 ;
}
else {
// verifico di non finire dentro l'oggetto
double dDiam ; b3Obj.GetDiameter( dDiam) ;
if ( m_dDistCamera < dDiam * 0.5)
m_dDistCamera = dDiam * 0.5 ;
// distanza della camera dalla faccia davanti del box
double dDist = m_dDistCamera - ( b3Obj.GetMax().z - b3Obj.GetMin().z) * 0.5 ;
// ricalcolo le dimensioni
double dAspect = m_dHalfWidth / m_dHalfHeight ;
m_dHalfHeight = m_dHalfHeight / dDist * m_dDistCamera ;
m_dHalfWidth = m_dHalfHeight * dAspect ;
}
}
// la distanza della camera è calcolata per non finire dentro gli oggetti
m_bDistOk = true ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::ZoomRadius( double dRadius)
{
// adatto le dimensioni a quelle della vista
if ( ! AdjustDimView( dRadius, dRadius))
return false ;
// per il dolly va modificata la distanza dalla camera
if ( ! m_bOrthographic && m_nPerspZoomType == ZT_DOLLY) {
m_dDistCamera = m_dHalfHeight / tan( PERSPECTIVE_STD_FOV * 0.5 * DEGTORAD) ;
// verifico la distanza della camera
CalcDistCamera() ;
}
else
m_bDistOk = true ;
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::ZoomChange( double dCoeff)
{
const double MIN_COEFF = 0.5 ;
const double MAX_COEFF = 2 ;
// cambio le dimensioni di zoom
if ( ! m_bOrthographic && m_nPerspZoomType == ZT_DOLLY) {
// per il dolly va modificata la distanza della camera
m_dDistCamera *= dCoeff ;
}
else {
// controllo i limiti
dCoeff = clamp( dCoeff, MIN_COEFF, MAX_COEFF) ;
m_dHalfWidth *= dCoeff ;
m_dHalfHeight *= dCoeff ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Scene::ZoomOnPoint( const Point3d& ptWin, double dCoeff)
{
// leggo Z del pixel
double dWinZ ;
GetPixelZ( ptWin, dWinZ) ;
// porto il punto in coordinate mondo
Point3d ptView( ptWin.x, ptWin.y, dWinZ) ;
Point3d ptWorld ;
if ( ! UnProject( ptView, ptWorld))
return false ;
// modifico opportunamente il centro di vista
Point3d ptOldCen = m_ptCenter ;
Point3d ptNewCen = ptWorld + ( m_ptCenter - ptWorld) * dCoeff ;
ptNewCen += ( ptWorld - ptNewCen) * m_vtDirCamera * m_vtDirCamera ;
SetCenter( ptNewCen) ;
m_bDistOk = true ;
if ( ! m_bOrthographic) {
if ( m_nPerspZoomType == ZT_DOLLY) {
// nel caso di dolly verifico se il nuovo zoom fa entrare negli oggetti
double dMinDist = CalcMinCameraDistance() ;
if ( m_dDistCamera * dCoeff < dMinDist) {
// adatto il coefficiente di zoom e ricalcolo il centro
dCoeff = dMinDist / m_dDistCamera ;
Point3d ptNewCenter = ptWorld + ( ptOldCen - ptWorld) * dCoeff ;
SetCenter( ptNewCenter) ;
}
}
else {
// nel caso standard verifico se il nuovo fov supera il valore massimo
if ( m_dHalfHeight * dCoeff / m_dDistCamera > PERSPECTIVE_TAN_MAX_FOV) {
// adatto il coefficiente di zoom e ricalcolo il centro
dCoeff = PERSPECTIVE_TAN_MAX_FOV * m_dDistCamera / m_dHalfHeight ;
Point3d ptNewCenter = ptWorld + ( ptOldCen - ptWorld) * dCoeff ;
SetCenter( ptNewCenter) ;
}
}
}
return ZoomChange( dCoeff) ;
}
//----------------------------------------------------------------------------
bool
Scene::ZoomWin( const Point3d& ptWin1, const Point3d& ptWin2)
{
// leggo Z del pixel
double dWinZ ;
GetPixelZ( Media( ptWin1, ptWin2), dWinZ) ;
// porto i punti in coordinate mondo
Point3d ptWorld1 ;
if ( ! UnProject( Point3d( ptWin1.x, ptWin1.y, dWinZ), ptWorld1))
return false ;
Point3d ptWorld2 ;
if ( ! UnProject( Point3d( ptWin2.x, ptWin2.y, dWinZ), ptWorld2))
return false ;
// recupero il riferimento della camera (vista)
Frame3d frView ;
if ( ! CalcCameraFrame( frView))
return false ;
// porto i punti in coordinate camera (vista)
Point3d ptView1 = GetToLoc( ptWorld1, frView) ;
Point3d ptView2 = GetToLoc( ptWorld2, frView) ;
// imposto il nuovo centro di vista
Point3d ptNewCen = 0.5 * ( ptWorld1 + ptWorld2) ;
SetCenter( ptNewCen) ;
// imposto il nuovo zoom
double dHalfWidth = 0.5 * abs( ptView1.x - ptView2.x) ;
double dHalfHeight = 0.5 * abs( ptView1.y - ptView2.y) ;
// adatto le dimensioni a quelle della vista
if ( ! AdjustDimView( dHalfWidth, dHalfHeight))
return false ;
// per il dolly va modificata la distanza della camera
if ( ! m_bOrthographic && m_nPerspZoomType == ZT_DOLLY) {
m_dDistCamera = m_dHalfHeight / tan( PERSPECTIVE_STD_FOV * 0.5 * DEGTORAD) ;
CalcDistCamera() ;
}
else
m_bDistOk = true ;
return true ;
}
//----------------------------------------------------------------------------
void
Scene::GetOrthoCamParam( double* pdWidth, double* pdHeight, double* pdNear, double* pdFar) const
{
if ( pdWidth != nullptr)
*pdWidth = m_dHalfWidth ;
if ( pdHeight != nullptr)
*pdHeight = m_dHalfHeight ;
if ( pdNear != nullptr)
*pdNear = m_dZNear ;
if ( pdFar != nullptr)
*pdFar = m_dZFar ;
}
Reference in New Issue View Git Blame Copy Permalink