spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include "mantle.h"

#include <windows.h>
#include <cassert>
#include <cstdio>
#include <malloc.h>

struct InitAndLoadMantle
{
    InitAndLoadMantle()
    {
        load();
    }

private:
    bool load()
    {
        HMODULE hModule = LoadLibrary(L"mantle64.dll");
        if (!hModule)
            return false;

        // ....

        return true;
    }
};

InitAndLoadMantle GManlteInstance;

#define CHECKED_CALL(call) if (call != GR_SUCCESS) assert(false && #call " failed...");

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case WM_CLOSE:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }

    return 0;
}

HWND createWindow()
{
    HINSTANCE hInst = GetModuleHandle(NULL);
    WNDCLASS wc = 
    {
        CS_HREDRAW | CS_VREDRAW,
        WndProc,
        0, 0,
        hInst,
        LoadIcon(NULL, IDI_APPLICATION),
        LoadCursor(NULL, IDC_ARROW),
        GetSysColorBrush(COLOR_BTNFACE),
        NULL,
        L"MantleTestWindow"
    };

    RegisterClass(&wc);

    HWND hWnd = CreateWindow(L"MantleTestWindow", L"Mantle Test Window", WS_OVERLAPPEDWINDOW, 0, 0, 800, 600, NULL, NULL, hInst, NULL);

    ShowWindow(hWnd, SW_SHOW);

    return hWnd;
}

class ImageStateTransition
{
public:
    ImageStateTransition(GR_IMAGE image, GR_IMAGE_SUBRESOURCE_RANGE subResRange, GR_ENUM currentState)
    {
        assert(image != GR_NULL_HANDLE && "invalid image");
        m_trans.image = image;
        m_trans.subresourceRange = subResRange;
        m_trans.oldState = currentState;
    }

    void submit(GR_CMD_BUFFER cmdBuffer, GR_ENUM newState)
    {
        if (m_trans.oldState == newState)
            return;

        m_trans.newState = newState;
        grCmdPrepareImages(cmdBuffer, 1, &m_trans);
        m_trans.oldState = m_trans.newState;
    }

private:
    GR_IMAGE_STATE_TRANSITION m_trans;
};

struct FrameBufferInfo
{
    GR_IMAGE backBuffer;
    GR_GPU_MEMORY backBufferMemory;
    GR_IMAGE_SUBRESOURCE_RANGE subResourceRange;
    GR_COLOR_TARGET_VIEW view;
};

bool initGraphicsDevice(GR_DEVICE& device)
{
    GR_RESULT result;
    GR_APPLICATION_INFO appInfo = {};
    appInfo.apiVersion = GR_API_VERSION;

    // get the list of all physically present gpus supporting mantle. for simplicity the first one is used for rendering
    GR_PHYSICAL_GPU gpus[GR_MAX_PHYSICAL_GPUS] = {};
    GR_UINT gpuCount = 0;
    if (grInitAndEnumerateGpus(&appInfo, NULL, &gpuCount, gpus) != GR_SUCCESS)
    {
        return false;
    }

    static const GR_CHAR* const ppExtensions[] =
    {
        (GR_CHAR*)"GR_WSI_WINDOWS"
    };

    // check first if all needed extensions are supported
    bool extensionsSupported = true;
    for (int i = 0; i < _countof(ppExtensions) && extensionsSupported; ++i)
    {
        extensionsSupported &= grGetExtensionSupport(gpus[0], ppExtensions[i]) == GR_SUCCESS;
    }

    if (!extensionsSupported)
        return false;

    // create the device and request a single queue. this is should be save since a universal queue is
    // always provided. if other queues are used (i.e. async compute) the available queues should be queried first
    GR_DEVICE_QUEUE_CREATE_INFO queueInfo = {};
    queueInfo.queueCount = GR_QUEUE_UNIVERSAL;
    queueInfo.queueCount = 1;

    GR_DEVICE_CREATE_INFO deviceInfo = {};
    deviceInfo.queueRecordCount = 1;
    deviceInfo.pRequestedQueues = &queueInfo;
    deviceInfo.extensionCount = 1;
    deviceInfo.ppEnabledExtensionNames = ppExtensions;
#if defined (DEBUG) || defined (_DEBUG)
    deviceInfo.maxValidationLevel = GR_VALIDATION_LEVEL_4;
    deviceInfo.flags |= GR_DEVICE_CREATE_VALIDATION;
#else
    deviceInfo.maxValidationLevel = GR_VALIDATION_LEVEL_0;
#endif

    device = GR_NULL_HANDLE;
    result = grCreateDevice(gpus[0], &deviceInfo, &device);
    
    return (result == GR_SUCCESS);
}

