Hi Guys,

I'm using QueryPerformanceCounter() to get the elapsed time in seconds in a float variable.

Then I multiply the elapsed time with the velocity as the following in entity Update(float timeElapsed) function:

void Update(float timeElapsed)
{
velocity *= timeElapsed;
setPosition(getPosition() + velocity); // Now, update the entity position based on velocity
velocity = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
...
...

I can notice that the entity movement speed is not the same when the frame rate drop, for example If I enable VSync during rendering to drop the frame rate to 60, the entity move faster than when the frame rate is 130

Any idea what could be causing this problem?

How do you calculate the velocity in the first place? Normalize it before multiplying it with the delta time and see if that makes it move at the same speed regardless of the frame rate. If that helps then it means that the calculations of the velocity themselves depend on the frame rate.

I'm using QueryPerformanceCounter() to get the elapsed time in seconds in a float variable.

How exactly are you using QPC to get the elapsed time?

I can notice that the entity movement speed is not the same when the frame rate drop

Whenever your framerate drops the time elapsed increases which is the expected obviously. In your example, when the elapsed time varies, so do an entity speed. A solution to that is use a fixed time step, which won't guarantee that your frame rate is the same every time, but will integrate your position in a more deterministic way. Read this article:

http://gafferongames.com/game-physics/fix-your-timestep/

Could you paste your game loop here?

@GuyWithBeard: Even after I normalize the velocity, I still have the same problem.

@Irlan Robson:

In class construction:

LARGE_INTEGER freq;
QueryPerformanceFrequency(&freq);
secondsPerCount = 1.0 / (double)freq.QuadPart;

void FrameUpdate()
{
     LARGE_INTEGER liCurrTime;
     QueryPerformanceCounter(&liCurrTime);
     currentTime = (double)liCurrTime.QuadPart;
     if (lastTime == 0)
     {
         lastTime = currentTime;
     }

     double timeElapsed = (currentTime - lastTime) * secondsPerCount;

     lastTime = currentTime;

     // Code here to do all the game updates...
     // ...
     // ...
}

@Irlan Robson:

@GuyWithBeard:

I notice that I don't have this problem if the entity is not assigned to the physics engine.

I'm using Bullet Physics and doing simulation as the following:

m_DynamicsWorld->stepSimulation(elapsedTime);

function Update(float timeElapsed)
{
velocity *= timeElapsed;
setPosition(getPosition() + velocity); // Now, update the entity position based on velocity
velocity = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
...
...

float3 distance_traveled = velocity * timeElapsed;  // u/s * s -> u
setPosition( getPosition() + distance_traveled );   // u + u -> u

const float DAMPING = 0.8f;        // (scalar) reduces velocity 20% every 1 second (roughly) 
velocity *= DAMPING * timeElapsed; // u/s * scalar -> u/s
float3 distance_traveled = velocity * timeElapsed; // u/s * s -> u 
setPosition( getPosition() + velocity * timeElapsed ); // u + u -> u

Whatever behaviour you're trying to achieve, normalizing the velocity wouldn't help at all.

Well it helps in the sense that it narrows the problem down. I never meant he should leave the normalization in there (obviously).

Since the problem is still there after normalization, it means that the velocity value is fine (or at least it means that there is a problem somewhere else, ie. the delta time value).

Now, it's clear that the problem is caused by the physics engine, since the movement is frame independent only if I disable the physics engine or if I don't assign the entity to the physics engine.

Here is what I'm doing in the physics engine each frame:

1. Iterate through all the body dynamics and update their transformation based on the entities transformation

2. Simulate physics using: m_DynamicsWorld->stepSimulation(elapsedTime);

3. Iterate through all the body dynamics and update the entities transformation based on the rigid bodies transformation.