Mar 10
25

23. OpenGL Camera Part 2

11 Comments



In this opengl camera tutorial you will learn how to incorporate
the mouse using the glut mouse functions, to move our opengl camera like in a first person shooter, along with how to implement the strafe (sideways movement) you see in these games also.

To add the strafe we use:
if (key==’d')
{
float yrotrad;
yrotrad = (yrot / 180 * 3.141592654f);
xpos += float(cos(yrotrad)) * 0.2;
zpos += float(sin(yrotrad)) * 0.2;
}

if (key==’a')
{
float yrotrad;
yrotrad = (yrot / 180 * 3.141592654f);
xpos -= float(cos(yrotrad)) * 0.2;
zpos -= float(sin(yrotrad)) * 0.2;
}

You can see that I have simply flipped the cos and sin functions
and set both the xpos and zpos to either a negative or a positive

Now the mouse is a little easier as it uses no trigonometry.

We have to add a function which I have called: mouseMovement
void mouseMovement(int x, int y) {
int diffx=x-lastx; //check the difference between the current x and the last x position
int diffy=y-lasty; //check the difference between the current y and the last y position
lastx=x; //set lastx to the current x position
lasty=y; //set lasty to the current y position
xrot += (float) diffy; //set the xrot to xrot with the addition of the difference in the y position
yrot += (float) diffx;// set the xrot to yrot with the addition of the difference in the x position
}

To get GLUT to register the mouse movements, we call the line:
glutPassiveMotionFunc(mouseMovement);
to see where the mouse is when no mouse button is pressed and call
any functions within our mouseMovement function.

And that does it…

You now know how to add a strafe movement and mouse view.
The next camera tutorial will have lean, jump and duck effects.

If you have any questions, email me at swiftless@gmail.com

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169. 		    #include <GL/gl.h>
#include <GL/glut.h>
#include <stdlib.h>
#include <math.h>

//angle of rotation
float xpos = 0, ypos = 0, zpos = 0, xrot = 0, yrot = 0, angle=0.0;

float lastx, lasty;

//positions of the cubes
float positionz[10];
float positionx[10];

void cubepositions (void) { //set the positions of the cubes

    for (int i=0;i<10;i++)
    {
    positionz[i] = rand()%5 + 5;
    positionx[i] = rand()%5 + 5;
    }
}

//draw the cube
void cube (void) {
    for (int i=0;i<10;i++)
    {
    glPushMatrix();
    glTranslated(-positionx[i + 1] * 10, 0, -positionz[i + 1] *
10); //translate the cube
    glutSolidCube(2); //draw the cube
    glPopMatrix();
    }
}

void init (void) {
cubepositions();
}

void enable (void) {
    glEnable (GL_DEPTH_TEST); //enable the depth testing
    glEnable (GL_LIGHTING); //enable the lighting
    glEnable (GL_LIGHT0); //enable LIGHT0, our Diffuse Light
    glShadeModel (GL_SMOOTH); //set the shader to smooth shader

}

void camera (void) {
    glRotatef(xrot,1.0,0.0,0.0);  //rotate our camera on teh 
x-axis (left and right)
    glRotatef(yrot,0.0,1.0,0.0);  //rotate our camera on the 
y-axis (up and down)
    glTranslated(-xpos,-ypos,-zpos); //translate the screen
 to the position of our camera
}

void display (void) {
    glClearColor (0.0,0.0,0.0,1.0); //clear the screen to 
black
    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /
/clear the color buffer and the depth buffer
    glLoadIdentity();  
    camera();
    enable();
    cube(); //call the cube drawing function
    glutSwapBuffers(); //swap the buffers
    angle++; //increase the angle
}

void reshape (int w, int h) {
    glViewport (0, 0, (GLsizei)w, (GLsizei)h); //set the viewport
 to the current window specifications
    glMatrixMode (GL_PROJECTION); //set the matrix to projection

    glLoadIdentity ();
    gluPerspective (60, (GLfloat)w / (GLfloat)h, 1.0, 1000.0
); //set the perspective (angle of sight, width, height, , 
depth)
    glMatrixMode (GL_MODELVIEW); //set the matrix back to model

}

void keyboard (unsigned char key, int x, int y) {
    if (key==‘q’)
    {
    xrot += 1;
    if (xrot >360) xrot -= 360;
    }

    if (key==‘z’)
    {
    xrot -= 1;
    if (xrot < -360) xrot += 360;
    }

    if (key==‘w’)
    {
    float xrotrad, yrotrad;
    yrotrad = (yrot / 180 * 3.141592654f);
    xrotrad = (xrot / 180 * 3.141592654f);
    xpos += float(sin(yrotrad)) ;
    zpos -= float(cos(yrotrad)) ;
    ypos -= float(sin(xrotrad)) ;
    }

    if (key==‘s’)
    {
    float xrotrad, yrotrad;
    yrotrad = (yrot / 180 * 3.141592654f);
    xrotrad = (xrot / 180 * 3.141592654f);
    xpos -= float(sin(yrotrad));
    zpos += float(cos(yrotrad)) ;
    ypos += float(sin(xrotrad));
    }

    if (key==‘d’)
    {
    float yrotrad;
    yrotrad = (yrot / 180 * 3.141592654f);
    xpos += float(cos(yrotrad)) * 0.2;
    zpos += float(sin(yrotrad)) * 0.2;
    }

    if (key==‘a’)
    {
    float yrotrad;
    yrotrad = (yrot / 180 * 3.141592654f);
    xpos -= float(cos(yrotrad)) * 0.2;
    zpos -= float(sin(yrotrad)) * 0.2;
    }

    if (key==27)
    {
    exit(0);
    }
}

void mouseMovement(int x, int y) {
    int diffx=x-lastx; //check the difference between the 
current x and the last x position
    int diffy=y-lasty; //check the difference between the 
current y and the last y position
    lastx=x; //set lastx to the current x position
    lasty=y; //set lasty to the current y position
    xrot += (float) diffy; //set the xrot to xrot with the addition
 of the difference in the y position
    yrot += (float) diffx;    //set the xrot to yrot with the addition
 of the difference in the x position
}

int main (int argc, char **argv) {
    glutInit (&argc, argv);
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_DEPTH);
    glutInitWindowSize (500, 500);
    glutInitWindowPosition (100, 100);
    glutCreateWindow (“A basic OpenGL Window“);
    init ();
    glutDisplayFunc (display);
    glutIdleFunc (display);
    glutReshapeFunc (reshape);

    glutPassiveMotionFunc(mouseMovement); //check for mouse
 movement

    glutKeyboardFunc (keyboard);
    glutMainLoop ();
    return 0;
}

