Viewport.cpp

Go to the documentation of this file.

#include "Viewport.h"

Viewport::Viewport(Bus* prmBus, Logger* prmLogger)
{
        bus = prmBus;
        logger = prmLogger;
}

void Viewport::Initialize(HINSTANCE hInstance)
{
        HRESULT hr;

        // Create the DXGI Factory
        V(CreateDXGIFactory(IID_IDXGIFactory, reinterpret_cast<void**>(&g_pDXGIFactory)));

        // Enumerate Adapters
        V(EnumerateAdapters());

        // Create the window class
        V(CreateWindowClass(hInstance));

        // Create a window per monitor
        V(CreateMonitorWindows());

        // Set DXGI Window association for the first monitor window
        V(SetWindowAssociation());

        // Create a device per adapter or device per output
        V(CreateDevicePerAdapter(D3D10_DRIVER_TYPE_HARDWARE));

        // Create a swap chain for each output
        V(CreateSwapChainPerOutput());

        for (UINT i = 0; i < screens.size(); i++)
        {
                for (int o = 0; o < g_WindowObjects.GetSize(); o++)
                {
                        WINDOW_OBJECT* pWindow = g_WindowObjects.GetAt(o);
                        if (screens.at(i).adapter == pWindow->AdapterOrdinal &&
                                screens.at(i).window == pWindow->WindowOrdinal)
                        {
                                screens.at(i).Initialize(logger, pWindow, fonts.at(0).pFont);
                                for (UINT j = 0; j < screens.at(i).pages.size(); j++)
                                {
                                        Page* page = &screens.at(i).pages.at(j);
                                        page->Initialize(bus, logger, pWindow->pDevice, pWindow->Width, pWindow->Height, &fonts, screens.at(i).flip);
                                }
                        }
                }
        }

        for (UINT i = 0; i < screens.size(); i++)
        {
                if (!screens.at(i).initialized)
                {
                        char msg[99];
                        sprintf_s(msg, 99, "Viewport::Initialize Screen %s (%i) not associated with an active window, removing...", screens.at(i).name.c_str(), i);
                        logger->Log(msg, Logger::Error);
                        screens.erase(screens.begin() + i);
                        i--;
                }
        }
}

void Viewport::Render(float fElapsed)
{
        DXUT_BeginPerfEvent(DXUT_PERFEVENTCOLOR, L"Viewport Render Loop");
        for (UINT i = 0; i < screens.size(); i++)
        {
                Screen* screen = &screens.at(i); // otherwise Doxygen doesn't see it!
                screen->Render(fElapsed);
        }
        DXUT_EndPerfEvent();

        DXUT_BeginPerfEvent(DXUT_PERFEVENTCOLOR, L"Viewport Present Loop");
        for (UINT i = 0; i < screens.size(); i++)
        {
                Screen* screen = &screens.at(i); // otherwise Doxygen doesn't see it!
                screen->Present();
        }
        DXUT_EndPerfEvent();
}

Viewport::~Viewport()
{
}

//--------------------------------------------------------------------------------------
// Enumerate all D3D10 Adapters
//--------------------------------------------------------------------------------------
HRESULT Viewport::EnumerateAdapters()
{
        HRESULT hr;

        for (UINT i = 0;; i++)
        {
                ADAPTER_OBJECT* pAdapterObj = new ADAPTER_OBJECT;
                if (!pAdapterObj)
                {
                        return E_OUTOFMEMORY;
                }

                pAdapterObj->pDXGIAdapter = nullptr;
                hr = g_pDXGIFactory->EnumAdapters(i, &pAdapterObj->pDXGIAdapter);
                if (DXGI_ERROR_NOT_FOUND == hr)
                {
                        SAFE_DELETE(pAdapterObj);
                        hr = S_OK;
                        break;
                }
                if (FAILED(hr))
                {
                        SAFE_DELETE(pAdapterObj);
                        return hr;
                }

                // get the description of the adapter
                DXGI_ADAPTER_DESC AdapterDesc;
                hr = pAdapterObj->pDXGIAdapter->GetDesc(&AdapterDesc);
                if (FAILED(hr))
                {
                        SAFE_DELETE(pAdapterObj);
                        return hr;
                }

                // Enumerate outputs for this adapter
                hr = EnumerateOutputs(pAdapterObj);
                if (FAILED(hr))
                {
                        SAFE_DELETE(pAdapterObj);
                        return hr;
                }

                size_t mbAvail = AdapterDesc.DedicatedVideoMemory / 1048576;
                if (mbAvail == 0)
                        break;

                char msg[199];
                sprintf_s(msg, 199, "Viewport::EnumerateAdapter %i GetAvailableTextureMem: %i MB", i, mbAvail);
                logger->Log(msg);

                // add the adapter to the list
                if (pAdapterObj->DXGIOutputArray.GetSize() > 0)
                        g_AdapterArray.Add(pAdapterObj);
        }

        if (g_AdapterArray.GetSize() == 0)
                return E_FAIL;

        return hr;
}

