#### Archived

This topic is now archived and is closed to further replies.

# First Person Camera

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

## Recommended Posts

I''m playing around with OpenGL now, and I thought I''d try to make a simple (VERY simple) first person camera. As far as I can tell, it works to a small extent. (You can only move backwards.) I doubt this is how most of them work, but am I headed in the right direction? NOTE: I put all this in a seperate .cpp and have it connected to the main OpenGL .cpp. #include #include #include #include int Rendering() // also handles moving { static GLfloat ccx = 0.0f; static GLfloat ccy = 0.0f; static GLfloat ccz = 0.0f; static GLfloat cx; static GLfloat cy; static GLfloat cz; WINGDIAPI void APIENTRY glTranslatef (GLfloat x, GLfloat y, GLfloat z); { } if(GetAsyncKeyState( VK_DOWN )) { cz = ccz - 0.5f; ccz = cz; } glTranslatef(cx, cy, cz); glBegin(GL_TRIANGLES); glVertex3f(0.0f,0.0f,0.0f); glVertex3f(1.0f,0.0f,0.0f); glVertex3f(1.0f,1.0f,0.0f); glEnd(); return 0; }

##### Share on other sites
Remember that opengl''s camera is really the eye coordinates, so if there is no camera to move around, you are forced to move the entire world. Here is a snippet of my code from a 3d game I wrote:

int moveLeftandRight(float angle){
lx = sin(angle);
lz = -cos(angle);
gluLookAt(x, y, z,
x + lx, y + ly, z + lz,
0,1,0);

return 0;
}

int moveForwardandBackward(int direction){ //''1'' if forward ''-1'' if backwards
x += direction*(lx)*SPEED;
z += direction*(lz)*SPEED;
gluLookAt(x, y, z,
x + lx, y + ly, z + lz,
0,1,0);
return 0;
}

Then, you can use BOOLs to detect keypresses, like