Related posts:

  1. 24. OpenGL Camera Part 3
  2. 22. OpenGL Camera
  3. 19. OpenGL Fullscreen Mode
  4. 2. Terrain Loading
  5. 4. Terrain Triangle Strips

Tags: , , ,


This entry was posted on March 25, 2010 at 6:17 am. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.

Posted in OpenGL by Swiftless 11 Comments

11 Responses to "23. OpenGL Camera Part 2"

  • drew says:
    May 23, 2011 at 3:22 am
    Reply

    In Code::Blocks, you need to replace the single quotation marks. But good overall code!!!

  • Glut Camera/stray error: need tutorial/advice says:
    May 22, 2011 at 9:52 am
    Reply

    [...] 23 Code is adapted from: 23. OpenGL Camera Part 2 | Swiftless Tutorials [...]

  • Joshua says:
    May 17, 2011 at 5:50 am
    Reply

    This implementation has gimbal lock

    • Swiftless says:
      May 20, 2011 at 11:49 am
      Reply

      Hi Joshua,

      It doesn’t technically have gimbal lock when you first start, it can however suffer from gimbal lock. This is only a starter, as we don’t want to scare people away with quaternions straight away.

      Cheers,
      Swiftless

  • Simple OpenGL Keyboard and Mouse FPS Controls | r3dux.org says:
    May 13, 2011 at 9:49 am
    Reply

    [...] SuperBible and did some googling, where I came across Swiftless‘ camera tutorials (Part 1, Part 2, Part 3) which gave me a really good start (Thank you, Swiftless!) on how to manipulate the [...]

  • Enrico says:
    April 20, 2011 at 7:26 pm
    Reply

    Hi, two suggestions:

    - if you include math.h you can use the M_PI define for the pi angle.
    - you are moving the modelview around, it’s incorrect, you want to move the camera, so in the display you should traslate and rotate the GL_PROJECTION, and then before the return point, set the GL_MODELVIEW again. Obviously, if you do this you have to change all the functions, but it’s the correct way.

    Anyway very good tutorial keep up the good work!

    • Swiftless says:
      April 21, 2011 at 10:28 am
      Reply

      Hi Enrico,

      That’s definitely true about math.h and M_PI!

      As for saying what I’m doing is incorrect, I hate to disappoint, but there is absolutely nothing wrong with it. In fact, it is a lot riskier to mess around with your GL_PROJECTION matrix and debugging your camera code can be a massive pain. The GL_PROJECTION matrix defines the projection from 3D to 2D on our screen, not where we are in our 3D scene.

      As a camera moves around a 3D scene, it makes a lot more sense to move the objects around the point of projection, to me that makes more sense anyway.

      I recommend you take a look at the following article on GL_PROJECTION abuse:
      http://www.sjbaker.org/steve/omniv/projection_abuse.html

      Cheers,
      Swiftless

  • Grugi says:
    April 10, 2011 at 6:30 am
    Reply

    Really good. It helped me a lot. I’m working OpenGL with SDL instead GLUT, but that strafe movement was what I wanted to learn how to implement.
    I was using gluLookAt() to try to do that, but I understood the way you did. Thanks!

  • Jake says:
    June 21, 2010 at 6:40 am
    Reply

    Hello,

    I am working on a project that involves being able to walk around a scene using the asdw keys and looking around using the arrow keys. I just recently added lighting effects to the mix. I also have a variable ‘mode’ that determines whether the scene is viewed in orthogonal mode or perspective mode. In orthogonal mode, I not able to change the position of the camera or eye (however you wanna think of it). You can only walk around in the perspective mode. When in orthogonal mode, the lighting effects work. But as soon as I switch to perspective mode, it is as if I never applied the lighting effects. The global ambiance is back and light intensities do not change. Would you have any insight as to why this would be happening. I was wondering if it had anything to do with the specific method you used to create the first person perspective as opposed to using something like gluLookAt(). Thanks

  • Oukara says:
    April 26, 2010 at 8:00 am
    Reply

    Bonjour,
    D’abord je vous remercie sur votre code qui’est vraiment intéressant, et qui m’a aidé vraiment.
    Pourriez vous faire un autre tutorial sur linteraction multitouch avce glut et opengl.
    et merci

Leave a Comment

Improve the web with Nofollow Reciprocity.