//--------------------------------------------------------------------------------------
// Enumerate all D3D10 Outputs
//--------------------------------------------------------------------------------------
HRESULT Viewport::EnumerateOutputs(ADAPTER_OBJECT* pAdapterObj)
{
        HRESULT hr;

        for (UINT i = 0;; i++)
        {
                IDXGIOutput* pOutput;
                hr = pAdapterObj->pDXGIAdapter->EnumOutputs(i, &pOutput);
                if (DXGI_ERROR_NOT_FOUND == hr)
                {
                        hr = S_OK;
                        break;
                }
                if (FAILED(hr))
                        return hr;

                // get the description
                DXGI_OUTPUT_DESC OutputDesc;
                hr = pOutput->GetDesc(&OutputDesc);
                if (FAILED(hr))
                        return hr;

                // only add outputs that are attached to the desktop
                // TODO: AttachedToDesktop seems to be always 0
                /*if( !OutputDesc.AttachedToDesktop )
                {
                pOutput->Release();
                continue;
                }*/

                pAdapterObj->DXGIOutputArray.Add(pOutput);
        }

        return hr;
}

//--------------------------------------------------------------------------------------
// Creates and register the window class
//--------------------------------------------------------------------------------------
HRESULT Viewport::CreateWindowClass(HINSTANCE hInstance)
{
        WCHAR szExePath[MAX_PATH];
        GetModuleFileName(nullptr, szExePath, MAX_PATH);
        HICON hIcon = ExtractIcon(hInstance, szExePath, 0);

        ZeroMemory(&g_WindowClass, sizeof(WNDCLASS));
        g_WindowClass.hCursor = nullptr;// LoadCursor(NULL, IDC_ARROW);
        g_WindowClass.hIcon = hIcon;
        g_WindowClass.hbrBackground = static_cast<HBRUSH>(GetStockObject(BLACK_BRUSH));
        g_WindowClass.style = CS_DBLCLKS;
        g_WindowClass.lpfnWndProc = DXUTStaticWndProc;
        g_WindowClass.hInstance = hInstance;
        g_WindowClass.lpszClassName = WindowClassStr;

        ATOM ClassAtom = RegisterClass(&g_WindowClass);
        if (ClassAtom == 0)
        {
                DWORD error = GetLastError();

                if (ERROR_CLASS_ALREADY_EXISTS != error)
                {
                        return E_FAIL;
                }
        }

        return S_OK;
}

