NeL: NL3D::CEvent3dMouseListener class Reference

00090 {
+00091         CEventMouse* mouseEvent=(CEventMouse*)&event;
+00092         if (event==EventMouseMoveId)
+00093         {
+00094                 bool bRotate=false;
+00095                 bool bTranslateXY=false;
+00096                 bool bTranslateZ=false;
+00097                 bool bZoom=false;
+00098                 
+00099 
+00100                 // Rotate Axis
+00101                 CVector axis;
+00102 
+00103                 if (_MouseMode==nelStyle)
+00104                 {
+00105                         bRotate=(mouseEvent->Button==(ctrlButton|rightButton));
+00106                         bTranslateXY=(mouseEvent->Button==(ctrlButton|leftButton));
+00107                         bTranslateZ=(mouseEvent->Button==(ctrlButton|shiftButton|leftButton));
+00108                         bZoom=(mouseEvent->Button==(altButton|leftButton));
+00109                         axis=_HotSpot;
+00110                 }
+00111                 else if (_MouseMode==edit3d)
+00112                 {
+00113                         bRotate=(mouseEvent->Button==(altButton|middleButton)) || (mouseEvent->Button==(altButton|leftButton));
+00114                         bTranslateXY=(mouseEvent->Button==(ctrlButton|leftButton)) || (mouseEvent->Button==middleButton);
+00115                         bTranslateZ=(mouseEvent->Button==(ctrlButton|shiftButton|leftButton)) || (mouseEvent->Button==(ctrlButton|middleButton));
+00116                         bZoom=(mouseEvent->Button==(shiftButton|leftButton)) || (mouseEvent->Button==(ctrlButton|altButton|middleButton));
+00117                         axis=_HotSpot;
+00118                 }
+00119                 else // if (_MouseMode==firstPerson)
+00120                 {
+00121                         bRotate=(mouseEvent->Button&leftButton)!=0;
+00122                         bTranslateXY=false;
+00123                         bTranslateZ=false;
+00124                         bZoom=false;
+00125                         axis=_Matrix.getPos();
+00126                 }
+00127 
+00128                 if (bRotate)
+00129                 {
+00130                         if (!_EnableModelMatrixEdition)
+00131                         {                                                       
+00132                                 // First in the hotSpot
+00133                                 CMatrix comeFromHotSpot=_Matrix;
+00134                                 comeFromHotSpot.setPos (axis);
+00135 
+00136                                 // Then turn along the Z axis with X mouse
+00137                                 CMatrix turnZ;
+00138                                 turnZ.identity();
+00139                                 turnZ.rotateZ ((float) Pi*2.f*(_X-mouseEvent->X));
+00140 
+00141                                 // Then turn along the X axis with Y mouse
+00142                                 CMatrix turnX;
+00143                                 turnX.identity();
+00144                                 turnX.rotateX ((float) Pi*2.f*(mouseEvent->Y-_Y));
+00145 
+00146                                 // Then come back from hotspot
+00147                                 CMatrix goToHotSpot=comeFromHotSpot;
+00148                                 goToHotSpot.invert();
+00149 
+00150                                 // Make the matrix
+00151                                 CMatrix negPivot, Pivot;
+00152                                 negPivot.identity();
+00153                                 negPivot.setPos (-axis);
+00154                                 Pivot.identity();
+00155                                 Pivot.setPos (axis);
+00156 
+00157                                 // Make this transformation \\//
+00158                                 //_Matrix=Pivot*turnZ*negPivot*comeFromHotSpot*turnX*goToHotSpot*_Matrix;
+00159                                 Pivot*=turnZ;
+00160                                 Pivot*=negPivot;
+00161                                 Pivot*=comeFromHotSpot;
+00162                                 Pivot*=turnX;
+00163                                 Pivot*=goToHotSpot;
+00164 
+00165                                 
+00166                                 Pivot*=_Matrix;
+00167                                 _Matrix=Pivot;                                          
+00168                                 // Normalize, too much transformation could give an ugly matrix..
+00169                                 _Matrix.normalize (CMatrix::XYZ);                       
+00170                         
+00171                         }
+00172                         else
+00173                         {
+00174                                 CVector pos = _ModelMatrix.getPos() ;
+00175                                 NLMISC::CQuat r ;
+00176                                 switch (_CurrentModelRotationAxis)
+00177                                 {
+00178                                         case xAxis : r = CQuat(CAngleAxis(_ModelMatrix.getI(), (float) Pi*2.f*(_X-mouseEvent->X))) ; break ;
+00179                                         case yAxis : r = CQuat(CAngleAxis(_ModelMatrix.getJ(), (float) Pi*2.f*(_X-mouseEvent->X))) ; break ;
+00180                                         case zAxis : r = CQuat(CAngleAxis(_ModelMatrix.getK(), (float) Pi*2.f*(_X-mouseEvent->X))) ; break ;
+00181                                 } ;
+00182 
+00183                         
+00184                                 CMatrix rm ;
+00185                                 rm.rotate(r) ;
+00186 
+00187                                 _ModelMatrix = rm * _ModelMatrix ;
+00188                                 _ModelMatrix.setPos(pos) ;
+00189 
+00190                                 _ModelMatrix.normalize (CMatrix::XYZ);
+00191                         }
+00192                 }
+00193 
+00194 
+00195                 if (bTranslateXY||bTranslateZ||bZoom)
+00196                 {
+00197                         // Move in plane
+00198 
+00199                         CPlane plane;
+00200 
+00201                         // For precision problem, do all the compute local to the hotspot/model.
+00202                         CVector         decal;
+00203 
+00204                         // Plane of the hotspot
+00205                         if (! _EnableModelMatrixEdition)
+00206                         {                       
+00207                                 decal= axis;
+00208                         }
+00209                         else
+00210                         {                       
+00211                                 decal= _ModelMatrix.getPos();
+00212                         }
+00213                         // Choose plane to move on
+00214                         if (bTranslateXY && _TranslateXYInWorld)
+00215                         {
+00216                                 plane.make (CVector::K, CVector::Null);
+00217                         }
+00218                         else
+00219                         {
+00220                                 plane.make (_Matrix.getJ(), CVector::Null);
+00221                         }
+00222 
+00223 
+00224                         // Get ray from mouse point
+00225                         CMatrix         localViewMatrix= _Matrix;
+00226                         localViewMatrix.setPos(_Matrix.getPos() - decal);
+00227                         CVector localPoint1, localPoint2;
+00228                         CVector pos, dir;
+00229                         _Viewport.getRayWithPoint (_X, _Y, pos, dir, localViewMatrix, _Frustrum);
+00230                         localPoint1=plane.intersect (pos, pos+dir);
+00231                         _Viewport.getRayWithPoint (mouseEvent->X, mouseEvent->Y, pos, dir, localViewMatrix, _Frustrum);
+00232                         localPoint2=plane.intersect (pos, pos+dir);
+00233 
+00234                         // Move the camera
+00235                         if (bTranslateXY)
+00236                         {
+00237                                 if (! _EnableModelMatrixEdition)
+00238                                 {
+00239                                         _Matrix.setPos(_Matrix.getPos()+localPoint1-localPoint2);
+00240                                 }
+00241                                 else
+00242                                 {
+00243                                         CVector dir =  - localPoint1 + localPoint2 ;
+00244                                         // transform the translation as needed.
+00245                                         dir= _ModelMatrixTransformMove * dir;
+00246                                         truncateVect(dir) ;
+00247                                         _ModelMatrix.setPos(_ModelMatrix.getPos()+dir);
+00248                                 }
+00249                         }
+00250                         else if (bTranslateZ)
+00251                         {
+00252                                 CVector vect=localPoint1-localPoint2;
+00253                                 if (! _EnableModelMatrixEdition)
+00254                                 {
+00255                                         _Matrix.setPos(_Matrix.getPos()+_Matrix.getK()*(vect.x+vect.y+vect.z));
+00256                                 }
+00257                                 else
+00258                                 {
+00259                                         CVector dir = _Matrix.getK()*(vect.x+vect.y+vect.z) ;
+00260                                         // transform the translation as needed.
+00261                                         dir= _ModelMatrixTransformMove * dir;
+00262                                         truncateVect(dir) ;
+00263                                         _ModelMatrix.setPos(_ModelMatrix.getPos()+dir);
+00264                                 }
+00265                         }
+00266                         else if (bZoom)
+00267                         {
+00268                                 CVector vect=localPoint1-localPoint2;
+00269                                 CVector direc=axis-_Matrix.getPos();
+00270                                 direc.normalize();
+00271                                 if (! _EnableModelMatrixEdition)
+00272                                 {
+00273                                         _Matrix.setPos(_Matrix.getPos()+direc*(vect.x+vect.y+vect.z));
+00274                                 }
+00275                                 else
+00276                                 {
+00277                                         // transform the translation as needed.
+00278                                         direc= _ModelMatrixTransformMove * direc;
+00279                                         direc.normalize();
+00280                                         _ModelMatrix.setPos(_ModelMatrix.getPos()+direc*(vect.x+vect.y+vect.z));
+00281                                 }
+00282                         }
+00283                 }
+00284                 
+00285 
+00286                 // Update mouse position
+00287                 _X=mouseEvent->X;
+00288                 _Y=mouseEvent->Y;
+00289         }
+00290         else if (event==EventMouseDownId)
+00291         {
+00292                 // Update mouse position
+00293                 _X=mouseEvent->X;
+00294                 _Y=mouseEvent->Y;
+00295         }
+00296         else if (event==EventMouseUpId)
+00297         {
+00298                 // Update mouse position
+00299                 _X=mouseEvent->X;
+00300                 _Y=mouseEvent->Y;
+00301         }
+00302         else if (event==EventMouseWheelId)
+00303         {
+00304                 // Zoom..
+00305                 CEventMouseWheel* mouseEvent=(CEventMouseWheel*)&event;
+00306 
+00307                 CVector direc=_HotSpot-_Matrix.getPos();
+00308                 if (! _EnableModelMatrixEdition)
+00309                 {
+00310                         _Matrix.setPos(_Matrix.getPos()+direc*(mouseEvent->Direction?0.1f:-0.1f));
+00311                 }
+00312                 else
+00313                 {
+00314                         CVector dir = direc*(mouseEvent->Direction?0.1f:-0.1f) ;
+00315                         // transform the translation as needed.
+00316                         dir= _ModelMatrixTransformMove * dir;
+00317                         truncateVect(dir) ;
+00318                         _ModelMatrix.setPos(_ModelMatrix.getPos() + dir);
+00319                 }
+00320         }
+00321 }
+


