Ошибка с DirectX

#include <Windows.h>
#include <d3d11.h>
 
 
//--------------------------------------------------------------------------------------
//Глобальные переменные
//--------------------------------------------------------------------------------------
HINSTANCE               g_hInst = NULL;
HWND                    g_hWnd = NULL;
D3D_DRIVER_TYPE         g_driverType = D3D_DRIVER_TYPE_NULL;
D3D_FEATURE_LEVEL       g_featureLevel = D3D_FEATURE_LEVEL_11_0;
ID3D11Device*           g_pd3dDevice = NULL;          // Устройство (для создания объектов)
ID3D11DeviceContext*    g_pImmediateContext = NULL;   // Контекст устройства (рисование)
IDXGISwapChain*         g_pSwapChain = NULL;          // Цепь связи (буфера с экраном)
ID3D11RenderTargetView* g_pRenderTargetView = NULL;   // Объект заднего буфера
 
//--------------------------------------------------------------------------------------
// Предварительные объявления функций
//--------------------------------------------------------------------------------------
HRESULT  createWindow(HINSTANCE, int); //Создание окна
HRESULT  initDirectX(); // Инициализация устройств DirectX
void CleanupDevice(); // Удаление созданнных устройств DirectX
LRESULT __stdcall WndProc(HWND, UINT, WPARAM, LPARAM); // Функция окна
void Render();      // Функция рисования
 
//--------------------------------------------------------------------------------------
// Точка входа в программу. Здесь мы все инициализируем и входим в цикл сообщений.
// Время простоя используем для вызова функции рисования.
//--------------------------------------------------------------------------------------
void Init(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
 
    if(FAILED(createWindow( hInstance, nCmdShow ))) {
        MessageBox ( NULL,L"Не удалось создать окно.",L"Ошибка",MB_OK|MB_ICONERROR);
        exit(1);
    }
 
    if(FAILED(initDirectX())) {
        MessageBox (NULL, L"Не удалось инициализировать DirectX 11.", L"Ошибка", MB_OK|MB_ICONERROR);
        exit(1);
    }
 
    MessageBox ( NULL, L"DirectX 11 инициализирован! Нажми ок чтоб все заработало!", L"Все ахрененно!", MB_OK|MB_ICONERROR);
 
    // Главный цикл сообщений
    MSG msg = {0};
    while ( WM_QUIT != msg.message )
    {
        if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE) )
        {
            TranslateMessage( &msg );
            DispatchMessage( &msg );
        }
        else
        {
            Render(); // Рисуем
        }
    }
}
 
//--------------------------------------------------------------------------------------
// Регистрация класса и создание окна
//--------------------------------------------------------------------------------------
HRESULT createWindow(HINSTANCE hInstance, int nCmdShow)
{
    HWND hWnd;
    WNDCLASS WndClass;
    wchar_t szClassName[] = L"Fallen World";
    /*
    Регистрируем создаваемый класс
    Заполняем структуру WNDCLASS
    */
    WndClass.style = CS_OWNDC;
    WndClass.lpfnWndProc = WndProc;
    WndClass.cbClsExtra = 0;
    WndClass.cbWndExtra = 0;
    WndClass.hInstance = hInstance;
    WndClass.hIcon = LoadIcon(NULL ,IDI_APPLICATION);
    WndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    WndClass.lpszClassName = szClassName;
    WndClass.lpszMenuName = NULL;
    WndClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    
    if (!RegisterClass(&WndClass)) {
        return E_FAIL;
    }
 
    // Создание окна
    g_hInst = hInstance;
    RECT rc = { 0, 0, 640, 480 };
    AdjustWindowRect (&rc, WS_OVERLAPPEDWINDOW, FALSE);
    hWnd = CreateWindow(szClassName, L"Fallen World",
                        WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,CW_USEDEFAULT,
                        rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, hInstance, NULL);
 
    if (!hWnd) {
        return E_FAIL;
    }
 
    /*
    Показываем окно
    */
    ShowWindow(hWnd,nCmdShow);
    
    return S_OK;
}
 
