Hey gamedev

I'm currently working on an FPS, and at the moment I'm trying to write everything to do with walking.

My question to you is, how do you go about making the camera tilt slightly whilst strafing left and right as seen in some games?

I've tried a few things and have had a few problems. I've had problems specifying when the camera should stop rolling, I came up with a sort of solution to that, but I now have the problem where if I strafe, say to the right while turning the camera to the left (yaw) then stop the camera will be permenently tilted.

This is my code so far. It's bad, I know but I'm a beginner

Code messed up here - see second post

That seems to do the job. The camera rolls slightly and smoothly whilst strafing. The only problem is that if I strafe and turn yaw at the same time the camera ends up stuck tilted

I don't know why the code has squished up like that, Heres a repost of the code:

[source lang="cpp"]float rollIndex = 0.01f;
float rotZ = 0;
float currentZRot = 0; //I use this to try and stop the roll where I want it

//later on in code

if strafing left:
if (currentZRot < 0.07f)
rotZ += rollIndex;
if strafing right:
if (currentZRot > -0.07f)
rotZ -= rollIndex;
else
if (currentZRot < 0)
rotZ += rollIndex;
else if (currentZRot > 0)
rotZ -= rollIndex;
//that makes the camera roll back to the right way up

//Later on in code

//at the end of the cameras update function
roll(rotZ);
currentZRot += rotZ;
rotZ = 0.00f;



//and here is my camera's yaw, pitch and roll functions
void Camera::pitch(float A)
{
D3DXMATRIX T;
D3DXMatrixRotationAxis(&T, &right, A);
D3DXVec3TransformCoord(&lookDir, &lookDir, &T);
}
void Camera::yaw(float A)
{
D3DXMATRIX T;
D3DXMatrixRotationY(&T, A);
D3DXVec3TransformCoord(&right, &right, &T);
D3DXVec3TransformCoord(&lookDir, &lookDir, &T);
}
void Camera::roll(float A)
{
D3DXMATRIX T;
D3DXMatrixRotationAxis(&T, &lookDir, A);
D3DXVec3TransformCoord(&right, &right, &T);
D3DXVec3TransformCoord(&up, &up, &T);
}[/source]

Anybody?

Shameless self bump

Sorry to do this again but I'm desperate for an answer. Bump again

From what I can tell, it's a math problem. I'm pretty rubbish at math so I have no idea what's going on. I'll post a video and my entire camera class.

3DCamera.h

//Camera header
#include "Main.h"
class Camera
{
public:
D3DXMATRIX viewMatrix;
D3DXMATRIX projMatrix;
D3DXVECTOR3 pos;
D3DXVECTOR3 up;
D3DXVECTOR3 target;
D3DXVECTOR3 lookDir;
D3DXVECTOR3 right;
D3DXVECTOR3 acceleration;
D3DXVECTOR3 currentVel;
float maxWalkingVelocity;
void Initialize(D3DXVECTOR3 Position, D3DXVECTOR3 Up, D3DXVECTOR3 Target);
void Update(LPDIRECT3DDEVICE9& d3dDevice);
void Camera::pitch(float A);
void Camera::yaw(float A);
void Camera::roll(float A);
};


3DCamera.cpp

//Camera source file
#include "3DCamera.h"
extern bool ISINFOCUS;
float rotX = 0;
float rotY = 0;
float rotZ = 0;
float currentZRot = 0;
float rollIndex = 0.01f;
void Camera::Initialize(D3DXVECTOR3 Position, D3DXVECTOR3 Up, D3DXVECTOR3 Target)
{
maxWalkingVelocity = 0.3f;
D3DXMatrixPerspectiveFovLH(&projMatrix, D3DXToRadian(45), 800.0f / 600.0f, 1, 2000);
pos = Position;
up = Up;
target = Target;
lookDir = target - pos;
}
void Camera::Update(LPDIRECT3DDEVICE9& d3dDevice)
{
D3DXVec3Normalize(&lookDir, &lookDir);
D3DXVec3Cross(&right, &up, &lookDir);
D3DXVec3Normalize(&right, &right);
//Walk control
if(GetAsyncKeyState(0x57))
acceleration += lookDir * 0.02f;
if (GetAsyncKeyState(0x53))
acceleration += lookDir * -0.02f;
//Strafe control

if (GetAsyncKeyState(0x41))
{
acceleration += D3DXVECTOR3(right.x, 0, right.z) * -0.015f;
if (currentZRot < 0.07f)
rotZ += rollIndex;
}
else
if (GetAsyncKeyState(0x44))
{
acceleration += D3DXVECTOR3(right.x, 0, right.z) * 0.015f;
if (currentZRot > -0.07f)
rotZ -= rollIndex;
}
else
if (currentZRot < 0)
rotZ += rollIndex;
else if (currentZRot > 0)
rotZ -= rollIndex;

//look control
if (GetAsyncKeyState(VK_LEFT))
rotX -= 0.04f;
else
if (GetAsyncKeyState(VK_RIGHT))
rotX += 0.04f;

if (GetAsyncKeyState(VK_UP) && lookDir.y < 0.932f)
rotY -= 0.04f;
else
if (GetAsyncKeyState(VK_DOWN) && lookDir.y > -0.985f)
rotY += 0.04f;

static const float friction = 0.08f;
currentVel += acceleration;
currentVel += ((currentVel * friction * -1));
pos += currentVel;
acceleration = D3DXVECTOR3(0, 0, 0);
pitch(rotY);
yaw(rotX);
roll(rotZ);
D3DXMatrixLookAtLH(&viewMatrix, &pos, &(pos + lookDir), &up);
rotX = 0;
rotY = 0;
currentZRot += rotZ;
rotZ = 0.00f;
}
void Camera::pitch(float A)
{
D3DXMATRIX T;
D3DXMatrixRotationAxis(&T, &right, A);
D3DXVec3TransformCoord(&lookDir, &lookDir, &T);
}
void Camera::yaw(float A)
{
D3DXMATRIX T;
D3DXMatrixRotationY(&T, A);
D3DXVec3TransformCoord(&right, &right, &T);
D3DXVec3TransformCoord(&lookDir, &lookDir, &T);
}
void Camera::roll(float A)
{
D3DXMATRIX T;
D3DXMatrixRotationAxis(&T, &lookDir, A);
D3DXVec3TransformCoord(&right, &right, &T);
D3DXVec3TransformCoord(&up, &up, &T);
}



Then in my update loop I call

camera.Update(d3dDevice);


?END EMBARRASSING CODE

As for the video

Try drawing all your camera vectors to the screen. That way you can see what changes when the bug appears.

I will do that, thanks. I would assume it's the right vector though as it's the only one Roll and Yaw functions have in common...?