void initGlobalResources(GR_DEVICE device, HWND hWnd, GR_QUEUE& renderQueue, FrameBufferInfo& frameBufferInfo)
{
    // create the actual image object and allocate memory 
    GR_WSI_WIN_PRESENTABLE_IMAGE_CREATE_INFO backBufferInfo;
    ::ZeroMemory(&backBufferInfo, sizeof(backBufferInfo));
    backBufferInfo.extent.width = 800;
    backBufferInfo.extent.height = 600;
    backBufferInfo.format.channelFormat = GR_CH_FMT_R8G8B8A8;
    backBufferInfo.format.numericFormat = GR_NUM_FMT_SRGB;
    backBufferInfo.display = GR_NULL_HANDLE;
    backBufferInfo.usage = GR_IMAGE_USAGE_COLOR_TARGET;
    CHECKED_CALL(grWsiWinCreatePresentableImage(device, &backBufferInfo, &frameBufferInfo.backBuffer, &frameBufferInfo.backBufferMemory));

    // create color target view
    GR_COLOR_TARGET_VIEW_CREATE_INFO backbufferViewInfo;
    ::ZeroMemory(&backbufferViewInfo, sizeof(backbufferViewInfo));
    backbufferViewInfo.format = backBufferInfo.format;
    backbufferViewInfo.image = frameBufferInfo.backBuffer;
    backbufferViewInfo.arraySize = 1;
    CHECKED_CALL(grCreateColorTargetView(device, &backbufferViewInfo, &frameBufferInfo.view));

    // create subresource range for operations on the data
    ::ZeroMemory(&frameBufferInfo.subResourceRange, sizeof(GR_IMAGE_SUBRESOURCE_RANGE));
    frameBufferInfo.subResourceRange.aspect = GR_IMAGE_ASPECT_COLOR;
    frameBufferInfo.subResourceRange.arraySize = 1;
    frameBufferInfo.subResourceRange.mipLevels = 1;

    // create render queues
    CHECKED_CALL(grGetDeviceQueue(device, GR_QUEUE_UNIVERSAL, 0, &renderQueue));
}
void syncWithGPU(GR_DEVICE device, GR_FENCE fence)
{
    // stall until the command buffer execution has been completed... a better solution is to get a new command buffer out of a pool (etc...)
    if (grGetFenceStatus(fence) == GR_NOT_READY)
    {
        do {} while (grWaitForFences(device, 1, &fence, GR_TRUE, 1.0f) != GR_SUCCESS);
    }
}

int main()
{
    HWND hWnd = createWindow();

    GR_DEVICE device;
    if (!initGraphicsDevice(device))
    {
        printf("cannot initialize the graphics device\n");
        return -1;
    }

    GR_QUEUE mainQueue;
    FrameBufferInfo frameBufferInfo;
    initGlobalResources(device, hWnd, mainQueue, frameBufferInfo);

    // create a new command buffer, for this example a single one is sufficient
    GR_CMD_BUFFER_CREATE_INFO cmdBufferInfo;
    cmdBufferInfo.queueType = GR_QUEUE_UNIVERSAL;
    cmdBufferInfo.flags = 0;

    GR_CMD_BUFFER cmdBuffer;
    CHECKED_CALL(grCreateCommandBuffer(device, &cmdBufferInfo, &cmdBuffer));

    // create fence to sync with the command buffer execution
    GR_FENCE_CREATE_INFO fenceInfo = {0};

    GR_FENCE fence;
    CHECKED_CALL(grCreateFence(device, &fenceInfo, &fence));

    ImageStateTransition transition(frameBufferInfo.backBuffer, 
        frameBufferInfo.subResourceRange,
        GR_IMAGE_STATE_UNINITIALIZED);

    GR_FLOAT clearColors[][3] =
    {
        {1, 0, 0},
        {0, 1, 0},
        {0, 0, 1}
    };

    int colorIndex = 0;
    
    DWORD time = GetTickCount();

    bool exit = false;
    while (!exit)
    {
        MSG msg;
        while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            if (msg.message == WM_QUIT)
            {
                exit = true;
                break;
            }

            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        DWORD t = GetTickCount();
        if (t - time > 5000.0f)
        {
            time = t;
            colorIndex = (colorIndex + 1) % _countof(clearColors);
        }

        // synchronize with command buffer execution
        syncWithGPU(device, fence);

        // record command buffer
        CHECKED_CALL(grBeginCommandBuffer(cmdBuffer, 0));

        // clear color, image needs to be in 'clear' state
        transition.submit(cmdBuffer, GR_IMAGE_STATE_CLEAR);
        grCmdClearColorImage(cmdBuffer, frameBufferInfo.backBuffer, clearColors[colorIndex], 1, &frameBufferInfo.subResourceRange);

        // make backbuffer ready for present
        transition.submit(cmdBuffer, GR_WSI_WIN_IMAGE_STATE_PRESENT_WINDOWED);

        CHECKED_CALL(grEndCommandBuffer(cmdBuffer));

        // submit the command buffer to the queue to let the gpu process it
        GR_MEMORY_REF memRef;
        memRef.mem = frameBufferInfo.backBufferMemory;
        memRef.flags = 0;
        CHECKED_CALL(grQueueSubmit(mainQueue, 1, &cmdBuffer, 1, &memRef, fence));

        // present backbuffer
        GR_WSI_WIN_PRESENT_INFO presentInfo;
        presentInfo.hWndDest = hWnd;
        presentInfo.srcImage = frameBufferInfo.backBuffer;
        presentInfo.flags = 0;
        presentInfo.presentMode = GR_WSI_WIN_PRESENT_MODE_WINDOWED;
        presentInfo.presentInterval = 0;

        CHECKED_CALL(grWsiWinQueuePresent(mainQueue, &presentInfo));
    }

    // sync with all command queues
    grDeviceWaitIdle(device);

    // destroy all created resources
    grDestroyObject(frameBufferInfo.view);
    grDestroyObject(cmdBuffer);
    grDestroyDevice(device);
}