Jump to content
  • Advertisement
Sign in to follow this  
VitaliBR

OpenGL Movement camera with Mouse (GLUT)

This topic is 2480 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

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

Share this post


Link to post
Share on other sites
Advertisement
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!

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!