if(keyLeft){
LRpos-=0.01;
moveLeftandRight(LRpos);

Anyway, its the math that is hard for most people. Hope that helps.
moveLeftandRight(

##### Share on other sites
Forgot to mention:

the camera coordinates are x,y,z and the view coordinates (the coordinates that you look at) are lx,ly,and lz.

##### Share on other sites
So basically I need to change my translate stuff to the lookat stuff?

##### Share on other sites
Ok I figured that stuff out... but how do you turn left instead of move left? Do you need to use glRotatef to do that?

Also: How do you use that key stuff? I tried it and it doesn't seem to work...

Edited by - Drakon on November 26, 2001 6:50:31 PM

##### Share on other sites
Change the xcenter variable.

##### Share on other sites
centerx just moves it left and right, not turn it.

##### Share on other sites
Did you even TRY my code up there? That moveLeftandRight function DOES turn you... sheesh!

try it out, all you need is a few geometrical calls to gluLookAt

##### Share on other sites
I tried it out but it gave me a few errors so I went back to trying it on my own...

What are cos and sin? They have anything to do with it?

##### Share on other sites
Woah, if you don't know what cos and sin are then you probably are in Algebra I, right?

That's not bad though, you'll get there, but I'll try to give you the basic stuff.

GO HERE to learn about Trigonometry

Just read the first three tutorials, and they'll get you in the right direction. The rest is more advanced stuff, but nothing too difficult. When I took trig, I thought it was pretty easy.

After you read those, you should be able to infer what that snippet of code is actually doing.

Good luck!

EDIT: This is probably real important. The sin and cos functions in the code accept their angles in radians. You may not know what those are, but just think of them as degrees. You'll get used to it.

Edited by - Floppy on November 26, 2001 11:40:31 PM

##### Share on other sites
Ok, thanks
Yes, ... (*thinks... remembering which algebra I''m in*) Man... I dont even remember what algebra book I''m in, but I think its two... but we haven''t gotten to cos and sin yet...
Its far too late to read that stuff now, but I''ll look at it in the morning.

##### Share on other sites
Another question... what is angle equal to?

Also: I don't understand whats going on in that tutorial stuff... I have a hard time learning math from tutorials.

Edited by - Drakon on November 27, 2001 9:33:22 AM

##### Share on other sites
There are three ways to get measurments of a triangle: sine, cosine, and tangent. Each are methodical to SOHCAHTOA, meaning:

sine = opposite over hypotenuse

You need to know these because when you turn left, for example, you would decrement a variable ''float angle''. Then, you need to figure out whether the sin, cos, or tangent is needed.

In the case of turning, the most commonly used are the negative cosine and the sine.

gluLookAt takes 9 arguments. The first three are the camera position (x,y,z), which are unaffected when you turn. The ones that are affected are the next three arguments, (lx, ly, lz) which are the look-x, look-y, and look-z. They determine the point where the camera is looking.

So when you move forward, you need to figure out what angle measurement between you and the z axis (and x axis) is so that you can move in the proper direction.

The mathematical (actually, it''s geometrical) way of calculating this properly is in the functions that I gave you.

Set up a system of BOOLs. Like this:

bool turnleft; bool turnright; bool forward; bool backward;

Then, (assuming that you are using GLUT), set up your keyboard up functions and keyboard down functions.

float turnangle;

void main(int argc, char **argv){
...
glutKeyboardUpFunc(KeysUp);
glutKeyboardFunc(KeysDown);
...
glutDisplayFunc(RenderScene);
...
glutMainLoop();
}

void KeysDown(unsigned char key, int x, int y){
switch(key){
case ''a'': turnleft=1; break;
case ''d'': turnright=1; break;
case ''w'': forward=1; break;
case ''s'': backward=1; break;
default: break;
}
}

void KeysUp(unsigned char key, int x, int y){
switch(key){
case ''a'': turnleft=0; break;
case ''d'': turnright=0; break;
case ''w'': forward=0; break;
case ''s'': backward=0; break;
default: break;
}
}

void RenderScene(void){
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
...
if(turnleft){
turnangle-=0.01;
moveLeftandRight(angle);
}
if(turnright){
turnangle+=0.01;
moveLeftanfRight(angle);
}
if(forward){
moveForwardandBackward(1);
}
if(backward){
moveForwardandBackward(-1);
}

Get it now? Geometry is the only way you can interpret the angles easily. Because the default setting for translating forward would be along the z axis, you not only need to compenstate your lx,ly,lz coords by translating along the z axis, but also the x axis.

This, my friend, is why geometry is critical.

~Jesse Lawson,
www.proggin.com/tutorials/opengl/index.htm

##### Share on other sites
I just noticed that you aren''t using GLUT; I thought you would be. The functions are still cooperative, so try them before you deny them.

##### Share on other sites
??? Huh ???

I have been searching for an answer on how to correctly move after turning, so I tried to use your code Zues_. However, just like all things, it screwed up. I can get it to turn very strangley, but, when I implemented the forward and backward movement code, it would stand still when I hit forward, when I hit back, it would rotate the screen, then when I hit forward again, it just screws up some more, and makes me frustrated. Does anyone have any other answers? Oh, and um, Zues_, you said that sin, and -cos are often used to determine this. Um, how is this? I''ve taken Algebra, but not Trigo yet. SOMEONE HELP ME! If you don''t, then I will have to calculate the additions to X and Z for all three hundred and sixty degrees of movement. Also, if I just add and subtract values from the camera''s X axis view, why does it stop when I reach 180 degrees and 360 degrees?

Doom to all who threaten the homeworld!
*Protoss Zealot - Starcraft*

##### Share on other sites
Do you know what sine, cosine, and tangent are? No?

Hmm... Look them up. To do what you want to do, the way you want to do it, you need to use SOHCAHTOA.

Do you know why?

Well, my examples involved incrementing an angle, right?

SOHCAHTOA was previously explained by me. Im serious, ask your math teacher about it, its hard to explain without visual contact. =)