void CCamera::SetPos(float x, float y, float z)
{
	mXpos = x;
	mYpos = y;
	mZpos = z;

	mIsChanged = true;
}

void CCamera::SetPYR(float pitch, float yaw, float roll)
{
	mPitch = pitch;
	mYaw = yaw;
	mRoll = roll;

	mIsChanged = true;
}

void CCamera::Render()
{
	glLoadIdentity();
	glRotatef(-mPitch, 1, 0, 0); // +degrees = pitch up (move environ down, so to speak)
	glRotatef(mYaw, 0, 1, 0); // +degrees = yaw to right (move environ left)
	glRotatef(mRoll, 0, 0, 1); // +degrees = roll clockwise (rotate environ counterclockwise)
	glTranslatef(-mXpos, -mYpos, -mZpos);

	mIsChanged = false;
}

Quote:Original post by jyk

Quote:Original post by Ledneh
Thanks for the response. You'll have to forgive my newbish response questions, but there are a lot of things I still don't know well enough here--kind of flying by the seat of my pants, more or less.

First off, why would having a Euler representation be a bad idea? Intuitively it seems to make the most logical sense, but if there's some important reason that I would use forward, right, and up normally instead of roll, pitch, and yaw, I'd like to hear it.

Also, are there any alternatives besides Euler and forward/right/up? Or are those the only practical ones?


Let's see, what else... oh yeah, why would it be an unadvisable idea to pull the forward, right, and up vectors out of the modelview and store them right after I set up the camera? To me that seems almost like an ideal solution.

Thanks for any further clarification you can provide! :)

Quick answers:

Euler angles are fine for some types of motion, not for others. If it's doing what you want, then perhaps it's the right solution for you.

The real issue isn't so much Euler angles vs. other representations, but incremental rotation vs. 'from scratch' rotation (you're doing the latter). For completely free 6DOF motion you need the former, while the latter is perfectly satisfactory for an FPS or similar game.

As for other representations, rotation matrices and quaternions are the most common and useful.

Finally, it would certainly be a lot easier to pull the vectors directly from OpenGL than to write your own math library code or adapt someone else's, and if you just want to get it working it may be the way to go. However, doing your math via OpenGL is very limited and limiting, so sooner or later you'll need your own math code anyway, and this would be a good opportunity to get started on it :)

void CCamera::MoveForward(float l){	float fX, fY, fZ, mag;		// Calculate forward based on yaw and pitch	fX = sin(mYaw * DEG_2_RAD) * cos(mPitch * DEG_2_RAD);	fY = sin(mPitch * DEG_2_RAD);	fZ = -cos(mYaw * DEG_2_RAD) * cos(mPitch * DEG_2_RAD);	// Calculate magnitude, normalize	mag = sqrt(fX*fX + fY*fY + fZ*fZ);	fX /= mag; fY /= mag; fZ /= mag;	// Scale vector by movement distance	fX *= l; fY *= l; fZ *= l;		//cout << "Vel = " << sqrt(fX*fX + fY*fY + fZ*fZ) << endl;	// Add new components to current location to get new destination	mXpos += fX; mYpos += fY; mZpos += fZ;	mIsChanged = true;}void CCamera::MoveUp(float l){	float fX, fY, fZ, mag;		// Calculate up based on yaw and pitch	fX = sin(mYaw * DEG_2_RAD) * cos((mPitch+90) * DEG_2_RAD);	fY = sin((mPitch+90) * DEG_2_RAD);	fZ = -cos(mYaw * DEG_2_RAD) * cos((mPitch+90) * DEG_2_RAD);	// Calculate magnitude, normalize	mag = sqrt(fX*fX + fY*fY + fZ*fZ);	fX /= mag; fY /= mag; fZ /= mag;	// Scale vector by movement distance	fX *= l; fY *= l; fZ *= l;		//cout << "Vel = " << sqrt(fX*fX + fY*fY + fZ*fZ) << endl;	// Add new components to current location to get new destination	mXpos += fX; mYpos += fY; mZpos += fZ;	mIsChanged = true;}void CCamera::MoveRight(float l){		float fX, fY, fZ, mag;		// Calculate right based on yaw (pitch is irrelevant)	fX = sin((mYaw+90) * DEG_2_RAD);// * cos(mPitch * DEG_2_RAD);	//fY = sin(mPitch * DEG_2_RAD);	fY = 0;	fZ = -cos((mYaw+90) * DEG_2_RAD);// * cos(mPitch * DEG_2_RAD);	// Calculate magnitude, normalize	mag = sqrt(fX*fX + fY*fY + fZ*fZ);	fX /= mag; fY /= mag; fZ /= mag;	// Scale vector by movement distance	fX *= l; fY *= l; fZ *= l;		//cout << "Vel = " << sqrt(fX*fX + fY*fY + fZ*fZ) << endl;	// Add new components to current location to get new destination	mXpos += fX; mYpos += fY; mZpos += fZ;	mIsChanged = true;}