Jump to content
  • Advertisement
Sign in to follow this  

first-person camera

This topic is 3686 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

Hey, My doubt concerns this article: A Simple Quaternion-based camera. Specifically, this method:
void Camera::SetViewByMouse(void)
  // the coordinates of our mouse coordinates
  int MouseX, MouseY;

  // the middle of the screen in the x direction
  int MiddleX = SCREENWIDTH/2;

  // the middle of the screen in the y direction
  int MiddleY = SCREENHEIGHT/2;

  // vector that describes mouseposition - center
  Vector MouseDirection(0, 0, 0);

  // static variable to store the rotation about the x-axis, since
  // we want to limit how far up or down we can look.
  // We don't need to cap the rotation about the y-axis as we
  // want to be able to turn around 360 degrees
  static double CurrentRotationX = 0.0;

  // The maximum angle we can look up or down, in radians
  double maxAngle = 1;

  // This function gets the position of the mouse
  SDL_GetMouseState(&MouseX, &MouseY);

  // if the mouse hasn't moved, return without doing
  // anything to our view
  if((MouseX == MiddleX) && (MouseY == MiddleY))

  // otherwise move the mouse back to the middle of the screen
  SDL_WarpMouse(MiddleX, MiddleY);

  // get the distance and direction the mouse moved in x (in
  // pixels). We can't use the actual number of pixels in radians,
  // as only six pixels  would cause a full 360 degree rotation.
  // So we use a mousesensitivity variable that can be changed to
  // vary how many radians we want to turn in the x-direction for
  // a given mouse movement distance

  // We have to remember that positive rotation is counter-clockwise. 
  // Moving the mouse down is a negative rotation about the x axis
  // Moving the mouse right is a negative rotation about the y axis
  MouseDirection.x = (MiddleX - MouseX)/MouseSensitivity; 
  MouseDirection.y = (MiddleY - MouseY)/MouseSensitivity;

  CurrentRotationX += MouseDirection.y;
  // We don't want to rotate up more than one radian, so we cap it.
  if(CurrentRotationX > 1)
    CurrentRotationX = 1;
  // We don't want to rotate down more than one radian, so we cap it.
  if(CurrentRotationX < -1)
    CurrentRotationX = -1;
    // get the axis to rotate around the x-axis. 
    Vector Axis = CrossProduct(View - Position, Up);
    // To be able to use the quaternion conjugate, the axis to
    // rotate around must be normalized.
    Axis = Normalize(Axis);

    // Rotate around the y axis
    RotateCamera(MouseDirection.y, Axis.x, Axis.y, Axis.z);
    // Rotate around the x axis
    RotateCamera(MouseDirection.x, 0, 1, 0);

My problem is that my CurrentRotationX is only < 1 or > -1 for the first mouse movements, and then it goes >1 and the camera never moves again... Does anyone have any idea of what the problem might be ? Thanks

Share this post

Link to post
Share on other sites
Got it to "work" with gametutorial.com's code:

void Camera::onMousePassiveMotion(int x, int y)
int middleX = (int)_winWidth >> 1; // This is a binary shift to get half the width
int middleY = (int)_winHeight >> 1; // This is a binary shift to get half the height
float angleY = 0.0f; // This is the direction for looking up or down
float angleZ = 0.0f; // This will be the value we need to rotate around the Y axis (Left and Right)
static float currentRotX = 0.0f;

// If our cursor is still in the middle, we never moved... so don't update the screen
if( (x == middleX) && (y == middleY) ) return;

// Set the mouse position to the middle of our window
glutWarpPointer(middleX, middleY);

// Get the direction the mouse moved in, but bring the number down to a reasonable amount
angleY = (float)( (middleX - x) ) / 500.0f;
angleZ = (float)( (middleY - y) ) / 500.0f;

// Here we keep track of the current rotation (for up and down) so that
// we can restrict the camera from doing a full 360 loop.
currentRotX -= angleZ;

// If the current rotation (in radians) is greater than 1.0, we want to cap it.
if(currentRotX > 1.0f)
currentRotX = 1.0f;
// Check if the rotation is below -1.0, if so we want to make sure it doesn't continue
else if(currentRotX < -1.0f)
currentRotX = -1.0f;
// Otherwise, we can rotate the view around our position
// To find the axis we need to rotate around for up and down
// movements, we need to get a perpendicular vector from the
// camera's view vector and up vector. This will be the axis.
btVector3 tmp = _lookAt - _position;
btVector3 vAxis = tmp.cross(_up);
vAxis = vAxis.normalize();

// Rotate around our perpendicular axis and along the y-axis
RotateView(angleZ, vAxis[0], vAxis[1], vAxis[2]);

// Rotate around the y axis no matter what the currentRotX is
RotateView(angleY, 0, 1, 0);

However... the movement is VERY jerky... and not smooth at all...
Any ideas?

Thanks again!

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!