Setup
enum	TAxis { xAxis = 0, +yAxis = 1, +zAxis = 2 + }
void	enableModelMatrixEdition (bool enable=true)
	enable / disable model matrix edition mode. (the default deals with the with matrix)
void	enableModelTranslationAxis (TAxis axis, bool enabled)
void	enableTranslateXYInWorld (bool enabled)
TAxis	getModelMatrixRotationAxis (void) const
	get the current axe of rotation for the model matrix
void	getModelMatrixTransformMove (NLMISC::CMatrix &transModelMove) const
	see setModelMatrixTransformMove
bool	isModelTranslationEnabled (TAxis axis)
bool	isTranslateXYInWorldEnabled () const
void	setFrustrum (const CFrustum &frustrum)
void	setHotSpot (const CVector &hotSpot)
void	setMatrix (const NLMISC::CMatrix &matrix)
void	setModelMatrix (const NLMISC::CMatrix &matrix)
void	setModelMatrixRotationAxis (TAxis axis)
	set the current axe of rotation for the model matrix
void	setModelMatrixTransformMove (const NLMISC::CMatrix &transModelMove)
void	setMouseMode (TMouseMode mouseMode)
void	setSpeed (float speed)
void	setViewport (const NL3D::CViewport &viewport)
Get
void	addToServer (NLMISC::CEventServer &server)
CVector	getHotSpot () const
const NLMISC::CMatrix &	getModelMatrix ()
const NLMISC::CMatrix &	getViewMatrix ()
void	removeFromServer (NLMISC::CEventServer &server)
virtual void	operator() (const NLMISC::CEvent &event)
	Internal use.
void	truncateVect (CVector &v)
NLMISC::CEventListenerAsync	_AsyncListener
TAxis	_CurrentModelRotationAxis
bool	_EnableModelMatrixEdition
CFrustum	_Frustrum
CVector	_HotSpot
uint64	_LastTime
bool	_LeftPushed
CMatrix	_Matrix
bool	_MiddlePushed
CMatrix	_ModelMatrix
CMatrix	_ModelMatrixTransformMove
TMouseMode	_MouseMode
bool	_RightPushed
float	_Speed
bool	_TranslateXYInWorld
NL3D::CViewport	_Viewport
float	_X
bool	_XModelTranslateEnabled
float	_Y
bool	_YModelTranslateEnabled
bool	_ZModelTranslateEnabled
Public Types
enum	TMouseMode { nelStyle, +edit3d, +firstPerson + }
Public Member Functions
	CEvent3dMouseListener ()
virtual void	operator() (const CEvent &event)=0
virtual	~CEvent3dMouseListener ()

NL3D::CEvent3dMouseListener Class Reference

Detailed Description

Setup

Get

Public Types

Public Member Functions

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation