Hi all,

I've noticed that in my camera movement, when the camera/ player both walks forward/backward and strafes, the camera moves twice the amount as it should. At least that's what I think.

Below the code I'm using right now.

I have 2 questions:

- is my assumption correct that with the approach below, moving forward/backward + strafe at the same time, moves the camera/player twice the amount it should

- my approach to fix this, would be to check if the keys for both moving forward/backward and strafe and down, and if so, call a separate/ new function, moving the camera for strafe/ moving at once (if both keys down), if else only one etc.

What do you think?

			if(_dinput.KeyDown(DIK_W)) _player.SetPosition(_d3dcam.MoveForwardBackward(_timer.GetDelta() * _player.GetWalkSpeed()));
			if(_dinput.KeyDown(DIK_S)) _player.SetPosition(_d3dcam.MoveForwardBackward(_timer.GetDelta() * -_player.GetWalkSpeed()));		

			if(_dinput.KeyDown(DIK_A)) _player.SetPosition(_d3dcam.MoveLeftRight(_timer.GetDelta() * -_player.GetStrafeSpeed()));
			if(_dinput.KeyDown(DIK_D)) _player.SetPosition(_d3dcam.MoveLeftRight(_timer.GetDelta() * _player.GetStrafeSpeed()));


// the actual camera functions

/**************************************************************************************/
/***							MOVE FORWARD BACKWARD								***/
/*** ==> usage: when camera moves forward or backward								***/
/*** ==> calculates the changed X and Z camera position, based on movement value	***/
/**************************************************************************************/

VECTOR3 CD3dcam::MoveForwardBackward(const float pAmount)	
{ 
	mPosition += mLook * pAmount;					// 'flying' allowed, 6 DOF
	
	// to disable 'FLYING', use:
//	mPosition += D3DXVECTOR3(mLook.x, 0.0f, mLook.z) * pAmount;

	return VECTOR3(mPosition.x, mPosition.y, mPosition.z);
}

/**************************************************************************************/
/***							MOVE LEFT RIGHT										***/
/*** ==> usage: when camera strafes to the left or right							***/
/*** ==> calculates the changed X and Z camera position, based on movement value	***/
/**************************************************************************************/

VECTOR3 CD3dcam::MoveLeftRight(const float pAmount)
{
	mPosition += mRight * pAmount;

	return VECTOR3(mPosition.x, mPosition.y, mPosition.z);
}

Thanks, this is really clear. I'll go implement it right away

That was easy, think I've got it.

Here it is, result looks as expected.

I've left the separate move forward/backward, left/right and up/down functions unchanged.

What do you think?

			Crealysm_math::VECTOR3 movement = Crealysm_math::VECTOR3(0.0f, 0.0f, 0.0f);

			if(_dinput.KeyDown(DIK_W)) movement.z =  _player.GetWalkSpeed();
			if(_dinput.KeyDown(DIK_S)) movement.z = -_player.GetWalkSpeed();
			
			if(_dinput.KeyDown(DIK_A)) movement.x = -_player.GetStrafeSpeed();
			if(_dinput.KeyDown(DIK_D)) movement.x = _player.GetStrafeSpeed();

			if(_dinput.KeyDown(DIK_PRIOR)) movement.y = _player.GetWalkSpeed();
			if(_dinput.KeyDown(DIK_NEXT)) movement.y = -_player.GetWalkSpeed();

			movement *= _timer.GetDelta();

			_player.SetPosition(_d3dcam.Move(movement));


VECTOR3 CD3dcam::Move(const Crealysm_math::VECTOR3 pMovement)
{
	MoveForwardBackward(pMovement.z);
	MoveLeftRight(pMovement.x);		
	MoveUpDown(pMovement.y);

	return VECTOR3(mPosition.x, mPosition.y, mPosition.z);
}

Thanks Nypyren, got it.

The movement actually 'feels' smoother now.

Here's the result:

		if(!_d3dscene.GetAnimated())
		{
			_player.Running(_dinput.KeyDown(DIK_LSHIFT));
			Crealysm_math::VECTOR3 movement = Crealysm_math::VECTOR3(0.0f, 0.0f, 0.0f);

			if(_dinput.KeyDown(DIK_W)) movement.z +=  _player.GetWalkSpeed();
			if(_dinput.KeyDown(DIK_S)) movement.z += -_player.GetWalkSpeed();
			
			if(_dinput.KeyDown(DIK_A)) movement.x += -_player.GetStrafeSpeed();
			if(_dinput.KeyDown(DIK_D)) movement.x += _player.GetStrafeSpeed();

			if(_dinput.KeyDown(DIK_PRIOR)) movement.y += _player.GetWalkSpeed();
			if(_dinput.KeyDown(DIK_NEXT)) movement.y += -_player.GetWalkSpeed();

			movement.limit(_player.GetWalkSpeed());
			movement *= _timer.GetDelta();

			_player.SetPosition(_d3dcam.Move(movement));
		}

// NEW VECTOR3 inline function

	VECTOR3 limit(const float pMax)
	{
		if(x > pMax) x = pMax;
		if(y > pMax) y = pMax;
		if(z > pMax) z = pMax;
		return *this;
	}

Ok. I might need some help on this. Do you mean I have to:

- calculate the length of the vector (sqrt(x*x + y*y + z*z)) = length

- if length > 'pMax', then make the vector the length of pMax

An example:

Movement vector = 0.5, 0.8, 0.5

Length/ magnitude = 1.067

Then I want to limit the vectors length to 'pMax', say 0.7.

I'm not sure how to do that, is this it?

Movement = 0.5, 0.8, 0.5 (1.067)

Limited = x, y, z (1.067)

New vector = movement * (0.7 / movement.length()

new.x = 0.5 * (0.7 / 1.067)

new.y = 0.8 * (0.7 / 1.067)

new.z = 0.5 * (0.7 / 1.067)

New = 0.33, 0.52, 0.33

Voila, magnitude = 0.7

Is this it?

If so, I'll make an optimized version of the above as a (inline) function in my vector struct.

Ps.: this really helps brushing up vector math :)