Движение объекта с камерой

void MyObject::Update()
{
тут вычисление матриц
 
for( проход по всем потомкам )
{
потомок->Update(); /// потомки тоже могут иметь своих потомков, поэтому обновится всё
}
}

void gtStaticObjectImpl::update()
{
    bool update_mat = false;
 
    if( m_parent )
    {
        update_mat = true;
    }
    
    if( m_position != m_old_position )
    {
        math::makeTranslationMatrix( m_position, m_translationMatrix );
        m_old_position = m_position;
        update_mat = true;
    }
    
    if( m_orientation != m_old_orientation )
    {
        math::makeRotationMatrix( m_rotationMatrix, m_orientation );
        m_old_orientation = m_orientation;
        update_mat = true;
    }
    
    if( m_scale != m_old_scale )
    {
        math::makeScaleMatrix( m_scale, m_scaleMatrix );
        m_old_scale = m_scale;
        update_mat = true;
    }
 
    if( update_mat )
    {
        m_worldMatrix = m_translationMatrix * m_rotationMatrix * m_scaleMatrix;
    }
 
    m_positionInSpace = m_position;
 
    if( m_parent )
    {
        m_worldMatrix = m_parent->getAbsoluteWorldMatrix() * m_worldMatrix;
 
        m_positionInSpace.x = m_worldMatrix[3].x;
        m_positionInSpace.y = m_worldMatrix[3].y;
        m_positionInSpace.z = m_worldMatrix[3].z;
        m_positionInSpace.w = 1.f;
    }
 
    if( update_mat )
    {
        m_worldMatrixAbsolute = m_worldMatrix;
    }
 
    auto * childs = &getChildList();
    for(auto it = childs->begin(); it != childs->end(); ++it)
    {
        (*it)->update();
    }
}