HRESULT initDirectX() 
{
    HRESULT hr = S_OK;
 
    RECT rc;
    GetClientRect( g_hWnd, &rc );
    UINT width = rc.right - rc.left; // получаем ширину
    UINT height = rc.bottom - rc.top; // и высоту окна
    UINT createDeviceFlags = 0;
 
    D3D_DRIVER_TYPE driverTypes[] = 
    {
        D3D_DRIVER_TYPE_HARDWARE,
        D3D_DRIVER_TYPE_WARP,
        D3D_DRIVER_TYPE_REFERENCE,
    };
    UINT numDriverTypes = ARRAYSIZE( driverTypes );
 
    // Тут мы создаем список поддерживаемых версий DirectX
    D3D_FEATURE_LEVEL featureLevels[] =
    {
        D3D_FEATURE_LEVEL_11_0,
        D3D_FEATURE_LEVEL_10_1,
        D3D_FEATURE_LEVEL_10_0,
    };
    UINT numFeatureLevels = ARRAYSIZE( featureLevels );
 
    // Сейчас мы создадим устройства DirectX. Для начала заполним структуру,
    // которая описывает свойства переднего буфера и привязывает его к нашему окну.
    DXGI_SWAP_CHAIN_DESC sd;            // Структура, описывающая цепь связи (Swap Chain)
    ZeroMemory( &sd, sizeof( sd ) );    // очищаем ее
    sd.BufferCount = 1;                               // у нас один задний буфер
    sd.BufferDesc.Width = width;                     // ширина буфера
    sd.BufferDesc.Height = height;                          // высота буфера
    sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;      // формат пикселя в буфере
    sd.BufferDesc.RefreshRate.Numerator = 75;         // частота обновления экрана
    sd.BufferDesc.RefreshRate.Denominator = 1;
    sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; // назначение буфера - задний буфер
    sd.OutputWindow = g_hWnd;                               // привязываем к нашему окну
    sd.SampleDesc.Count = 1;
    sd.SampleDesc.Quality = 0;
    sd.Windowed = TRUE;                               // не полноэкранный режим
 
    for ( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ )
    {
        g_driverType = driverTypes[driverTypeIndex];
        hr = D3D11CreateDeviceAndSwapChain ( NULL, g_driverType, NULL, createDeviceFlags, featureLevels, numFeatureLevels, D3D11_SDK_VERSION, &sd, 
                                            &g_pSwapChain, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext );
        if (SUCCEEDED(hr))
            break;
    }
    if (FAILED(hr)) return hr;
 
    // Теперь создаем задний буфер. Обратите внимание, в SDK
    // RenderTargetOutput - это передний буфер, а RenderTargetView - задний.
    ID3D11Texture2D* pBackBuffer = NULL;
    hr = g_pSwapChain->GetBuffer( 0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer );
    if (FAILED(hr)) return hr;
 
    // Я уже упоминал, что интерфейс g_pd3dDevice будет
    // использоваться для создания остальных объектов
    hr = g_pd3dDevice->CreateRenderTargetView ( pBackBuffer, NULL, &g_pRenderTargetView );
    pBackBuffer->Release();
    if (FAILED(hr)) return hr;
 
    // Подключаем объект заднего буфера к контексту устройства
    g_pImmediateContext->OMSetRenderTargets( 1, &g_pRenderTargetView, NULL );
 
    // Настройка вьюпорта
    D3D11_VIEWPORT vp;
    vp.Width = (FLOAT)width;
    vp.Height = (FLOAT)height;
    vp.MinDepth = 0.0f;
    vp.MaxDepth = 1.0f;
    vp.TopLeftX = 0;
    vp.TopLeftY = 0;
 
    // Подключаем вьюпорт к контексту устройства
    g_pImmediateContext->RSSetViewports( 1, &vp );
 
    return S_OK;
}
//--------------------------------------------------------------------------------------
// Удалить все созданные объекты
//--------------------------------------------------------------------------------------
void CleanupDevice()
{
    // Сначала отключим контекст устройства, потом отпустим объекты.
    if ( g_pImmediateContext ) g_pImmediateContext->ClearState();
    // Порядок удаления имеет значение. Обратите внимание, мы удалеям
    // эти объекты порядке, обратном тому, в котором создавали.
    if ( g_pRenderTargetView ) g_pRenderTargetView->Release();
    if ( g_pSwapChain ) g_pSwapChain->Release();
    if ( g_pImmediateContext ) g_pImmediateContext->Release();
    if ( g_pd3dDevice ) g_pd3dDevice->Release();
}
//--------------------------------------------------------------------------------------
// Рисование кадра
//--------------------------------------------------------------------------------------
void Render()
{
    // Просто очищаем задний буфер
    float ClearColor[4] = { 0.0f, 0.0f, 1.0f, 1.0f }; // красный, зеленый, синий, альфа-канал
    g_pImmediateContext->ClearRenderTargetView( g_pRenderTargetView, ClearColor );
    // Выбросить задний буфер на экран
    g_pSwapChain->Present( 0, 0 );
}
//--------------------------------------------------------------------------------------
// Вызывается каждый раз, когда приложение получает сообщение
//--------------------------------------------------------------------------------------
LRESULT __stdcall WndProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
  switch (msg)
  {
  case WM_DESTROY:
    PostQuitMessage(0);
    return 0;
  }
  return DefWindowProc(hWnd,msg,wParam,lParam);
}

for ( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ )
    {
        g_driverType = driverTypes[driverTypeIndex];
        hr = D3D11CreateDeviceAndSwapChain ( NULL, g_driverType, NULL, createDeviceFlags, featureLevels, numFeatureLevels, D3D11_SDK_VERSION, &sd, 
                                            &g_pSwapChain, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext );
        if (SUCCEEDED(hr))
            break;
    }

1>main.obj : error LNK2019: ссылка на неразрешенный внешний символ _D3D11CreateDeviceAndSwapChain@48 в функции "long __cdecl InitDevice(void)" (?InitDevice@@YAJXZ)
1>C:\Users\DoctorBooooom\YandexDisk\Документы\Projects\DirectX\Debug\DirectX.exe : fatal error LNK1120: 1 неразрешенных внешних элементов