void CWeapon::UpdateHudAdditonal(Fmatrix& trans)
{
    CActor* pActor = smart_cast<CActor*>(H_Parent());
    if (!pActor)        return;

    attachable_hud_item* hi = HudItemData();
    R_ASSERT(hi);

    u8 idx = GetCurrentHudOffsetIdx();

    if ((IsZoomed() && m_zoom_params.m_fZoomRotationFactor <= 1.f) || (!IsZoomed() && m_zoom_params.m_fZoomRotationFactor > 0.f))
    {
        Fvector                     curr_offs, curr_rot;
        curr_offs = hi->m_measures.m_hands_offset[0][idx];//pos,aim
        curr_rot = hi->m_measures.m_hands_offset[1][idx];//rot,aim
        curr_offs.mul(m_zoom_params.m_fZoomRotationFactor);
        curr_rot.mul(m_zoom_params.m_fZoomRotationFactor);

        Fmatrix                     hud_rotation;
        hud_rotation.identity();
        hud_rotation.rotateX(curr_rot.x);

        Fmatrix                     hud_rotation_y;
        hud_rotation_y.identity();
        hud_rotation_y.rotateY(curr_rot.y);
        hud_rotation.mulA_43(hud_rotation_y);

        hud_rotation_y.identity();
        hud_rotation_y.rotateZ(curr_rot.z);
        hud_rotation.mulA_43(hud_rotation_y);

        hud_rotation.translate_over(curr_offs);
        trans.mulB_43(hud_rotation);

        if (pActor->IsZoomAimingMode())
            m_zoom_params.m_fZoomRotationFactor += Device.fTimeDelta / m_zoom_params.m_fZoomRotateTime;
        else
            m_zoom_params.m_fZoomRotationFactor -= Device.fTimeDelta / m_zoom_params.m_fZoomRotateTime;

        clamp(m_zoom_params.m_fZoomRotationFactor, 0.f, 1.f);
    }

    // Рассчитываем фактор боковой ходьбы
    float fStrafeMaxTime = hi->m_measures.m_strafe_offset[2][idx].y; // Макс. время в секундах, за которое мы наклонимся из центрального положения
    if (fStrafeMaxTime <= EPS)
        fStrafeMaxTime = 0.01f;

    float fStepPerUpd = Device.fTimeDelta / fStrafeMaxTime; // Величина изменение фактора поворота

                                                    // Добавляем боковой наклон от движения камеры
    float fCamReturnSpeedMod = 1.5f; // Восколько ускоряем нормализацию наклона, полученного от движения камеры (только от бедра)
    float fCamLimitNoAim = 0.5f; // Максимальный фактор наклона от камеры от бедра
    float fYMag = pActor->fFPCamYawMagnitude;

    if (fYMag != 0.0f)
    { //--> Камера крутится по оси Y
        m_fLR_CameraFactor -= (fYMag * 0.005f);

        float fCamLimitBlend = 1.0f - ((1.0f - fCamLimitNoAim) * (1.0f - m_zoom_params.m_fZoomRotationFactor));
        clamp(m_fLR_CameraFactor, -fCamLimitBlend, fCamLimitBlend);
    }
    else
    { //--> Камера не поворачивается - убираем наклон
        if (m_fLR_CameraFactor < 0.0f)
        {
            m_fLR_CameraFactor += fStepPerUpd * fCamReturnSpeedMod;
            clamp(m_fLR_CameraFactor, -1.0f, 0.0f);
        }
        else
        {
            m_fLR_CameraFactor -= fStepPerUpd * fCamReturnSpeedMod;
            clamp(m_fLR_CameraFactor, 0.0f, 1.0f);
        }
    }

    // Добавляем боковой наклон от ходьбы вбок
    float fChangeDirSpeedMod = 3; // Восколько быстро меняем направление направление наклона, если оно в другую сторону от текущего

    u32 iMovingState = pActor->MovingState();
    if ((iMovingState & mcLStrafe) != 0)
    { // Движемся влево
        float fVal = (m_fLR_MovingFactor > 0.f ? fStepPerUpd * fChangeDirSpeedMod : fStepPerUpd);
        m_fLR_MovingFactor -= fVal;
    }
    else if ((iMovingState & mcRStrafe) != 0)
    { // Движемся вправо
        float fVal = (m_fLR_MovingFactor < 0.f ? fStepPerUpd * fChangeDirSpeedMod : fStepPerUpd);
        m_fLR_MovingFactor += fVal;
    }
    else
    { // Двигаемся в любом другом направлении
        if (m_fLR_MovingFactor < 0.0f)
        {
            m_fLR_MovingFactor += fStepPerUpd;
            clamp(m_fLR_MovingFactor, -1.0f, 0.0f);
        }
        else
        {
            m_fLR_MovingFactor -= fStepPerUpd;
            clamp(m_fLR_MovingFactor, 0.0f, 1.0f);
        }
    }

    clamp(m_fLR_MovingFactor, -1.0f, 1.0f); // Фактор боковой ходьбы не должен превышать эти лимиты

                                            // Вычисляем и нормализируем итоговый фактор наклона
    float fLR_Factor = m_fLR_MovingFactor + m_fLR_CameraFactor;
    clamp(fLR_Factor, -1.0f, 1.0f); // Фактор боковой ходьбы не должен превышать эти лимиты

    // Производим наклон ствола для нормального режима и аима
    if (idx == 0 && hi->m_measures.m_strafe_offset[2][0].x);
    {
        Fvector curr_offs, curr_rot;

        // Смещение позиции худа в стрейфе
        curr_offs = hi->m_measures.m_strafe_offset[0][0]; //pos
        curr_offs.mul(fLR_Factor);                   // Умножаем на фактор стрейфа

                                                             // Поворот худа в стрейфе
        curr_rot = hi->m_measures.m_strafe_offset[1][0]; //rot
        curr_rot.mul(-PI / 180.f);                          // Преобразуем углы в радианы
        curr_rot.mul(fLR_Factor);                   // Умножаем на фактор стрейфа

        curr_offs.mul(1.f - m_zoom_params.m_fZoomRotationFactor);
        curr_rot.mul(1.f - m_zoom_params.m_fZoomRotationFactor);

        Fmatrix hud_rotation;
        Fmatrix hud_rotation_y;

        hud_rotation.identity();
        hud_rotation.rotateX(curr_rot.x);

        hud_rotation_y.identity();
        hud_rotation_y.rotateY(curr_rot.y);
        hud_rotation.mulA_43(hud_rotation_y);

        hud_rotation_y.identity();
        hud_rotation_y.rotateZ(curr_rot.z);
        hud_rotation.mulA_43(hud_rotation_y);

        hud_rotation.translate_over(curr_offs);
        trans.mulB_43(hud_rotation);
    }
}