void UpdateCamera()
{
    // Rotate target around camera
    camRotationMatrix = XMMatrixRotationRollPitchYaw(camPitch, camYaw, 0);
    camTarget = XMVector3TransformCoord(DefaultForward, camRotationMatrix );
    camTarget = XMVector3Normalize(camTarget);
 
    XMMATRIX RotateYTempMatrix;
    RotateYTempMatrix = XMMatrixRotationY(camYaw);
 
    // Walk
    camRight = XMVector3TransformCoord(DefaultRight, RotateYTempMatrix);
    camForward = XMVector3TransformCoord(DefaultForward, RotateYTempMatrix);
    camUp = XMVector3Cross(camForward, camRight);
 
    // Free Cam
    camRight = XMVector3TransformCoord(DefaultRight, camRotationMatrix);
    camForward = XMVector3TransformCoord(DefaultForward, camRotationMatrix);
    camUp = XMVector3Cross(camForward, camRight);
 
    camPosition += moveLeftRight*camRight;
    camPosition += moveBackForward*camForward;
 
    moveLeftRight = 0.0f;
    moveBackForward = 0.0f;
 
    camTarget = camPosition + camTarget;
 
    // Third Person Camera
    // Set the cameras target to be looking at the character.
    camTarget = charPosition;
    camTarget = XMVectorSetY(camTarget, XMVectorGetY(camTarget)+5.0f);    
 
 
    // Rotate camera around target
    camRotationMatrix = XMMatrixRotationRollPitchYaw(-camPitch, camYaw, 0);
    camPosition = XMVector3TransformNormal(DefaultForward, camRotationMatrix );
    camPosition = XMVector3Normalize(camPosition);
 
    // Set our cameras position to rotate around the character.
    // to be "standing" on (0,0,0), instead of centered around it ;) Well target her head here though
    camPosition = (camPosition * charCamDist) + camTarget;
 
 
    camForward = XMVector3Normalize(camTarget - camPosition);    // Get forward vector based on target
    camForward = XMVectorSetY(camForward, 0.0f);    // set forwards y component to 0 so it lays only on
    // the xz plane
    camForward = XMVector3Normalize(camForward);
    // To get our camera's Right vector, we set it's x component to the negative z component from the
    // camera's forward vector, and the z component to the camera forwards x component
    camRight = XMVectorSet(-XMVectorGetZ(camForward), 0.0f, XMVectorGetX(camForward), 0.0f);
 
    // Our camera does not "roll", so we can safely assume that the cameras right vector is always
    // in the xz plane, so to get the up vector, we just get the normalized vector from the camera
    // position to the cameras target, and cross it with the camera's Right vector
    camUp =XMVector3Normalize(XMVector3Cross(XMVector3Normalize(camPosition - camTarget), camRight));
 
    camView = XMMatrixLookAtLH( camPosition, camTarget, camUp );
}
 
 
void DetectInput(double time)
{
    DIMOUSESTATE mouseCurrState;
 
    BYTE keyboardState[256];
 
    DIKeyboard->Acquire();
    DIMouse->Acquire();
 
    DIMouse->GetDeviceState(sizeof(DIMOUSESTATE), &mouseCurrState);
 
    DIKeyboard->GetDeviceState(sizeof(keyboardState),(LPVOID)&keyboardState);
 
    if(keyboardState[DIK_ESCAPE] & 0x80)
        PostMessage(hwnd, WM_DESTROY, 0, 0);
 
    float speed = 10.0f * time;    
    bool moveChar = false;
    XMVECTOR desiredCharDir = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
 
    if(keyboardState[DIK_A] & 0x80)
    {
        desiredCharDir += (camRight);
        moveChar = true;
    }
    if(keyboardState[DIK_D] & 0x80)
    {
        desiredCharDir += -(camRight);
        moveChar = true;
    }
    if(keyboardState[DIK_W] & 0x80)
    {
        desiredCharDir += (camForward);
        moveChar = true;
    }
    if(keyboardState[DIK_S] & 0x80)
    {
        desiredCharDir += -(camForward);
        moveChar = true;
    }
    if((mouseCurrState.lX != mouseLastState.lX) || (mouseCurrState.lY != mouseLastState.lY))
    {
        camYaw += mouseLastState.lX * 0.002f;
        camPitch += mouseCurrState.lY * 0.002f;
 
 
        // Normalize our destinated direction vector
        desiredCharDir = XMVector3Normalize(desiredCharDir);
 
 
        if (XMVectorGetX(XMVector3Dot(desiredCharDir, oldCharDirection)) == -1)
            oldCharDirection += XMVectorSet(0.02f, 0.0f, -0.02f, 0.0f);
 
        // Get our current characters position in the world, from it's world matrix
        charPosition = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
        charPosition = XMVector3TransformCoord(charPosition, playerCharWorld);
 
        // Rotate our character smoothly when changing direction (from the GPG series)
        float destDirLength = 10.0f * frameTime;        // Change to the speed you want your character to rotate. This uses the game timer from an earlier lesson
                                                        // The larget this value, the faster the character rotates
        currCharDirection = (oldCharDirection)+(desiredCharDir * destDirLength);    // Get the characters direction (based off time, old position, and desired
                                                                                    // direction), by adding together the current direction and the old direction
                                                                                    // to get vector that smoothly turns from oldCharDir to denstinationDirection
        currCharDirection = XMVector3Normalize(currCharDirection);        // Normalize the characters current direction vector
                                                                        // the opposite of what it currently is, giving us the result in -1 PI to 1 PI.
        float charDirAngle = XMVectorGetX(XMVector3AngleBetweenNormals(XMVector3Normalize(currCharDirection), XMVector3Normalize(DefaultForward)));
        if (XMVectorGetY(XMVector3Cross(currCharDirection, DefaultForward)) > 0.0f)
            charDirAngle = -charDirAngle;
 
        // Now we update our characters position based off the frame time, his old position, and the direction he is facing
        float speed = 15.0f * frameTime;
        charPosition = charPosition + (desiredCharDir * speed);
 
        // Update characters world matrix
        Scale = XMMatrixScaling(0.25f, 0.25f, 0.25f);
        Translation = XMMatrixTranslation(XMVectorGetX(charPosition), 0.0f, XMVectorGetZ(charPosition));
 
        playerCharWorld = Scale * XMMatrixRotationRollPitchYaw(-camPitch, camYaw, 0) * Translation;
 
        // Check that the camera doesn't go over the top or under the player
        if(camPitch > 0.85f)
            camPitch = 0.85f;
        if(camPitch < -0.85f)
            camPitch = -0.85f;
 
        mouseLastState = mouseCurrState;
    }

playerCharWorld = Scale * XMMatrixRotationRollPitchYaw(-camPitch, camYaw, 0) * Translation;