//--------------------------------------------------------------------------------------
// Creates windows for all monitors
//--------------------------------------------------------------------------------------
HRESULT Viewport::CreateMonitorWindows()
{
        HRESULT hr = S_OK;

        for (int a = 0; a < g_AdapterArray.GetSize(); a++)
        {
                ADAPTER_OBJECT* pAdapter = g_AdapterArray.GetAt(a);
                for (int o = 0; o < pAdapter->DXGIOutputArray.GetSize(); o++)
                {
                        IDXGIOutput* pOutput = pAdapter->DXGIOutputArray.GetAt(o);
                        DXGI_OUTPUT_DESC OutputDesc;
                        pOutput->GetDesc(&OutputDesc);
                        int X = OutputDesc.DesktopCoordinates.left;
                        int Y = OutputDesc.DesktopCoordinates.top;
                        int Width = OutputDesc.DesktopCoordinates.right - X;
                        int Height = OutputDesc.DesktopCoordinates.bottom - Y;

                        WINDOW_OBJECT* pWindow = new WINDOW_OBJECT;
                        ZeroMemory(pWindow, sizeof(WINDOW_OBJECT));
                        pWindow->AdapterOrdinal = a;
                        pWindow->WindowOrdinal = o;

                        char msg[199];
                        sprintf_s(msg, 199, "Viewport::CreateMonitorWindows (adapter %i, window %i) %S (%ix%i)", a, o, OutputDesc.DeviceName, Width, Height);
                        logger->Log(msg);

                        pWindow->hWnd = CreateWindow(WindowClassStr,
                                L"Avionics",
                                WS_POPUP,
                                X,
                                Y,
                                Width,
                                Height,
                                NULL,
                                NULL,
                                g_WindowClass.hInstance,
                                NULL);

                        if (NULL == pWindow->hWnd)
                        {
                                SAFE_DELETE(pWindow);
                                return E_FAIL;
                        }

                        // show the window
                        ShowWindow(pWindow->hWnd, SW_SHOWDEFAULT);
                        SetCursor(nullptr);

                        // set width and height
                        pWindow->Width = Width;
                        pWindow->Height = Height;

                        // add this to the window object array
                        g_WindowObjects.Add(pWindow);
                }
        }

        return hr;
}

//--------------------------------------------------------------------------------------
// Set DXGI's window association
//--------------------------------------------------------------------------------------
HRESULT Viewport::SetWindowAssociation() const
{
        if (g_WindowObjects.GetSize() == 0)
                return E_FAIL;

        HWND hWnd = g_WindowObjects.GetAt(0)->hWnd;

        // set window association
        return g_pDXGIFactory->MakeWindowAssociation(hWnd, 0);
}

//--------------------------------------------------------------------------------------
// Creates a device per adapter
//--------------------------------------------------------------------------------------
HRESULT Viewport::CreateDevicePerAdapter(D3D10_DRIVER_TYPE DriverType)
{
        HRESULT hr = S_OK;
        int iWindowObj = 0;
        for (int a = 0; a < g_AdapterArray.GetSize(); a++)
        {
                ADAPTER_OBJECT* pAdapterObj = g_AdapterArray.GetAt(a);

                IDXGIAdapter* pAdapter = nullptr;
                if (D3D10_DRIVER_TYPE_HARDWARE == DriverType)
                        pAdapter = pAdapterObj->pDXGIAdapter;

                DEVICE_OBJECT* pDevice = new DEVICE_OBJECT;
                ZeroMemory(pDevice, sizeof(DEVICE_OBJECT));

                UINT CreateFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE;

                // Create a device for this adapter
                V_RETURN(D3D10CreateDevice(pAdapter, DriverType, NULL, CreateFlags, D3D10_SDK_VERSION, &pDevice->pd3dDevice));

                // add the device
                pDevice->Ordinal = g_DeviceArray.GetSize();
                g_DeviceArray.Add(pDevice);

                // Init stuff needed for the device
                OnD3D10CreateDevice(pDevice);

                // go through the outputs and set the device, adapter, and output
                for (int o = 0; o < pAdapterObj->DXGIOutputArray.GetSize(); o++)
                {
                        IDXGIOutput* pOutput = pAdapterObj->DXGIOutputArray.GetAt(o);
                        WINDOW_OBJECT* pWindow = g_WindowObjects.GetAt(iWindowObj);

                        pWindow->pDevice = pDevice;
                        pWindow->pAdapter = pAdapter;
                        pWindow->pOutput = pOutput;
                        iWindowObj++;
                }
        }

        return hr;
}

