24. OpenGL Camera Part 3

In this OpenGL tutorial, we are going to look at creating a third person camera. I searched long and hard on the internet for a way to do this using my old calculations or something at least similar, but I had no luck, so here is what I hope you will find to be a simple way around creating this.

First off, we are going to start off with the code from the second camera tutorial. I am going to start this tutorial, by adding only one new variable for our program, this is going to be the distance that the camera will be from our character/target object:

float cRadius = 10.0f;

Next off, I am going to remove the camera() function. For our third person camera to work, we need to work our camera in two different parts, first is the part that centres the character, and the second part is the part that draws the scenery, so one camera function is not sufficient as our camera code goes around our other code.

The first thing we need to do after our glLoadIdentity call, is to translate our camera behind our character/target by our cRadius value like so:

glTranslatef(0.0f, 0.0f, -cRadius);

Running this, you will see a red square in front of the view. Although now we need to add some rotation ^_^ The next line here is going to rotate our view for *both* our character and our scenery, upon creating this tutorial, it is this little bit that kept messing me up, I had seperate glLoadIdentity calls for our character camera, and our scene camera, but I realised I had to combine the two. This is going to rotate the view on the x axis so you can look down and up around the character (including seeing the top and bottom of the character):

glRotatef(xrot,1.0,0.0,0.0);

The next section of code in this tutorial is just to draw our character, we do this like so:

glColor3f(1.0f, 0.0f, 0.0f);
glutSolidCube(2); //Our character to follow

Now we need to rotate the camera on our y axis to look around the world. In this tutorial, the character/target rotates with the view so you will only ever see the back of it unless you look up and over the character:

glRotatef(yrot,0.0,1.0,0.0); //rotate our camera on the y-axis (left and right)

After this, we need to move our scene like in our previous tutorials, only this time, we are removing the ypos value, this will move the scenery as if you were using a first person camera, but because of the previous rotations and translations, our character/target will always be in the centre of the view:

glTranslated(-xpos,0.0f,-zpos); //translate the screen to the position of our camera

Then finally we just draw all our cubes ^_^

glColor3f(1.0f, 1.0f, 1.0f);
cube(); //call the cube drawing function

This camera not only supports basic movement, it also keeps in tact our strafing movements ^_^ I am still yet to add jumping, running and a bobbing effect (using cycloids).

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.
170.
171.
172.
173.
174.
175.
176. 		    #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 cRadius = 10.0f; // our radius distance from our character

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 + 1;
    positionx[i] = rand()%5 + 1;
    }
}

//draw the cube
void cube (void) {
    for (int i=0;i<10 – 1;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
    glEnable (GL_COLOR_MATERIAL);
    glShadeModel (GL_SMOOTH); //set the shader to smooth shader

}

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
    enable();
    
    glLoadIdentity();
    
    glTranslatef(0.0f, 0.0f, –cRadius);
    glRotatef(xrot,1.0,0.0,0.0);
    glColor3f(1.0f, 0.0f, 0.0f);
    glutSolidCube(2); //Our character to follow
    
    glRotatef(yrot,0.0,1.0,0.0);  //rotate our camera on the 
y-axis (up and down)
    glTranslated(–xpos,0.0f,–zpos); //translate the screen
 to the position of our camera
    glColor3f(1.0f, 1.0f, 1.0f);
    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, 0.1, 100.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;
}
Be Sociable, Share!

Related posts:

  1. 23. OpenGL Camera Part 2 Here I will be extending upon the previous OpenGL Camera...
  2. 22. OpenGL Camera If you look at making any game where the scene...
  3. 19. OpenGL Fullscreen Mode Most games we know, run in fullscreen mode, and lucky...
  4. 4. Terrain Triangle Strips We have a basic class setup to hold our terrain,...
  5. 2. Terrain Loading We have a basic class setup to hold our terrain,...

Written by

Leave a Reply

Your email address will not be published. Required fields are marked *