Movement camera with Mouse (GLUT)

Hi,

I have the class Camera:

Camera.h

//***************************************************************************
 //
 // Advanced CodeColony Camera
 // Philipp Crocoll, 2003
 //
 //***************************************************************************
 
 
 #include <GLUT/glut.h>
 #include <OpenGL/gl.h> // Need to include it here because the GL* types are required
 #define PI 3.1415926535897932384626433832795
 #define PIdiv180 (PI/180.0)
 
 /////////////////////////////////
 //Note: All angles in degrees //
 /////////////////////////////////
 
 struct SF3dVector //Float 3d-vect, normally used
 {
 GLfloat x,y,z;
 };
 struct SF2dVector
 {
 GLfloat x,y;
 };
 SF3dVector F3dVector ( GLfloat x, GLfloat y, GLfloat z );
 
 class CCamera
 {
 private:
 
 SF3dVector ViewDir;
 SF3dVector RightVector;
 SF3dVector UpVector;
 SF3dVector Position;
 
 GLfloat RotatedX, RotatedY, RotatedZ;
 
 public:
 CCamera(); //inits the values (Position: (0|0|0) Target: (0|0|-1) )
 void Render ( void ); //executes some glRotates and a glTranslate command
 //Note: You should call glLoadIdentity before using Render
 
 void Move ( SF3dVector Direction );
 void RotateX ( GLfloat Angle );
 void RotateY ( GLfloat Angle );
 void RotateZ ( GLfloat Angle );
 
 void MoveForward ( GLfloat Distance );
 void MoveUpward ( GLfloat Distance );
 void StrafeRight ( GLfloat Distance );
 
 
 };

Camera.cpp

#include "camera.h"
 #include <math.h>
 #include <iostream>
 
 #define SQR(x) (x*x)
 
 #define NULL_VECTOR F3dVector(0.0f,0.0f,0.0f)
 
 SF3dVector F3dVector ( GLfloat x, GLfloat y, GLfloat z )
 {
 SF3dVector tmp;
 tmp.x = x;
 tmp.y = y;
 tmp.z = z;
 return tmp;
 }
 
 GLfloat GetF3dVectorLength( SF3dVector * v)
 {
 return (GLfloat)(sqrt(SQR(v->x)+SQR(v->y)+SQR(v->z)));
 }
 
 SF3dVector Normalize3dVector( SF3dVector v)
 {
 SF3dVector res;
 float l = GetF3dVectorLength(&v);
 if (l == 0.0f) return NULL_VECTOR;
 res.x = v.x / l;
 res.y = v.y / l;
 res.z = v.z / l;
 return res;
 }
 
 SF3dVector operator+ (SF3dVector v, SF3dVector u)
 {
 SF3dVector res;
 res.x = v.x+u.x;
 res.y = v.y+u.y;
 res.z = v.z+u.z;
 return res;
 }
 SF3dVector operator- (SF3dVector v, SF3dVector u)
 {
 SF3dVector res;
 res.x = v.x-u.x;
 res.y = v.y-u.y;
 res.z = v.z-u.z;
 return res;
 }
 
 
 SF3dVector operator* (SF3dVector v, float r)
 {
 SF3dVector res;
 res.x = v.x*r;
 res.y = v.y*r;
 res.z = v.z*r;
 return res;
 }
 
 SF3dVector CrossProduct (SF3dVector * u, SF3dVector * v)
 {
 SF3dVector resVector;
 resVector.x = u->y*v->z - u->z*v->y;
 resVector.y = u->z*v->x - u->x*v->z;
 resVector.z = u->x*v->y - u->y*v->x;
 
 return resVector;
 }
 float operator* (SF3dVector v, SF3dVector u) //dot product
 {
 return v.x*u.x+v.y*u.y+v.z*u.z;
 }
 
 
 
 
 /***************************************************************************************/
 
 CCamera::CCamera()
 {
 //Init with standard OGL values:
 Position = F3dVector (0.0, 0.0, 0.0);
 ViewDir = F3dVector( 0.0, 0.0, -1.0);
 RightVector = F3dVector (1.0, 0.0, 0.0);
 UpVector = F3dVector (0.0, 1.0, 0.0);
 
 //Only to be sure:
 RotatedX = RotatedY = RotatedZ = 0.0;
 }
 
 void CCamera::Move (SF3dVector Direction)
 {
 Position = Position + Direction;
 }
 
 void CCamera::RotateX (GLfloat Angle)
 {
 RotatedX += Angle;
 
 //Rotate viewdir around the right vector:
 ViewDir = Normalize3dVector(ViewDir*cos(Angle*PIdiv180)
 + UpVector*sin(Angle*PIdiv180));
 
 //now compute the new UpVector (by cross product)
 UpVector = CrossProduct(&ViewDir, &RightVector)*-1;
 
 
 }
 
 void CCamera::RotateY (GLfloat Angle)
 {
 RotatedY += Angle;
 
 //Rotate viewdir around the up vector:
 ViewDir = Normalize3dVector(ViewDir*cos(Angle*PIdiv180)
 - RightVector*sin(Angle*PIdiv180));
 
 //now compute the new RightVector (by cross product)
 RightVector = CrossProduct(&ViewDir, &UpVector);
 }
 
 void CCamera::RotateZ (GLfloat Angle)
 {
 RotatedZ += Angle;
 
 //Rotate viewdir around the right vector:
 RightVector = Normalize3dVector(RightVector*cos(Angle*PIdiv180)
 + UpVector*sin(Angle*PIdiv180));
 
 //now compute the new UpVector (by cross product)
 UpVector = CrossProduct(&ViewDir, &RightVector)*-1;
 }
 
 void CCamera::Render( void )
 {
 
 //The point at which the camera looks:
 SF3dVector ViewPoint = Position+ViewDir;
 
 //as we know the up vector, we can easily use gluLookAt:
 gluLookAt( Position.x,Position.y,Position.z,
 ViewPoint.x,ViewPoint.y,ViewPoint.z,
 UpVector.x,UpVector.y,UpVector.z);
 
 }
 
 void CCamera::MoveForward( GLfloat Distance )
 {
 Position = Position + (ViewDir*-Distance);
 }
 
 void CCamera::StrafeRight ( GLfloat Distance )
 {
 Position = Position + (RightVector*Distance);
 }
 
 void CCamera::MoveUpward( GLfloat Distance )
 {
 Position = Position + (UpVector*Distance);
 }