//--------------------------------------------------------------------------------------
// Creates a swapchain per output
//--------------------------------------------------------------------------------------
HRESULT Viewport::CreateSwapChainPerOutput() const
{
        HRESULT hr = S_OK;
        for (int i = 0; i < g_WindowObjects.GetSize(); i++)
        {
                WINDOW_OBJECT* pWindow = g_WindowObjects.GetAt(i);

                // get the dxgi device
                IDXGIDevice* pDXGIDevice = nullptr;
                V_RETURN(pWindow->pDevice->pd3dDevice->QueryInterface(IID_IDXGIDevice, reinterpret_cast<void**>(&pDXGIDevice)));

                // create a swap chain
                DXGI_SWAP_CHAIN_DESC SwapChainDesc;
                ZeroMemory(&SwapChainDesc, sizeof(DXGI_SWAP_CHAIN_DESC));
                SwapChainDesc.BufferDesc.Width = pWindow->Width;
                SwapChainDesc.BufferDesc.Height = pWindow->Height;
                SwapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
                SwapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
                SwapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
                SwapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
                SwapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
                SwapChainDesc.SampleDesc.Count = 1;
                SwapChainDesc.SampleDesc.Quality = 0;
                SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
                SwapChainDesc.BufferCount = 3;
                SwapChainDesc.OutputWindow = pWindow->hWnd;
                SwapChainDesc.Windowed = !exclusiveMode;
                SwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
                SwapChainDesc.Flags = 0;
                V_RETURN(g_pDXGIFactory->CreateSwapChain(pDXGIDevice, &SwapChainDesc, &pWindow->pSwapChain));

                pDXGIDevice->Release();

                V_RETURN(CreateViewsForWindowObject(pWindow));
        }

        return hr;
}

//--------------------------------------------------------------------------------------
// Create any D3D10 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT Viewport::OnD3D10CreateDevice(DEVICE_OBJECT* pDevice)
{
        HRESULT hr;
        logger->Log("Viewport::OnD3D10CreateDevice");

        for (UINT i = 0; i < fonts.size(); i++)
        {
                Font* font = &fonts.at(i);
                font->OnD3D10CreateDevice(logger, pDevice->pd3dDevice);
        }

        if (FAILED(hr = D3DX10CreateSprite(pDevice->pd3dDevice, 1, &pDevice->pSprite)))
        {
                logger->Log("Viewport::OnD3D10CreateDevice D3DX10CreateSprite failed!", Logger::Error, hr);
        }

        return S_OK;
}

//--------------------------------------------------------------------------------------
// Creates a render target view and depth stencil surface/view per swapchain
//--------------------------------------------------------------------------------------
HRESULT Viewport::CreateViewsForWindowObject(WINDOW_OBJECT* pWindow)
{
        HRESULT hr;

        // get the backbuffer
        ID3D10Texture2D* pBackBuffer = nullptr;
        hr = pWindow->pSwapChain->GetBuffer(0, IID_ID3D10Texture2D, reinterpret_cast<void**>(&pBackBuffer));
        if (FAILED(hr))
                return hr;

        // get the backbuffer desc
        D3D10_TEXTURE2D_DESC BBDesc;
        pBackBuffer->GetDesc(&BBDesc);

        // create the render target view
        D3D10_RENDER_TARGET_VIEW_DESC RTVDesc;
        RTVDesc.Format = BBDesc.Format;
        RTVDesc.ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2D;
        RTVDesc.Texture2D.MipSlice = 0;
        hr = pWindow->pDevice->pd3dDevice->CreateRenderTargetView(pBackBuffer, &RTVDesc, &pWindow->pRenderTargetView);
        pBackBuffer->Release();
        pBackBuffer = nullptr;
        if (FAILED(hr))
                return hr;

        // Create depth stencil texture
        ID3D10Texture2D* pDepthStencil = nullptr;
        D3D10_TEXTURE2D_DESC descDepth;
        descDepth.Width = pWindow->Width;
        descDepth.Height = pWindow->Height;
        descDepth.MipLevels = 1;
        descDepth.ArraySize = 1;
        descDepth.Format = DXGI_FORMAT_D16_UNORM;
        descDepth.SampleDesc.Count = 1;
        descDepth.SampleDesc.Quality = 0;
        descDepth.Usage = D3D10_USAGE_DEFAULT;
        descDepth.BindFlags = D3D10_BIND_DEPTH_STENCIL;
        descDepth.CPUAccessFlags = 0;
        descDepth.MiscFlags = 0;
        hr = pWindow->pDevice->pd3dDevice->CreateTexture2D(&descDepth, nullptr, &pDepthStencil);
        if (FAILED(hr))
                return hr;

        // Create the depth stencil view
        D3D10_DEPTH_STENCIL_VIEW_DESC descDSV;
        descDSV.Format = descDepth.Format;
        descDSV.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D;
        descDSV.Texture2D.MipSlice = 0;
        hr = pWindow->pDevice->pd3dDevice->CreateDepthStencilView(pDepthStencil, &descDSV, &pWindow->pDepthStencilView);
        SAFE_RELEASE(pDepthStencil);
        if (FAILED(hr))
                return hr;

        // get various information
        if (pWindow->pAdapter)
                pWindow->pAdapter->GetDesc(&pWindow->AdapterDesc);
        if (pWindow->pOutput)
                pWindow->pOutput->GetDesc(&pWindow->OutputDesc);

        return hr;
}

