0
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