I'm moving the camera by keyboard, but I'm now trying to use the functions of the class to move with the mouse (like the ghost of half-life, counter-strike, Unreal, ...)

My functions of mouse with GLUT:


 
 void mouseMove(int x, int y) 
 { 
 
 }
 
 void mouseButton(int button, int state, int x, int y) 
 {
 
 }
 
 void processNormalKeys(unsigned char key, int xx, int yy) 
 { 
 switch (key) {
 case 'w':
 Camera.MoveForward(-0.1) ;
 renderScene();
 break;
 case 's':
 Camera.MoveForward(0.1) ;
 renderScene();
 break;
 case 'x':
 Camera.RotateX(5.0);
 renderScene();
 break;
 case 'y':
 Camera.RotateX(-5.0);
 renderScene();
 break;
 case 'a':
 Camera.StrafeRight(-0.1);
 renderScene();
 break;
 case 'd':
 Camera.StrafeRight(0.1);
 renderScene();
 break;
 case 'q':
 Camera.MoveUpward(-0.3);
 renderScene();
 break;
 case 'e':
 Camera.MoveUpward(0.3);
 renderScene();
 break;
 case 'h':
 if(help)
 help = false;
 else
 help = true;
 break;
 }
 if (key == 27)
 exit(0);
 
 } 
 
 void pressKey(int key, int xx, int yy) 
 {
 switch (key) {
 case GLUT_KEY_LEFT : 
 Camera.StrafeRight(-0.1);
 renderScene();
 break;
 case GLUT_KEY_RIGHT : 
 Camera.StrafeRight(0.1);
 renderScene();
 break;
 case GLUT_KEY_UP : 
 Camera.MoveForward(-0.1);
 renderScene();
 break;
 case GLUT_KEY_DOWN :
 Camera.MoveForward(0.1);
 renderScene();
 break;
 }
 } 
 
 //Main...
 glutKeyboardFunc(processNormalKeys);
 glutSpecialFunc(pressKey);
 glutSpecialUpFunc(releaseKey);
 
 glutMouseFunc(mouseButton);
 glutMotionFunc(mouseMove);

Could anyone help me?

Thanks

I think you need to be a bit more specific about what exactly you need help with. Are you unsure as to how to implement the glut
mouse functions? Or are you not sure how to calculate the camera rotation based off the mouse position instead of the arrow keys?
For mouse coordinates look up glutPassiveMotionFunc and glutWarpPointer. There are also a few good tutorials on this for glut, for example
the one up at Lighthouse3d http://www.lighthouse3d.com/tutorials/glut-tutorial/the-mouse/. There is an entire subsection for glut that
covers camera moverment quite well, amongst other things. If your programming skills are alright you should be able to change
up your curent camera code to suit your needs, otherwise I would highly suggest going through the camera tutorials from the begining of
the keyboard area to get a better understanding of whats going on. Hope something here will help!

Topic Locked