//--------------------------------------------------------------------------------------
// Cleanup the device and window based objects
//--------------------------------------------------------------------------------------
void Viewport::DeviceCleanup()
{
        logger->Log("Viewport::DeviceCleanup");

        // Make sure we're in windowed mode, since we cannot destroy a fullscreen swapchain
        for (int w = 0; w < g_WindowObjects.GetSize(); w++)
        {
                WINDOW_OBJECT* pWindow = g_WindowObjects.GetAt(w);
                pWindow->pSwapChain->SetFullscreenState(false, nullptr);
        }

        // cleanup window objects
        for (int w = 0; w < g_WindowObjects.GetSize(); w++)
        {
                WINDOW_OBJECT* pWindow = g_WindowObjects.GetAt(w);
                DestroyWindow(pWindow->hWnd);
                SAFE_RELEASE(pWindow->pRenderTargetView);
                SAFE_RELEASE(pWindow->pDepthStencilView);
                SAFE_RELEASE(pWindow->pSwapChain);
                SAFE_DELETE(pWindow);
        }
        g_WindowObjects.RemoveAll();

        char msg[99];
        sprintf_s(msg, 99, "Viewport::DeviceCleanup DeviceArray Size %i", g_DeviceArray.GetSize());
        logger->Log(msg);

        // cleanup devices
        for (int d = 0; d < g_DeviceArray.GetSize(); d++)
        {
                DEVICE_OBJECT* pDevice = g_DeviceArray.GetAt(d);

                sprintf_s(msg, 99, "Viewport::DeviceCleanup Calling Destroy: %i", d);
                logger->Log(msg);

                pDevice->Destroy();

                SAFE_DELETE(pDevice);
        }

        for (UINT i = 0; i < fonts.size(); i++)
        {
                fonts.at(i).DeviceCleanup();
        }

        g_DeviceArray.RemoveAll();
}

//--------------------------------------------------------------------------------------
// Cleanup everything
//--------------------------------------------------------------------------------------
void Viewport::Destroy()
{
        logger->Log("Viewport::Destroy");

        for (unsigned i = 0; i < screens.size(); i++)
        {
                for (unsigned j = 0; j < screens.at(i).pages.size(); j++)
                {
                        screens.at(i).pages.at(j).Destroy();
                }
                screens.at(i).DestroyDevice();
        }

        // Destroy devices
        DeviceCleanup();

        // Remove enumerated objects
        for (int a = 0; a < g_AdapterArray.GetSize(); a++)
        {
                ADAPTER_OBJECT* pAdapterObj = g_AdapterArray.GetAt(a);

                // go through the outputs
                for (int o = 0; o < pAdapterObj->DXGIOutputArray.GetSize(); o++)
                {
                        IDXGIOutput* pOutput = pAdapterObj->DXGIOutputArray.GetAt(o);
                        SAFE_RELEASE(pOutput);
                }
                pAdapterObj->DXGIOutputArray.RemoveAll();

                SAFE_RELEASE(pAdapterObj->pDXGIAdapter);
                SAFE_DELETE(pAdapterObj);
        }

        SAFE_RELEASE(g_pDXGIFactory);

        g_AdapterArray.RemoveAll();
}

std::vector<HWND> Viewport::GetWindowHandles() const
{
        std::vector<HWND> hwnds;
        for (int t = 0; t < g_WindowObjects.GetSize(); t++)
        {
                hwnds.push_back(g_WindowObjects.GetAt(t)->hWnd);
        }
        return hwnds;
}